Je vous propose aujourd’hui, un billet plutôt orienté pour les débutants qui présente les différents usages des tableaux en C# (csharp).

Je vais parler ici des bases du langage qu’il est important de connaitre. Je pense que cet article pourra aussi intéresser les plus expérimentés (j’ai appris quelques petites astuces lors de mes recherches).

Les bases

La déclaration

Les tableaux sont des structures de données utilisées pour faire des traitements sur un ensemble d’informations.
Très souvent, les développeurs utilisent des tableaux pour faire des calculs sur des nombres (calcul de moyenne, minimum, maximum) ou bien aussi pour trier des éléments (une liste de noms par exemple).

Les tableaux en C# (array) commencent toujours à l’index 0 (zéro). La syntaxe pour lire et écrire dans un tableau est la suivante :

[csharp] // lecture du 13ème élément
int valeur = montableau[12];

// écriture dans le 11ème élément
montableau[10] = 10;
[/csharp]

Pour déclarer un tableau en C#, il faut utiliser la syntaxe « [] » associée à un type.
Il faudra aussi allouer l’espace mémoire nécessaire pour le tableau avant de l’utiliser.

Ces deux opérations peuvent se faire en écrivant une ligne (dans l’exemple, je crée un tableau d’entiers (int) ):

[csharp] int[] valeurs = new int[100];
[/csharp]

Nous venons de voir ce qui est nécessaire pour déclarer et utiliser un tableau de manière simple. Passons désormais à des utilisations plus avancées.

L’initialisation

Il existe différentes manières d’initialiser un tableau en C# :

• soit lors de la déclaration (c’est un peu comme un constructeur),
• soit par le code (en exécutant une boucle par exemple).

Voici comment initialiser un tableau simplement lorsque vous avez que quelques valeurs à définir (initialisation à la déclaration) :

[csharp] // déclaration d’un tableau initialisé avec 5 valeurs
int[] valeurs = new int[] {1, 2, 3, 4, 5};
[/csharp]

Lorsque vous avez beaucoup de valeurs ou bien si vous souhaitez calculer les valeurs de manière plus complexe, il faudra initialiser le tableau par le code. Voici un exemple simple :

[csharp] // déclaration et allocation d’un tableau de 10 éléments du type int
int[] valeurs = new int[10];

// initialisation des valeurs
for (int i = 0; i < 10; i++) valeurs[i] = i*i;
[/csharp]

Parcours des tableaux

Pour lire ou écrire les valeurs d’un tableau vous pouvez utiliser une boucle du type « for », « while » ou « do…while ».
En C#, il existe aussi « foreach » qui permet de parcourir une liste d’éléments dont les tableaux.

Cette structure est intéressante car elle permet de simplifier le code. Voici un exemple :

[csharp] foreach (int valeur in valeurs)
{
Console.WriteLine("valeur = {0}", valeur);
}
[/csharp]

Remarque : ce type de boucle est utilisable uniquement si vous n’avez pas besoin de connaitre l’index du tableau lors de son parcours.

Les différents types de tableaux

En C#, il existe trois types de tableaux :

• Les tableaux à une dimension (ceux que nous venons de voir jusqu’à présent),
• Les tableaux à plusieurs dimensions « rectangles »,
• Les tableaux à plusieurs dimensions « non rectangulaires » (jagged array).

Les tableaux à une seule dimension

Ces tableaux sont sont qui sont le plus souvent utilisés dans le quotidien. L’index correspond à un entier qui permet d’accéder à un élément (par exemple : chaque ligne comporte le même nombre de colonnes).

Les tableaux à plusieurs dimensions « rectangles »

Cette fois-ci, pour accéder à un élément vous allez utiliser plusieurs indexes. Il y aura autant d’indexes que de dimensions.

Les tableaux multi-dimentionnels rectangles sont des tableaux pour lesquels le nombre d’éléments est constant pour chaque index.

Le plus simple à comprendre est le tableau à deux dimensions (c’est de là que vient l’image du rectangle). Voici un exemple de déclaration :

[csharp] // déclaration et allocation d’un tableau de 10 lignes et de 20 colonnes
int[,] tableauRectangulaire = new int[10, 20];

// écriture d’une valeur
tableauRectangulaire[0, 0] = 1;

// lecture d’une valeur
int valeur = tableauRectangulaire[3, 5];
[/csharp]

Vous pouvez aussi initialiser vos tableaux lors de la déclaration :
[csharp] string [,] utilisateurs = new string[3,2] { { "John", "Doe" }, { "Mary", "Smith"}, {"Bill", "Gates"} };
[/csharp]

Les tableaux à plusieurs dimensions « non rectangulaires » (jagged array)

En C#, il est possible de créer des tableaux multi-dimensionnels « non rectangulaires », ce qui va permettre, très souvent, d’optimiser la mémoire.

Ce type de tableau se déclare simplement comme un tableau de tableau. Voici un exemple :

[csharp] int[][] tableauNonRectangulaire = new int[3][];

tableauNonRectangulaire[0] = new int[2];
tableauNonRectangulaire[0] = new int[3];
tableauNonRectangulaire[0] = new int[4];
[/csharp]

Dans cet exemple, j’ai crée un tableau de 3 lignes. La première ligne aura deux valeurs, la seconde ligne trois valeurs et la dernières contiendra quatre valeurs.

Vous pouvez bien sûr initialiser les différentes lignes comme un tableau « classique » :

[csharp] tableauNonRectangulaire[0] = new int[2] { 1, 2 };
[/csharp]

Rassurez-vous, ce type de tableau est rarement utilisé. Il sera néanmoins nécessaire pour certains algorithmes qui traitent beaucoup de valeurs et pour lesquels chaque « ligne » ou « colonne » ne comportent pas forcément le même nombre d’éléments.

Les opérations

Voici comment utiliser vos tableaux pour effectuer des recherches ou faire des calculs.

La classe Array

La classe Array est la classe de base de tous les tableaux en C#. Je vous invite à consulter la documentation Microsoft pour référence.

Voici quelques éléments intéressants de la classe Array :

• La propriété Length : elle retourne le nombre d’éléments dans le tableau,
• La propriété Rank : elle indique le nombre de dimensions dans le tableau (fonctionne uniquement s’il est du type « rectangulaire »),
• La méthode Clear() permet de réinitialiser les valeurs à 0 ou null (selon le type de données),
• Les méthodes Copy() permettent de copier des éléments d’un tableau à un autre,
• Les méthodes Find() et FindAll permettent de rechercher des éléments dans un tableau,
• Les méthodes Sort() permettent de trier les valeurs.

Attention : les méthodes statiques de la classe Array doivent être utilisées en utilisant le nom « Array ». Vous comprendrez mieux en lisant l’exemple ci-dessous.

Exemple complet
[csharp] int[] valeurs = new int[] { 3, 5, 1, 2, 3, 2, 3, 4, 2, -1, 33 };

// inverser le tableau
Array.Reverse(valeurs);

// afficher la première valeur
Console.WriteLine(valeurs[0]); // affiche 33

// trier (ordre de tri par défaut)
Array.Sort(valeurs);

Console.WriteLine("{0} | {1}", valeurs[0], valeurs[valeurs.Length-1]); // affiche -1 | 33

// rechercher tous les "2" dans le tableau
int[] lesDeux = Array.FindAll(valeurs, delegate(int v) { return v == 2; });

Console.WriteLine(lesDeux.Length); // affiche 3 – il y a bien 3 fois le nombre 2 dans le tableau
[/csharp]

Pour faire des manipulations rapides, je vous invite à essayer LinqPad dont j’ai parlé dans l’article Comment écrire un morceau de code et le tester rapidement.

A vous maintenant

Vous connaissez désormais le nécessaire pour manipuler des tableaux en C#. Pour aller plus loin, il faudra passer à la pratique (et pourquoi pas avec LinqPad ?).

• Pour vous aider, je vous ai préparé une fiche pratique au format PDF qui résume tout ce qu’il faut savoir sur une page.
• Cette fiche est téléchargeable gratuitement à l’aide du formulaire ci-dessous.

[sociallocker] Télécharger la fiche PDF complémentaire
[/sociallocker]