Docs C# exécutables : Tableaux

Q: Comment obtenir la taille d'un tableau en C# ?

Utilisez la propriété Length : scores.Length. C'est une propriété, pas une méthode, donc sans parenthèses. Pour un tableau 2D, Length est le nombre total d'éléments ; utilisez GetLength(0) pour le nombre de lignes et GetLength(1) pour le nombre de colonnes.

Q: Comment trier un tableau en C# ?

Array.Sort(arr) trie le tableau sur place par ordre croissant. Pour l'ordre décroissant, appelez Array.Reverse(arr) après le tri, ou passez une comparaison : Array.Sort(arr, (a, b) => b.CompareTo(a)). Pour obtenir une copie triée et garder l'original, utilisez LINQ : arr.OrderBy(x => x).ToArray().

Q: Quelle est la différence entre un tableau 2D et un tableau en escalier en C# ?

Un tableau 2D int[,] est un seul bloc rectangulaire : chaque ligne a le même nombre de colonnes, et on l'indexe avec grid[row, col]. Un tableau en escalier int[][] est un tableau de tableaux : chaque ligne est un tableau séparé qui peut avoir sa propre longueur, et on l'indexe avec rows[i][j]. Chaque ligne d'un tableau en escalier doit être créée avant utilisation, sinon elle vaut null.

Q: Peut-on changer la taille d'un tableau en C# ?

Non. La longueur d'un tableau est fixée à sa création. Array.Resize(ref arr, newSize) semble redimensionner, mais il alloue un nouveau tableau, copie les éléments et fait pointer votre variable vers le nouveau. Si la taille change souvent, utilisez une List .

Q: Pourquoi afficher un tableau montre-t-il System.Int32[] ?

Console.WriteLine(arr) appelle arr.ToString(), que les tableaux ne redéfinissent pas, donc vous obtenez le nom du type. Assemblez plutôt les éléments en une seule chaîne : Console.WriteLine(string.Join(", ", arr)).

Un tableau contient un nombre fixe d'éléments d'un même type, stockés côte à côte en mémoire. Vous choisissez la longueur à sa création, vous lisez et écrivez les éléments par un index qui commence à zéro, et la longueur ne change plus ensuite.

Déclarer et initialiser un tableau

Le type d'un tableau est le type d'élément suivi de []. Il existe plusieurs façons d'en créer un :

using System;

class Program
{
    static void Main()
    {
        int[] scores = new int[4];                     // 4 elements, all 0
        string[] names = { "Ana", "Ben", "Chloe" };     // initializer
        double[] prices = new double[] { 2.5, 9.99 };   // explicit form
        var days = new[] { "Mon", "Tue", "Wed" };       // type inferred: string[]

        scores[0] = 90;
        scores[3] = 72;

        Console.WriteLine(string.Join(", ", scores));
        Console.WriteLine(names[1]);
        Console.WriteLine(prices.Length + " prices, " + days.Length + " days");
    }
}

Sortie :

90, 0, 0, 72
Ben
2 prices, 3 days

new int[4] remplit chaque élément avec la valeur par défaut du type : 0 pour les nombres, false pour bool, null pour les chaînes et les autres types référence. La forme courte { "Ana", "Ben" } ne fonctionne que dans une déclaration ; pour affecter une variable existante, il faut names = new[] { "Dev", "Eli" };.

Length, indexation et dernier élément

Les index vont de 0 à Length - 1. Length est une propriété, donc sans parenthèses (contrairement à la méthode Count() de LINQ).

using System;

class Program
{
    static void Main()
    {
        int[] temps = { 18, 21, 25, 19, 16 };

        Console.WriteLine("Count: " + temps.Length);
        Console.WriteLine("First: " + temps[0]);
        Console.WriteLine("Last: " + temps[temps.Length - 1]);

        try
        {
            Console.WriteLine(temps[5]);
        }
        catch (IndexOutOfRangeException e)
        {
            Console.WriteLine("Caught " + e.GetType().Name);
        }
    }
}

Sortie :

Count: 5
First: 18
Last: 16
Caught IndexOutOfRangeException

Lire ou écrire hors des limites lève IndexOutOfRangeException à l'exécution ; le compilateur ne le détecte pas. La cause habituelle est une condition de boucle écrite i <= arr.Length au lieu de i < arr.Length.

C# 8 et plus ajoutent la syntaxe d'index depuis la fin et de plage, plus courte pour le dernier élément et pour les tranches :

int last = temps[^1];        // 16
int[] middle = temps[1..4];  // { 21, 25, 19 }, a new array

Parcourir un tableau

Une boucle for donne l'index ; foreach donne chaque élément et c'est le choix le plus clair quand vous ne faites que lire.

using System;

class Program
{
    static void Main()
    {
        decimal[] prices = { 4.50m, 12.00m, 3.25m };

        for (int i = 0; i < prices.Length; i++)
        {
            prices[i] = Math.Round(prices[i] * 1.10m, 2); // raise every price by 10%
        }

        decimal total = 0;
        foreach (decimal p in prices)
        {
            total += p;
        }

        Console.WriteLine(string.Join(" | ", prices));
        Console.WriteLine("Total: " + total);
    }
}

Sortie :

4.95 | 13.20 | 3.58
Total: 21.73

La variable du foreach est en lecture seule : p = 0; dans la boucle est une erreur de compilation. Pour modifier des éléments, bouclez avec un index.

Trier, inverser et chercher

La classe statique Array contient les fonctions utilitaires. Array.Sort trie sur place et ne renvoie rien, donc l'ordre d'origine est perdu.

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 72, 95, 60, 88, 79 };

        Array.Sort(scores);
        Console.WriteLine("Ascending:  " + string.Join(", ", scores));

        Array.Reverse(scores);
        Console.WriteLine("Descending: " + string.Join(", ", scores));

        Console.WriteLine("Index of 60: " + Array.IndexOf(scores, 60));
        Console.WriteLine("Index of 99: " + Array.IndexOf(scores, 99));
        Console.WriteLine("Any above 90: " + Array.Exists(scores, s => s > 90));
        Console.WriteLine("First below 75: " + Array.Find(scores, s => s < 75));

        string[] names = { "chloe", "Ana", "ben" };
        Array.Sort(names, StringComparer.OrdinalIgnoreCase);
        Console.WriteLine(string.Join(", ", names));

        string[] fruits = { "kiwi", "banana", "fig" };
        Array.Sort(fruits, (a, b) => a.Length.CompareTo(b.Length)); // by length
        Console.WriteLine(string.Join(", ", fruits));
    }
}

Sortie :

Ascending:  60, 72, 79, 88, 95
Descending: 95, 88, 79, 72, 60
Index of 60: 4
Index of 99: -1
Any above 90: True
First below 75: 72
Ana, ben, chloe
fig, kiwi, banana

Array.IndexOf renvoie -1 quand la valeur est absente. Array.Find renvoie la valeur par défaut du type (0 ici) quand rien ne correspond, ce qui est ambigu pour des nombres ; utilisez Array.FindIndex quand cela compte. Un tri décroissant en un seul appel s'écrit Array.Sort(scores, (a, b) => b.CompareTo(a)).

Si vous avez besoin du résultat trié sans toucher à l'original, LINQ renvoie un nouveau tableau : var sorted = scores.OrderBy(s => s).ToArray();. Voir LINQ.

Redimensionner : un tableau ne peut pas grandir

La longueur est fixe. Array.Resize crée un nouveau tableau de la taille demandée, copie les éléments et met à jour la variable que vous passez par ref.

using System;

class Program
{
    static void Main()
    {
        string[] queue = { "Ana", "Ben" };
        string[] before = queue;

        Array.Resize(ref queue, 4);
        queue[2] = "Chloe";

        Console.WriteLine(queue.Length);
        Console.WriteLine(before.Length);             // the old array is unchanged
        Console.WriteLine(queue[3] == null);          // new slots get the default
        Console.WriteLine(ReferenceEquals(before, queue));
    }
}

Sortie :

4
2
True
False

Chaque redimensionnement copie tous les éléments. Faire grandir un tableau d'un élément à la fois dans une boucle est lent, et c'est exactement ce que List<T> fait pour vous plus efficacement, en doublant son tableau interne.

Les tableaux sont des types référence : la copie

Affecter un tableau à une autre variable copie la référence, pas les éléments. Les deux noms pointent alors vers le même tableau.

using System;

class Program
{
    static void Main()
    {
        int[] original = { 1, 2, 3 };

        int[] alias = original;
        alias[0] = 100;
        Console.WriteLine(original[0]); // 100: same array

        int[] copy = (int[])original.Clone();
        copy[1] = 200;
        Console.WriteLine(original[1]); // 2: independent array

        int[] target = new int[5];
        Array.Copy(original, 0, target, 1, 3); // source, start, dest, start, count
        Console.WriteLine(string.Join(", ", target));
    }
}

Sortie :

100
2
0, 100, 2, 3, 0

Il en va de même quand vous passez un tableau à une méthode : la méthode peut modifier les éléments de l'appelant. Clone, Array.Copy, CopyTo et le ToArray() de LINQ font tous une copie superficielle. Pour un tableau d'objets, le nouveau tableau contient des références vers les mêmes objets, donc modifier copy[0].Name modifie toujours ce que voit original[0].

Comparer des tableaux avec == compare les références. Pour comparer les contenus, utilisez a.SequenceEqual(b) de System.Linq.

Tableaux 2D (multidimensionnels)

Une grille rectangulaire se déclare avec une virgule entre les crochets. On l'indexe avec [row, col].

using System;

class Program
{
    static void Main()
    {
        int[,] seats = new int[2, 3]; // 2 rows, 3 columns
        seats[0, 1] = 1;
        seats[1, 2] = 1;

        int[,] grid =
        {
            { 1, 2, 3 },
            { 4, 5, 6 },
        };

        Console.WriteLine("Rows: " + grid.GetLength(0));
        Console.WriteLine("Cols: " + grid.GetLength(1));
        Console.WriteLine("Length: " + grid.Length + ", Rank: " + grid.Rank);

        for (int r = 0; r < seats.GetLength(0); r++)
        {
            for (int c = 0; c < seats.GetLength(1); c++)
            {
                Console.Write(seats[r, c] == 1 ? "X " : ". ");
            }
            Console.WriteLine();
        }
    }
}

Sortie :

Rows: 2
Cols: 3
Length: 6, Rank: 2
. X . 
. . X

Length sur un tableau 2D est le nombre total d'éléments (6 pour une grille de 2 sur 3), c'est pourquoi les boucles imbriquées utilisent GetLength(0) et GetLength(1). Rank est le nombre de dimensions. Trois dimensions fonctionnent de la même façon : new int[4, 4, 4] et cube[x, y, z]. Un foreach sur un tableau 2D visite chaque élément ligne par ligne.

Tableaux en escalier (tableaux de tableaux)

Un tableau en escalier int[][] est un tableau dont les éléments sont eux-mêmes des tableaux, et chaque tableau interne peut avoir sa propre longueur. Il convient à des données comme « commandes par client », où les lignes diffèrent en taille.

using System;

class Program
{
    static void Main()
    {
        int[][] orders = new int[3][]; // 3 rows, none created yet
        orders[0] = new[] { 20, 35 };
        orders[1] = new[] { 12 };
        orders[2] = new[] { 8, 15, 40, 22 };

        for (int i = 0; i < orders.Length; i++)
        {
            Console.WriteLine("Customer " + i + ": " + orders[i].Length
                + " orders, " + string.Join(", ", orders[i]));
        }

        int[][] empty = new int[2][];
        Console.WriteLine(empty[0] == null);
    }
}

Sortie :

Customer 0: 2 orders, 20, 35
Customer 1: 1 orders, 12
Customer 2: 4 orders, 8, 15, 40, 22
True

new int[3][] ne crée que le tableau externe ; chaque ligne commence à null, et orders[0][0] avant l'affectation d'une ligne lève NullReferenceException. La syntaxe new int[3][4] n'est pas autorisée ; vous créez chaque ligne vous-même.

Utilisez [,] pour une vraie grille (un plateau, une matrice, des pixels) et [][] quand les lignes ont des longueurs différentes ou que vous voulez échanger des lignes entières.

Tableau ou List

	Tableau `T[]`	`List<T>`
Taille	Fixée à la création	Augmente et diminue
Nombre d'éléments	Propriété `Length`	Propriété `Count`
Ajouter ou retirer	Impossible (seulement `Array.Resize`)	`Add`, `Insert`, `Remove`
Multidimensionnel	`[,]` et `[][]`	Seulement des listes de listes
Usage typique	Taille connue, tables de correspondance, tampons	Collections qui changent

La conversion tient en un appel dans les deux sens : new List<int>(arr) ou arr.ToList(), et list.ToArray(). List<T> est la version extensible.

Erreurs courantes

i <= arr.Length dans une boucle. Le dernier index valide est Length - 1 ; cela lève IndexOutOfRangeException.
Afficher le tableau directement. Console.WriteLine(arr) affiche System.Int32[] ; utilisez string.Join.
S'attendre à ce qu'Array.Sort renvoie le tableau trié. Il renvoie void et trie sur place.
Copier avec =. Cela copie la référence ; utilisez Clone() ou ToArray().
Utiliser des lignes d'un tableau en escalier avant de les créer. Chaque ligne de new T[n][] vaut null tant qu'elle n'est pas affectée.
Utiliser Length pour les lignes d'un tableau 2D. Il compte tous les éléments ; utilisez GetLength(0).

Questions fréquentes

Comment obtenir la taille d'un tableau en C# ?

Utilisez la propriété Length : scores.Length. C'est une propriété, pas une méthode, donc sans parenthèses. Pour un tableau 2D, Length est le nombre total d'éléments ; utilisez GetLength(0) pour le nombre de lignes et GetLength(1) pour le nombre de colonnes.

Comment trier un tableau en C# ?

Array.Sort(arr) trie le tableau sur place par ordre croissant. Pour l'ordre décroissant, appelez Array.Reverse(arr) après le tri, ou passez une comparaison : Array.Sort(arr, (a, b) => b.CompareTo(a)). Pour obtenir une copie triée et garder l'original, utilisez LINQ : arr.OrderBy(x => x).ToArray().

Quelle est la différence entre un tableau 2D et un tableau en escalier en C# ?

Un tableau 2D int[,] est un seul bloc rectangulaire : chaque ligne a le même nombre de colonnes, et on l'indexe avec grid[row, col]. Un tableau en escalier int[][] est un tableau de tableaux : chaque ligne est un tableau séparé qui peut avoir sa propre longueur, et on l'indexe avec rows[i][j]. Chaque ligne d'un tableau en escalier doit être créée avant utilisation, sinon elle vaut null.

Peut-on changer la taille d'un tableau en C# ?

Non. La longueur d'un tableau est fixée à sa création. Array.Resize(ref arr, newSize) semble redimensionner, mais il alloue un nouveau tableau, copie les éléments et fait pointer votre variable vers le nouveau. Si la taille change souvent, utilisez une List<T>.

Pourquoi afficher un tableau montre-t-il System.Int32[] ?

Console.WriteLine(arr) appelle arr.ToString(), que les tableaux ne redéfinissent pas, donc vous obtenez le nom du type. Assemblez plutôt les éléments en une seule chaîne : Console.WriteLine(string.Join(", ", arr)).

Faut-il utiliser un tableau ou une List en C# ?

Utilisez un tableau quand le nombre d'éléments est connu et fixe, comme les 12 mois ou un plateau de jeu. Utilisez List<T> quand des éléments sont ajoutés ou retirés au fil du temps. Les deux s'indexent en temps constant, et une List<T> stocke ses éléments dans un tableau en interne.

Concepts liés