Warum kann ich eine Liste wie ein Array in C # initialisieren?

Heute war ich überrascht, dass ich in C # Folgendes tun kann:

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

Warum kann ich das tun? Welcher Konstruktor heißt? Wie kann ich das mit meinen eigenen Klassen machen? Ich weiß, dass dies der Weg ist, um Arrays zu initialisieren, aber Arrays sind Sprachelemente und Listen sind einfache Objekte ...

Dies ist Teil der Syntax der Auflistungsinitialisierung in .NET. Sie können diese Syntax für jede Sammlung verwenden, die Sie erstellen, solange:

• Es implementiert IEnumerable(vorzugsweise IEnumerable<T>)

• Es hat eine Methode namens Add(...)

Was passiert, ist, dass der Standardkonstruktor aufgerufen wird und dann Add(...)für jedes Mitglied des Initialisierers aufgerufen wird.

Somit sind diese beiden Blöcke ungefähr identisch:

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

Und

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

Sie können einen alternativen Konstruktor aufrufen, wenn Sie möchten, um beispielsweise eine Überdimensionierung List<T>während des Wachstums zu vermeiden usw.:

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

Beachten Sie, dass die Add()Methode kein einzelnes Element annehmen muss, z. B. die Add()Methode für Dictionary<TKey, TValue>zwei Elemente:

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

Ist ungefähr identisch mit:

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

Um dies zu Ihrer eigenen Klasse hinzuzufügen, müssen Sie, wie erwähnt, lediglich IEnumerable(vorzugsweise IEnumerable<T>) implementieren und eine oder mehrere Add()Methoden erstellen :

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

Dann können Sie es genau wie die BCL-Sammlungen verwenden:

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

    // ...
}

(Weitere Informationen finden Sie im MSDN. )

Es ist so genannter syntaktischer Zucker .

List<T> ist die "einfache" Klasse, aber der Compiler behandelt sie speziell, um Ihnen das Leben zu erleichtern.

Dieser wird als Sammlungsinitialisierer bezeichnet . Sie müssen implementieren IEnumerable<T>und Addmethodisieren.

Gemäß der C # Version 3.0-Spezifikation "Das Auflistungsobjekt, auf das ein Auflistungsinitialisierer angewendet wird, muss von einem Typ sein, der System.Collections.Generic.ICollection für genau ein T implementiert."

Diese Informationen scheinen jedoch zum Zeitpunkt dieses Schreibens ungenau zu sein. siehe Eric Lipperts Klarstellung in den Kommentaren unten.

Es funktioniert dank Sammlungsinitialisierern , für die die Sammlung grundsätzlich eine Add-Methode implementieren muss, und die die Arbeit für Sie erledigt.

Eine weitere coole Sache bei Sammlungsinitialisierern ist, dass Sie mehrere AddMethodenüberladungen haben und sie alle im selben Initialisierer aufrufen können! Zum Beispiel funktioniert dies:

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

Es ruft die richtigen Überladungen auf. Außerdem sucht es nur nach der Methode mit dem Namen Add, der Rückgabetyp kann alles sein.

Die Array-ähnliche Syntax wird in einer Reihe von Add()Aufrufen gedreht.

Um dies in einem viel interessanteren Beispiel zu sehen, betrachten Sie den folgenden Code, in dem ich zwei interessante Dinge tue, die in C # zuerst illegal klingen: 1) Festlegen einer schreibgeschützten Eigenschaft, 2) Festlegen einer Liste mit einem Array wie dem Initialisierer.

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

Dieser Code funktioniert einwandfrei, obwohl 1) MyList schreibgeschützt ist und 2) ich eine Liste mit Array-Initialisierer erstellt habe.

Der Grund, warum dies funktioniert, liegt darin, dass der Compiler in Code, der Teil eines Objektinitialisierers ist, eine {}ähnliche Syntax immer in eine Reihe von Add()Aufrufen umwandelt, die selbst in einem schreibgeschützten Feld vollkommen legal sind.