Pourquoi ne puis-je initialiser une Liste comme un tableau en C#?

Cela fait partie de la collection d'initialiseur de la syntaxe .NET. Vous pouvez utiliser cette syntaxe sur toute collection, vous créez tant que:

• Il met en œuvre IEnumerable (de préférence IEnumerable<T>)

• Il a une méthode nommée Add(...)

Ce qui se passe est le constructeur par défaut est appelé, et puis Add(...) est appelée pour chaque membre de l'initialiseur.

Ainsi, ces deux blocs sont à peu près identiques:

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

Et

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

Vous peut appeler un autre constructeur, si vous voulez, par exemple pour éviter le sur-dimensionnement de la List<T> pendant la culture, etc:

//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, }

Noter que le Add() méthode n'a pas besoin de prendre un seul élément, par exemple le Add() méthode pour Dictionary<TKey, TValue> prend deux éléments:

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

Est à peu près identique:

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

Donc, pour l'ajouter à votre propre classe, tout ce que vous devez faire, comme mentionné, est de mettre en œuvre IEnumerable (encore une fois, de préférence IEnumerable<T>) et de créer un ou plusieurs Add() méthodes:

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();
    }
}

Alors vous pouvez l'utiliser comme la BCL collections:

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

    //...
}

(Pour plus d'informations, voir la MSDN)

Selon la Version De C# 3.0 Spécification "L'objet de collection à laquelle un initialiseur de collection est appliqué doit être d'un type qui implémente le Système.Les Collections.Génériques.ICollection exactement un T."

Toutefois, cette information semble être inexactes de cette écriture; voir Eric Lippert de précisions dans les commentaires ci-dessous.

Une autre chose cool à propos de la collecte des initialiseurs est que vous pouvez avoir plusieurs surcharges de Add méthode et vous pouvez les appeler tous dans le même initialiseur! Par exemple cela fonctionne:

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
};

Il appelle la bonne surcharges. Aussi, il semble juste pour la méthode avec le nom Add, le type de retour pourrait être n'importe quoi.