Toutes les syntaxes d'initialisation de tableau possibles

Quelles sont toutes les syntaxes d'initialisation de tableau possibles avec C #?

Ce sont les méthodes actuelles de déclaration et d'initialisation pour un tableau simple.

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

Notez qu'il existe d'autres techniques d'obtention de tableaux, telles que les ToArray()extensions Linq sur IEnumerable<T>.

Notez également que dans les déclarations ci-dessus, les deux premiers pourraient remplacer le string[]sur la gauche par var(C # 3+), car les informations sur la droite sont suffisantes pour déduire le type approprié. La troisième ligne doit être écrite telle qu'elle est affichée, car la syntaxe d'initialisation du tableau ne suffit pas à elle seule pour satisfaire les demandes du compilateur. Le quatrième pourrait également utiliser l'inférence. Donc, si vous êtes dans la brièveté, ce qui précède pourrait être écrit comme

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 

Les syntaxes de création de tableau en C # qui sont des expressions sont:

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

Dans le premier, la taille peut être n'importe quelle valeur intégrale non négative et les éléments du tableau sont initialisés aux valeurs par défaut.

Dans le second, la taille doit être constante et le nombre d'éléments donné doit correspondre. Il doit y avoir une conversion implicite des éléments donnés vers le type d'élément de tableau donné.

Dans le troisième, les éléments doivent être implicitement convertibles en type d'élément, et la taille est déterminée à partir du nombre d'éléments donné.

Dans le quatrième, le type de l'élément de tableau est déduit en calculant le meilleur type, s'il y en a un, de tous les éléments donnés qui ont des types. Tous les éléments doivent être implicitement convertibles en ce type. La taille est déterminée à partir du nombre d'éléments donnés. Cette syntaxe a été introduite dans C # 3.0.

Il existe également une syntaxe qui ne peut être utilisée que dans une déclaration:

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

Les éléments doivent être implicitement convertibles en type d'élément. La taille est déterminée à partir du nombre d'éléments donnés.

il n'y a pas de guide tout-en-un

Je vous renvoie à la spécification C # 4.0, section 7.6.10.4 "Expressions de création de tableaux".

Tableaux non vides

• 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 }n'est pas compilable. Utilisez int[] data5 = { 1, 2, 3 }plutôt.

Tableaux vides

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

• var data8 = new [] { } et int[] data9 = new [] { }ne sont pas compilables.

• var data10 = { }n'est pas compilable. Utilisez int[] data11 = { } plutôt.

Comme argument d'une méthode

Seules les expressions qui peuvent être affectées avec le varmot - clé peuvent être passées comme arguments.

• Foo(new int[2])
• Foo(new int[2] { 1, 2 })
• Foo(new int[] { 1, 2 })
• Foo(new[] { 1, 2 })
• Foo({ 1, 2 }) n'est pas compilable
• Foo(new int[0])
• Foo(new int[] { })
• Foo({}) n'est pas compilable

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

Créera un tableau de chaînes vides répétées 'count' fois. Dans le cas où vous souhaitez initialiser le tableau avec la même valeur d'élément par défaut, mais spéciale. Attention aux types de référence, tous les éléments feront référence au même objet.

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

Dans le cas où vous souhaitez initialiser un tableau fixe d'éléments égaux (non nullou autres que default) pré-initialisés , utilisez ceci:

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

Veuillez également prendre part à cette discussion.

Exemple pour créer un tableau d'une classe personnalisée

Voici la définition de classe.

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

Voici comment initialiser le tableau:

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

Répétez sans 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;

ou

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

ou

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

et dans un tableau multidimensionnel

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

Une autre façon de créer et d'initialiser un tableau d'objets. Ceci est similaire à l' exemple que @Amol a publié ci - dessus , sauf que celui-ci utilise des constructeurs. Un soupçon de polymorphisme saupoudré, je n'ai pas pu résister.

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

Classes pour le contexte:

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

Pour la classe ci-dessous:

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

vous pouvez initialiser le tableau des objets ci-dessus comme ci-dessous.

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

J'espère que cela t'aides.

Vous pouvez également créer des tableaux dynamiques, c'est-à-dire que vous pouvez d'abord demander la taille du tableau à l'utilisateur avant de le créer.

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

Solution triviale avec des expressions. Notez qu'avec NewArrayInit, vous pouvez créer uniquement un tableau unidimensionnel.

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

Juste une note

Les tableaux suivants:

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

Sera compilé pour:

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