Perché posso inizializzare un elenco come un array in C #?

Oggi sono stato sorpreso di scoprire che in C # posso fare:

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

Perché posso farlo? Quale costruttore si chiama? Come posso farlo con le mie lezioni? So che questo è il modo di inizializzare le matrici ma le matrici sono voci di linguaggio e le liste sono oggetti semplici ...

Questo fa parte della sintassi dell'inizializzatore di raccolte in .NET. Puoi utilizzare questa sintassi su qualsiasi raccolta che crei purché:

• Implementa IEnumerable(preferibilmente IEnumerable<T>)

• Ha un metodo chiamato Add(...)

Ciò che accade è il costruttore predefinito che viene chiamato e quindi Add(...)viene chiamato per ciascun membro dell'inizializzatore.

Pertanto, questi due blocchi sono approssimativamente identici:

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

E

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

È possibile chiamare un costruttore alternativo, se si desidera, ad esempio per evitare sovra-dimensionamento della List<T>durante la crescita, ecc:

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

Si noti che il Add()metodo non deve prendere un singolo elemento, ad esempio il Add()metodo per Dictionary<TKey, TValue>accetta due elementi:

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

È approssimativamente identico a:

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

Quindi, per aggiungere questo alla tua classe, tutto ciò che devi fare, come detto, è implementare IEnumerable(di nuovo, preferibilmente IEnumerable<T>) e creare uno o più Add()metodi:

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

Quindi puoi usarlo proprio come fanno le raccolte BCL:

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

    // ...
}

(Per ulteriori informazioni, consultare MSDN )

Si chiama zucchero sintattico .

List<T> è la classe "semplice", ma il compilatore offre un trattamento speciale per semplificarti la vita.

Questo è il cosiddetto inizializzatore di raccolta . È necessario implementare IEnumerable<T>e Addmetodo.

Secondo le specifiche della versione 3.0 di C # "L'oggetto di raccolta a cui viene applicato un inizializzatore di raccolta deve essere di un tipo che implementa System.Collections.Generic.ICollection esattamente per un T."

Tuttavia, queste informazioni sembrano essere inaccurate al momento della stesura di questo documento; vedere i chiarimenti di Eric Lippert nei commenti qui sotto.

Funziona grazie agli inizializzatori di raccolta che in sostanza richiedono alla raccolta di implementare un metodo Add e che farà il lavoro per te.

Un'altra cosa interessante degli inizializzatori di raccolta è che puoi avere più sovraccarichi di Addmetodo e puoi chiamarli tutti nello stesso inizializzatore! Ad esempio questo funziona:

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

Chiama i sovraccarichi corretti. Inoltre, cerca solo il metodo con nome Add, il tipo restituito potrebbe essere qualsiasi cosa.

La matrice come sintassi viene trasformata in una serie di Add()chiamate.

Per vedere questo in un esempio molto più interessante, considera il seguente codice in cui faccio due cose interessanti che sembrano prima illegali in C #, 1) impostazione di una proprietà di sola lettura, 2) impostazione di un elenco con un array come l'inizializzatore.

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

Questo codice funzionerà perfettamente, anche se 1) MyList è di sola lettura e 2) Ho impostato un elenco con inizializzatore di array.

Il motivo per cui funziona, è perché nel codice che fa parte di un intializzatore di oggetti il ​​compilatore trasforma sempre qualsiasi {}sintassi simile in una serie di Add()chiamate che sono perfettamente legali anche su un campo di sola lettura.