web-dev-qa-db-fra.com

Toutes les syntaxes possibles pour l'initialisation des tableaux

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

c#arrayssyntaxarray-initialization
568
Joshua Girard

Ce sont les méthodes de déclaration et d'initialisation actuelles 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 extensions Linq ToArray() sur IEnumerable<T>.

Notez également que dans les déclarations ci-dessus, les deux premiers pourraient remplacer le string[] à gauche par var (C # 3+), car les informations à droite suffisent à déduire le type approprié. La troisième ligne doit être écrite telle qu’elle est affichée, car la syntaxe d’initialisation de tableau ne suffit pas à 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
599
Anthony Pegram

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

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

Dans le premier cas, la taille peut être toute 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 une constante et le nombre d'éléments fournis doit correspondre. Il doit exister 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 fournis.

Dans le quatrième cas, le type de l'élément array est déduit en calculant le meilleur type, s'il en existe un, parmi tous les éléments donnés ayant 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".

401
Eric Lippert
Enumerable.Repeat(String.Empty, count).ToArray()

Crée un tableau de chaînes vides répété 'nombre' fois. Si vous souhaitez initialiser un 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.

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

Si vous souhaitez initialiser un tableau fixe d'éléments égaux pré-initialisés (non -null ou autres que default), utilisez ceci:

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

Veuillez également prendre part à this discussion.

13
Shimmy

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

Vous trouverez ci-dessous la définition de la 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 = "[email protected]",
       language = "English"
    },
    new DummyUser{
       email = "[email protected]",
       language = "Spanish"
    }
};
11
Amol
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 multi-dimensionnel

    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)"
5
user2613377

Répéter sans LINQ :

float[] floats = System.Array.ConvertAll(new float[16], v => 1.0f);
5
Nick Shalimov
For Class initialization:
var page1 = new Class1();
var page2 = new Class2();
var pages = new UIViewController[] { page1, page2 };
2
Sanjay Shrivastava

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

IUser[] userArray = new IUser[]
{
    new DummyUser("[email protected]", "Gibberish"),
    new SmartyUser("[email protected]", "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;
}
0
Nick Alexeev

Vous pouvez également créer des tableaux dynamiques, c'est-à-dire que vous pouvez d'abord demander à l'utilisateur la taille du tableau 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();
0
Pushpendra7974

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

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
0
unsafePtr