Tutte le possibili sintassi di inizializzazione dell'array

Quali sono tutte le sintassi di inizializzazione dell'array possibili con C #?

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

Si noti che esistono altre tecniche per ottenere array, come ad esempio le ToArray()estensioni Linq IEnumerable<T>.

Si noti inoltre che nelle dichiarazioni sopra, i primi due potrebbero sostituire il string[]a sinistra con var(C # 3+), poiché le informazioni a destra sono sufficienti per inferire il tipo corretto. La terza riga deve essere scritta come visualizzata, poiché la sola sintassi di inizializzazione dell'array non è sufficiente per soddisfare le esigenze 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 dell'array 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 sono inizializzati sui valori predefiniti.

Nel secondo, la dimensione deve essere una costante e il numero di elementi indicati deve corrispondere. Deve esserci una conversione implicita dagli elementi dati al tipo di elemento matrice specificato.

Nel terzo, gli elementi devono essere implicitamente convertibili nel tipo di elemento e la dimensione è determinata dal numero di elementi forniti.

Nel quarto il tipo dell'elemento array viene dedotto calcolando il tipo migliore, se ce n'è uno, 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 indicati. 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 implicitamente convertibili nel tipo di elemento. La dimensione è determinata dal numero di elementi indicati.

non esiste una guida all-in-one

Vi rimando alla specifica C # 4.0, sezione 7.6.10.4 "Espressioni di 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 la varparola chiave possono essere passate 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

Enumerable.Repeat(String.Empty, count).ToArray()

Creerà una serie di stringhe vuote ripetute 'count' volte. Nel caso in cui si desideri inizializzare l'array con lo stesso valore di elemento predefinito ma speciale. Attento ai tipi di riferimento, tutti gli elementi faranno riferimento allo stesso oggetto.

var contacts = new[]
{
    new 
    {
        Name = " Eugene Zabokritski",
        PhoneNumbers = new[] { "206-555-0108", "425-555-0001" }
    },
    new 
    {
        Name = " Hanying Feng",
        PhoneNumbers = new[] { "650-555-0199" }
    }
};

Nel caso in cui si desideri inizializzare una matrice fissa di elementi uguali (non nullo diversi da default) pre-inizializzati , utilizzare questo:

var array = Enumerable.Repeat(string.Empty, 37).ToArray();

Inoltre, prendi parte a questa discussione.

Esempio per creare una matrice di una classe personalizzata

Di seguito è la definizione della classe.

public class DummyUser
{
    public string email { get; set; }
    public string language { get; set; }
}

Ecco come è possibile inizializzare l'array:

private DummyUser[] arrDummyUser = new DummyUser[]
{
    new DummyUser{
       email = "abc.xyz@email.com",
       language = "English"
    },
    new DummyUser{
       email = "def@email.com",
       language = "Spanish"
    }
};

Ripeti senza LINQ :

float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f);

int[] array = new int[4]; 
array[0] = 10;
array[1] = 20;
array[2] = 30;

o

string[] week = new string[] {"Sunday","Monday","Tuesday"};

o

string[] array = { "Sunday" , "Monday" };

e in array multidimensionale

    Dim i, j As Integer
    Dim strArr(1, 2) As String

    strArr(0, 0) = "First (0,0)"
    strArr(0, 1) = "Second (0,1)"

    strArr(1, 0) = "Third (1,0)"
    strArr(1, 1) = "Fourth (1,1)"

For Class initialization:
var page1 = new Class1();
var page2 = new Class2();
var pages = new UIViewController[] { page1, page2 };

Un altro modo di creare e inizializzare una matrice di oggetti. Questo è simile all'esempio che @Amol ha pubblicato sopra , tranne che per i costruttori. Una spruzzata di polimorfismo spruzzò dentro, non potei resistere.

IUser[] userArray = new IUser[]
{
    new DummyUser("abc@cde.edu", "Gibberish"),
    new SmartyUser("pga@lna.it", "Italian", "Engineer")
};

Classi per contesto:

interface IUser
{
    string EMail { get; }       // immutable, so get only an no set
    string Language { get; }
}

public class DummyUser : IUser
{
    public DummyUser(string email, string language)
    {
        m_email = email;
        m_language = language;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }
}

public class SmartyUser : IUser
{
    public SmartyUser(string email, string language, string occupation)
    {
        m_email = email;
        m_language = language;
        m_occupation = occupation;
    }

    private string m_email;
    public string EMail
    {
        get { return m_email; }
    }

    private string m_language;
    public string Language
    {
        get { return m_language; }
    }

    private string m_occupation;
}

Per la classe seguente:

public class Page
{

    private string data;

    public Page()
    {
    }

    public Page(string data)
    {
        this.Data = data;
    }

    public string Data
    {
        get
        {
            return this.data;
        }
        set
        {
            this.data = value;
        }
    }
}

è possibile inizializzare l'array dell'oggetto sopra come di seguito.

Pages = new Page[] { new Page("a string") };

Spero che sia di aiuto.

È inoltre possibile creare matrici dinamiche, ovvero è possibile chiedere all'utente la dimensione della matrice prima di crearla.

Console.Write("Enter size of array");
int n = Convert.ToInt16(Console.ReadLine());

int[] dynamicSizedArray= new int[n]; // Here we have created an array of size n
Console.WriteLine("Input Elements");
for(int i=0;i<n;i++)
{
     dynamicSizedArray[i] = Convert.ToInt32(Console.ReadLine());
}

Console.WriteLine("Elements of array are :");
foreach (int i in dynamicSizedArray)
{
    Console.WriteLine(i);
}
Console.ReadKey();

Soluzione fondamentale con espressioni. Si noti che con NewArrayInit è possibile creare solo array monodimensionali.

NewArrayExpression expr = Expression.NewArrayInit(typeof(int), new[] { Expression.Constant(2), Expression.Constant(3) });
int[] array = Expression.Lambda<Func<int[]>>(expr).Compile()(); // compile and call callback

Solo una nota

I seguenti array:

string[] array = new string[2];
string[] array2 = new string[] { "A", "B" };
string[] array3 = { "A" , "B" };
string[] array4 = new[] { "A", "B" };

Sarà compilato per:

string[] array = new string[2];
string[] array2 = new string[]
{
   "A",
   "B"
};
string[] array3 = new string[]
{
   "A",
   "B"
};
string[] array4 = new string[]
{
   "A",
   "B"
};