Чому я можу ініціалізувати список як масив у C #?

Сьогодні я здивовано виявив, що в C # я вмію робити:

List<int> a = new List<int> { 1, 2, 3 };

Чому я можу це зробити? Який конструктор називається? Як я можу це зробити на власних заняттях? Я знаю, що це спосіб ініціалізації масивів, але масиви - це мовні елементи, а списки - прості об'єкти ...

Це частина синтаксису ініціалізатора колекції в .NET. Ви можете використовувати цей синтаксис у будь-якій створеній вами колекції, якщо:

• Він реалізує IEnumerable(бажано IEnumerable<T>)

• Він має метод, названий Add(...)

Що відбувається - викликається конструктор за замовчуванням, а потім Add(...)викликається для кожного члена ініціалізатора.

Таким чином, ці два блоки приблизно однакові:

List<int> a = new List<int> { 1, 2, 3 };

І

List<int> temp = new List<int>();
temp.Add(1);
temp.Add(2);
temp.Add(3);
List<int> a = temp;

Ви можете зателефонувати до альтернативного конструктора, якщо ви хочете, наприклад, запобігти надмірному розміру List<T>під час вирощування тощо:

// Notice, calls the List constructor that takes an int arg
// for initial capacity, then Add()'s three items.
List<int> a = new List<int>(3) { 1, 2, 3, }

Зауважте, що Add()метод не повинен приймати жоден елемент, наприклад Add()метод для Dictionary<TKey, TValue>двох елементів:

var grades = new Dictionary<string, int>
    {
        { "Suzy", 100 },
        { "David", 98 },
        { "Karen", 73 }
    };

Приблизно ідентичний:

var temp = new Dictionary<string, int>();
temp.Add("Suzy", 100);
temp.Add("David", 98);
temp.Add("Karen", 73);
var grades = temp;

Отже, щоб додати це до власного класу, все, що вам потрібно зробити, як було сказано, - це реалізувати IEnumerable(знову ж таки бажано IEnumerable<T>) та створити один або кілька Add()методів:

public class SomeCollection<T> : IEnumerable<T>
{
    // implement Add() methods appropriate for your collection
    public void Add(T item)
    {
        // your add logic    
    }

    // implement your enumerators for IEnumerable<T> (and IEnumerable)
    public IEnumerator<T> GetEnumerator()
    {
        // your implementation
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Тоді ви можете використовувати його так само, як це роблять колекції BCL:

public class MyProgram
{
    private SomeCollection<int> _myCollection = new SomeCollection<int> { 13, 5, 7 };    

    // ...
}

(Докладнішу інформацію див. У MSDN )

Це так званий синтаксичний цукор .

List<T> є класом "простий", але компілятор надає йому спеціальну обробку, щоб полегшити ваше життя.

Це так званий ініціалізатор колекції . Вам потрібно реалізувати IEnumerable<T>і Addметод.

Відповідно до специфікації C # версії 3.0 "Об'єкт колекції, до якого застосовано ініціалізатор колекції, повинен бути такого типу, який реалізує System.Collections.Generic.ICollection точно для однієї Т."

Однак ця інформація, як видається, є неточною; див. роз'яснення Еріка Ліпперта в коментарях нижче.

Він працює завдяки ініціалізаторам колекції, які в основному вимагають, щоб колекція реалізувала метод Add, і це зробить роботу за вас.

Ще одна цікава річ щодо ініціалізаторів колекції - це те, що у вас може бути кілька перевантажень Addметоду, і ви можете викликати їх усіх в одному ініціалізаторі! Наприклад, це працює:

public class MyCollection<T> : IEnumerable<T>
{
    public void Add(T item, int number)
    {

    }
    public void Add(T item, string text) 
    {

    }
    public bool Add(T item) //return type could be anything
    {

    }
}

var myCollection = new MyCollection<bool> 
{
    true,
    { false, 0 },
    { true, "" },
    false
};

Це викликає правильні перевантаження. Крім того, він шукає лише метод з ім'ям Add, тип повернення може бути чим завгодно.

Масив, як синтаксис, перетворюється в ряд Add()дзвінків.

Щоб побачити це в набагато цікавішому прикладі, розгляньте наступний код, в якому я роблю дві цікаві речі, які звучать спочатку незаконно в C #, 1) встановлення властивості лише для читання; 2) встановлення списку з масивом, подібним до ініціалізатора.

public class MyClass
{   
    public MyClass()
    {   
        _list = new List<string>();
    }
    private IList<string> _list;
    public IList<string> MyList 
    { 
        get
        { 
            return _list;
        }
    }
}
//In some other method
var sample = new MyClass
{
    MyList = {"a", "b"}
};

Цей код буде відмінно працювати, хоча 1) MyList читається тільки 2) Я встановлюю список з ініціалізатором масиву.

Причина, чому це працює, полягає в тому, що в коді, який є частиною об'єктного ініціалізатора, компілятор завжди перетворює {}подібний синтаксис до серії Add()викликів, які є абсолютно законними навіть у полі для читання.