Tutte le possibili sintassi di inizializzazione dell'array

Questi sono i metodi di dichiarazione e inizializzazione correnti per un array semplice.

string[] array = new string[2]; // creates array of length 2, default values
string[] array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
string[] array = new[] { "A", "B" }; // created populated array of length 2

Nota che esistono altre tecniche per ottenere array, come Linq ToArray() estensioni su IEnumerable<T> .

Nota anche che nelle dichiarazioni precedenti, i primi due potrebbero sostituire il string[] a sinistra con var (C# 3+), poiché le informazioni a destra sono sufficienti per dedurre il tipo corretto. La terza riga deve essere scritta come visualizzata, poiché la sintassi di inizializzazione dell'array da sola non è sufficiente per soddisfare le richieste del compilatore. Il quarto potrebbe anche usare l'inferenza. Quindi, se ti interessa tutta la brevità, quanto sopra potrebbe essere scritto come

var array = new string[2]; // creates array of length 2, default values
var array = new string[] { "A", "B" }; // creates populated array of length 2
string[] array = { "A" , "B" }; // creates populated array of length 2
var array = new[] { "A", "B" }; // created populated array of length 2 

Le sintassi di creazione della matrice in C# che sono espressioni sono:

new int[3]
new int[3] { 10, 20, 30 }
new int[] { 10, 20, 30 }
new[] { 10, 20, 30 }

Nel primo, la dimensione può essere qualsiasi valore integrale non negativo e gli elementi dell'array vengono inizializzati sui valori predefiniti.

Nel secondo, la dimensione deve essere una costante e il numero di elementi fornito deve corrispondere. Deve esserci una conversione implicita dagli elementi forniti al tipo di elemento dell'array specificato.

Nella terza, gli elementi devono essere implicitamente convertibili nel tipo di elemento e la dimensione è determinata dal numero di elementi dati.

Nel quarto si deduce il tipo dell'elemento dell'array calcolando il tipo migliore, se presente, di tutti gli elementi dati che hanno tipi. Tutti gli elementi devono essere implicitamente convertibili in quel tipo. La dimensione è determinata dal numero di elementi forniti. Questa sintassi è stata introdotta in C# 3.0.

Esiste anche una sintassi che può essere utilizzata solo in una dichiarazione:

int[] x = { 10, 20, 30 };

Gli elementi devono essere convertibili in modo implicito nel tipo di elemento. La dimensione è determinata dal numero di elementi forniti.

Ti rimando alla specifica C# 4.0, sezione 7.6.10.4 "Espressioni per la creazione di array".

Matrici non vuote

• var data0 = new int[3]

• var data1 = new int[3] { 1, 2, 3 }

• var data2 = new int[] { 1, 2, 3 }

• var data3 = new[] { 1, 2, 3 }

• var data4 = { 1, 2, 3 } non è compilabile. Usa int[] data5 = { 1, 2, 3 } invece.

Matrici vuote

• var data6 = new int[0]
• var data7 = new int[] { }

• var data8 = new [] { } e int[] data9 = new [] { } non sono compilabili.

• var data10 = { } non è compilabile. Usa int[] data11 = { } invece.

Come argomento di un metodo

Solo le espressioni che possono essere assegnate con il var la parola chiave può essere passata come argomenti.

• Foo(new int[2])
• Foo(new int[2] { 1, 2 })
• Foo(new int[] { 1, 2 })
• Foo(new[] { 1, 2 })
• Foo({ 1, 2 }) non è compilabile
• Foo(new int[0])
• Foo(new int[] { })
• Foo({}) non è compilabile