C# Language
Inicjatory kolekcji

Uwagi

Inicjatory kolekcji

Zainicjuj typ kolekcji wartościami:

var stringList = new List<string>
{
    "foo",
    "bar",
};

Inicjatory kolekcji to cukier składniowy dla wywołań Add() . Powyższy kod jest równoważny z:

var temp = new List<string>();
temp.Add("foo");
temp.Add("bar");
var stringList = temp;

Należy zauważyć, że inicjalizacja odbywa się atomowo przy użyciu zmiennej tymczasowej, aby uniknąć warunków wyścigu.

W przypadku typów, które oferują wiele parametrów w metodzie Add() , umieść argumenty oddzielone przecinkami w nawiasach klamrowych:

var numberDictionary = new Dictionary<int, string>
{
    { 1, "One" },
    { 2, "Two" },
};

Jest to równoważne z:

var temp = new Dictionary<int, string>();
temp.Add(1, "One");
temp.Add(2, "Two");
var numberDictionarynumberDictionary = temp;

Inicjatory indeksu C # 6

Począwszy od C # 6, kolekcje z indeksatorami można zainicjować, określając indeks do przypisania w nawiasach kwadratowych, następnie znak równości, a następnie wartość do przypisania.

Inicjalizacja słownika

Przykład tej składni przy użyciu słownika:

var dict = new Dictionary<string, int>
{
    ["key1"] = 1,
    ["key2"] = 50
};

Jest to równoważne z:

var dict = new Dictionary<string, int>();
dict["key1"] = 1;
dict["key2"] = 50

Składnia inicjalizująca kolekcję, aby to zrobić przed C # 6, brzmiała:

var dict = new Dictionary<string, int>
{
    { "key1", 1 },
    { "key2", 50 }
};

Co odpowiada:

var dict = new Dictionary<string, int>();
dict.Add("key1", 1);
dict.Add("key2", 50);

Istnieje więc znacząca różnica w funkcjonalności, ponieważ nowa składnia używa indeksu zainicjowanego obiektu do przypisywania wartości zamiast używania metody Add() . Oznacza to, że nowa składnia wymaga tylko publicznie dostępnego indeksatora i działa dla każdego obiektu, który go posiada.

public class IndexableClass
{
    public int this[int index]
    {
        set 
        { 
            Console.WriteLine("{0} was assigned to index {1}", value, index);
        }
    }
}

var foo = new IndexableClass
{
    [0] = 10,
    [1] = 20
}

To dałoby wynik:

10 was assigned to index 0
20 was assigned to index 1

Inicjatory kolekcji w klasach niestandardowych

Aby zainicjować kolekcję obsługi klas, musi ona implementować interfejs IEnumerable i mieć co najmniej jedną metodę Add . Od C # 6 każdą kolekcję implementującą IEnumerable można rozszerzyć o niestandardowe metody Add przy użyciu metod rozszerzenia.

class Program
{
    static void Main()
    {
        var col = new MyCollection {
            "foo",
            { "bar", 3 },
            "baz",
            123.45d,
        };
    }
}

class MyCollection : IEnumerable
{
    private IList list = new ArrayList();

    public void Add(string item)
    {
        list.Add(item)
    }

    public void Add(string item, int count)
    {
        for(int i=0;i< count;i++) {
            list.Add(item);
        }
    }

    public IEnumerator GetEnumerator()
    {
        return list.GetEnumerator();
    }
}

static class MyCollectionExtensions
{
    public static void Add(this MyCollection @this, double value) => 
        @this.Add(value.ToString());
}

Inicjatory kolekcji z tablicami parametrów

Możesz mieszać normalne parametry i tablice parametrów:

public class LotteryTicket : IEnumerable{
    public int[] LuckyNumbers;
    public string UserName;

    public void Add(string userName, params int[] luckyNumbers){
        UserName = userName;
        Lottery = luckyNumbers;
    }
}

Ta składnia jest teraz możliwa:

var Tickets = new List<LotteryTicket>{
    {"Mr Cool"  , 35663, 35732, 12312, 75685},
    {"Bruce"    , 26874, 66677, 24546, 36483, 46768, 24632, 24527},
    {"John Cena", 25446, 83356, 65536, 23783, 24567, 89337}
}

Korzystanie z inicjalizatora kolekcji w inicjalizatorze obiektów

public class Tag
{
    public IList<string> Synonyms { get; set; }
}

Synonyms to właściwość typu kolekcji. Gdy obiekt Tag jest tworzony przy użyciu składni inicjalizującej obiekt, Synonyms można również inicjować za pomocą składni inicjalizującej kolekcję:

Tag t = new Tag 
{
    Synonyms = new List<string> {"c#", "c-sharp"}
};

Właściwość kolekcji może być tylko do odczytu i nadal obsługuje składnię inicjatora kolekcji. Rozważ ten zmodyfikowany przykład (właściwość Synonyms ma teraz prywatny ustawiacz):

public class Tag
{
    public Tag()
    {
        Synonyms = new List<string>();
    }
    
    public IList<string> Synonyms { get; private set; }
}

Nowy obiekt Tag można utworzyć w następujący sposób:

Tag t = new Tag 
{
    Synonyms = {"c#", "c-sharp"}
};

Działa to, ponieważ inicjalizatory kolekcji to po prostu cukier syntetyczny nad wywołaniami Add() . Nie tworzy się tutaj żadnej nowej listy, kompilator generuje tylko wywołania Add() na wychodzącym obiekcie.