Tutoriel C# Array : créer, déclarer, initialiser

Qu’est-ce qu’un tableau en C# ?

Un tableau est utilisé pour stocker une collection ou une série d’éléments. Ces éléments seront du même type.

Ainsi, par exemple, si vous aviez un tableau de valeurs entières, le tableau pourrait être une collection de valeurs telles que [1, 2, 3, 4]. Ici, le nombre d'éléments dans le tableau est de 4.

Les tableaux sont utiles lorsque vous souhaitez stocker une collection de valeurs du même type. Ainsi, au lieu de déclarer un variable pour chaque élément, vous pouvez simplement déclarer une variable.

Cette variable pointera vers un tableau ou une liste d'éléments, qui se chargera de stocker les éléments du tableau.

Voyons comment travailler avec des tableaux en C#. Dans notre exemple, nous allons déclarer un tableau d’entiers et travailler avec eux en conséquence.

Notez que tout le code ci-dessous est transféré dans le fichier Program.cs.

Étape 1) Déclaration d'un tableau – La première étape consiste à déclarer un tableau. Voyons comment nous pouvons y parvenir grâce à l'exemple de code ci-dessous.

Code Explication:-

1. La première partie est la Type de données. Il spécifie le type d'éléments utilisés dans le tableau. Donc, dans notre cas, nous créons un tableau d’entiers.
2. La deuxième partie [ ], qui spécifie le rang du tableau. (Le rang est un espace réservé qui spécifie le nombre d'éléments que le tableau contiendra)
3. Vient ensuite le nom du tableau qui dans notre cas est « valeurs ». Notez que vous voyez un soulignement vert ondulé, ne vous inquiétez pas pour cela. C'est juste .Net disant que vous avez déclaré un tableau, mais que vous ne l'utilisez nulle part.

Étape 2) L'étape suivante consiste à initialiser le tableau. Ici, nous allons spécifier le nombre de valeurs que le tableau contiendra. Nous allons également attribuer des valeurs à chaque élément du tableau.

Code Explication:-

1. Tout d’abord, nous définissons le nombre d’éléments que le tableau contiendra à 3. Ainsi, entre crochets, nous disons que le tableau contiendra 3 éléments.
2. Ensuite, nous assignons une valeur à chaque élément du tableau. Pour ce faire, nous spécifions le nom de la variable suivi de son indice dans le tableau. Ainsi, `values[0]` signifie que nous stockons la valeur située à la première position du tableau. De même, pour accéder à la deuxième position, nous utilisons la notation `values[1]`, et ainsi de suite.

Note: – Dans les tableaux, la position de l'index commence à 0.

Étape 3) Affichons maintenant les éléments individuels du tableau dans la console. Ajoutons le code ci-dessous pour y parvenir.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args) 
  {
   Int32[] value;
   value=new Int32[3];
   
   value[0]=1;
   value[1]=2;
   value[2]=3;
   
   Console.WriteLine(value[0]);
   Console.WriteLine(value[1]);
   Console.WriteLine(value[2]);
    
   Console.ReadKey(); 
  }
 }
}

Code Explication:-

C'est la partie simple dans laquelle nous utilisons simplement la méthode Console.WriteLine pour envoyer chaque valeur de l'élément à la console.

Notez que encore une fois, nous accédons à chaque élément à l'aide du nom de la variable du tableau ainsi que de la position de l'index.

Si le code ci-dessus est saisi correctement et que le programme est exécuté, la sortie suivante sera affichée.

Sortie :

À partir de la sortie, vous pouvez voir toutes les valeurs du tableau affichées dans la console.

Comment parcourir un tableau C# à l'aide de foreach

Parcourir chaque élément par son index fonctionne, mais devient fastidieux lorsqu'un tableau contient de nombreuses valeurs. La boucle foreach offre une méthode plus élégante pour parcourir chaque élément d'un tableau, dans l'ordre, sans interruption. tracCréez vous-même une variable d'index.

La boucle `foreach` parcourt chaque élément du tableau un par un et le stocke dans une variable de boucle. Cette variable est ensuite utilisée dans le corps de la boucle. Comme la boucle s'arrête automatiquement au dernier élément, `foreach` évite de lire au-delà de la fin du tableau.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Int32[] values = new Int32[3] {1, 2, 3};
   foreach (Int32 item in values)
   {
    Console.WriteLine(item);
   }
   Console.ReadKey();
  }
 }
}

L'exemple ci-dessus déclare et initialise un tableau de trois entiers, puis le parcourt avec une boucle foreach. À chaque itération, la variable Articles La fonction reçoit la valeur suivante, et Console.WriteLine l'affiche. Le résultat est constitué des nombres 1, 2 et 3 sur des lignes distinctes.

Points clés à retenir concernant la boucle foreach avec les tableaux :

• La variable de boucle est en lecture seule, il est donc préférable d'utiliser foreach pour lire les valeurs plutôt que de les modifier directement.
• Pour modifier des éléments pendant les toilettespingUtilisez plutôt une boucle for avec un index.
• La boucle foreach fonctionne avec les tableaux unidimensionnels, les tableaux multidimensionnels et toute collection prenant en charge l'itération.

Tableaux multidimensionnels en C#

Les tableaux présentés jusqu'à présent sont unidimensionnels, c'est-à-dire qu'ils stockent une simple liste de valeurs. C# prend également en charge les tableaux multidimensionnels, qui organisent les éléments en lignes et en colonnes. Le tableau bidimensionnel est le plus courant et convient aux données telles que les matrices, les plateaux de jeu et les tableaux.

On déclare un tableau bidimensionnel en plaçant une virgule à l'intérieur des crochets. Chaque virgule supplémentaire ajoute une dimension ; ainsi, `int[,]` est bidimensionnel et `int[,,]` est tridimensionnel. On accède ensuite aux éléments avec un indice par dimension.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   int[,] matrix = new int[2, 2] { {1, 2}, {3, 4} };
   Console.WriteLine(matrix[0, 0]);
   Console.WriteLine(matrix[1, 1]);
   Console.ReadKey();
  }
 }
}

Ici, le tableau matrix comporte deux lignes et deux colonnes. L'élément matrix[0, 0] renvoie 1, et matrix[1, 1] renvoie 4. Le nombre de dimensions est fixé lors de la déclaration du tableau, tandis que la taille de chaque dimension est définie lors de sa création.

Tableaux irréguliers en C#

Un tableau irrégulier est un tableau dont les éléments sont eux-mêmes des tableaux. Contrairement à un tableau multidimensionnel rectangulaire, chaque tableau interne peut avoir une longueur différente, c'est pourquoi un tableau irrégulier est souvent appelé un tableau de tableaux. Cette flexibilité est utile lorsque les lignes contiennent naturellement un nombre variable de valeurs.

Vous déclarez un tableau irrégulier à l'aide de deux paires de crochets, puis vous créez chaque sous-tableau séparément. L'exemple suivant construit un tableau irrégulier où la première ligne contient trois valeurs et la seconde deux.

using System;
namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   int[][] jagged = new int[2][];
   jagged[0] = new int[] {1, 2, 3};
   jagged[1] = new int[] {4, 5};
   Console.WriteLine(jagged[0][2]);
   Console.WriteLine(jagged[1][1]);
   Console.ReadKey();
  }
 }
}

L'expression jagged[0][2] lit le troisième élément de la première ligne, qui est 3, et jagged[1][1] lit le deuxième élément de la deuxième ligne, qui est 5. Parce que chaque ligne est un tableau séparé, les tableaux irréguliers utilisent la mémoire efficacement lorsque les longueurs de ligne varient, bien qu'ils aient besoin d'une étape supplémentaire pour initialiser chaque tableau interne.

FAQ