Почему я могу инициализировать список как массив в 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 ровно для одного T.»

Однако на момент написания эта информация кажется неточной; см. пояснение Эрика Липперта в комментариях ниже.

Он работает благодаря инициализаторам коллекций, которые в основном требуют, чтобы коллекция реализовывала метод 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) установка свойства readonly, 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()вызовов, которые совершенно допустимы даже в поле только для чтения.