Object initializer

C# esetén lehetőségünk van arra, hogy az osztályunk tagváltozóinak közvetlenül a létrehozásukkor adjunk értéket, ezzel elkerülve azt, hogy konstruktort írjunk. Ez azzal az előnyel jár, hogy egy kis osztály esetén, ahol maximum 3-4 tag van, nem kell egy külön metódust írnunk.

Property-k, tulajdonságok esetén, ha a tulajdonság kívülről is írható, akkor konstruktor nélkül, közvetlenül a tulajdonságok értékeinek megadásával is inicializálhatjuk az objektumunkat. Ezt hívjuk object initializernek.

Nézzünk rá egy példát:

using System;

public class ObjInitPelda
{
    public int X { get; set; }
    public int Y { get; set; }
    public int Z { get; set; }
}

internal class Program
{
    private static void Main(string[] args)
    {
        ObjInitPelda obj = new()
        {
            X = 1,
            Y = 2,
            Z = 3
        };

        Console.WriteLine("x: {0}, y: {1}, z: {2}", obj.X, obj.Y, obj.Z);
        Console.ReadKey();
    }
}

A program kimenete:

x: 1, y: 2, z: 3

Az initializer szintaxis kifejezetten akkor hasznos, ha az osztályunk összetett. Az ilyen osztályok esetén ha konstruktort alkalmazunk, akkor a paraméterszám növekedésével egyenes arányban csökken a kód karbantarthatósága, de nem is feltétlen kell hozzá sok paraméter. Tételezzük fel, hogy egy olyan osztályt modellezünk, ami beállításokat ír le. A konstruktora meghívva így néz ki: new Settings(true, false, true). Ezt elolvasva fogalmunk sincs arról, hogy mit is állít be igazra és hamisra a konstruktor.

Ilyen esetekben az initializer mindig egy jobb megoldás, mivel explicit kötelező megadni a beállított tulajdonságok nevét.

Megjegyzés: az initializer egy opcionális szolgáltatás. Alapértelmezetten semmilyen kényszer nincs, ami megkövetelné, hogy az objektum létrehozásakor meg kelljen adni egy tulajdonság értékét. Éppen ezért az initializer nem feltétlen a konstruktor alternatívája, inkább kiegészítÅ‘ társa. Ha C# 11 vagy újabb verzióval dolgozunk, akkor a required kulcsszóval kiegészítve egy tulajdonságot kikényszeríthetjük, hogy a létrehozáskor explicit értéket kelljen neki adni. ErrÅ‘l a késÅ‘bbiekben lesz szó.

Sorrendek

Az object initializer futása minden esetben a konstruktor futása után következik be. Ha több tulajdonságunk van, akkor a tulajdonságok megadásának sorrendjében történik az inicializáció.

A konstruktoron kívüli osztály tagváltozók inicializációja minden esetben megelőzi a konstruktor futását és a definíció/értékadás sorrendjében történik a futtatásuk. Az alábbi példaprogram ezt szemlélteti:

using System;

public class FieldPelda
{
    public FieldPelda(string name)
    {
        Console.WriteLine("{0} inicializáció", name);
    }
}

public class InitSorrendPelda
{
    private readonly FieldPelda fieldPelda2 = new FieldPelda("fieldPelda2");
    private readonly FieldPelda fieldPelda = new FieldPelda("fieldPelda");
    private int _backField;
    private int _backField2;

    public InitSorrendPelda()
    {
        Console.WriteLine("Konstruktor");
    }

    public int Property
    {
        get { return _backField; }
        set
        {
            _backField = value;
            Console.WriteLine("Property inicializáció");
        }
    }

    public int Property2
    {
        get { return _backField2; }
        set
        {
            _backField2 = value;
            Console.WriteLine("Property2 inicializáció");
        }
    }
}

public class Program
{
    private static void Main(string[] args)
    {
        InitSorrendPelda fieldPelda = new InitSorrendPelda()
        {
            Property2 = 11,
            Property = 42
        };
    }
}

A program kimenete:

fieldPelda2 inicializáció
fieldPelda inicializáció
Konstruktor
Property2 inicializáció
Property inicializáció