Guide : Liste de Tableaux C# vs Liste

En C#, une liste de Tableaux C# et une liste classique sont deux structures de données différentes. Chacune a ses propres cas d’utilisation et avantages.

1. Définition

Aspect	Liste de Tableaux	Liste
Structure	Une liste où chaque élément est un tableau (ex. `List<int[]>`).	Une collection dynamique d’éléments simples ou complexes.
Type des éléments	Les éléments sont des tableaux.	Les éléments sont des objets simples ou des classes.
Usage	Gérer des collections où chaque élément est un groupe de données de taille fixe ou variable.	Gérer des collections homogènes d’éléments individuels.

2. Déclaration

Liste de Tableaux

Une liste de tableaux combine les fonctionnalités d’une liste et celles d’un tableau.

Exemple : Liste de tableaux d’entiers

List<int[]> listeTableaux = new List<int[]>();

Liste

Une liste classique est une collection dynamique simple.

Exemple : Liste d’entiers

List<int> liste = new List<int>();

3. Initialisation

Liste de Tableaux

Chaque élément ajouté à une liste de tableaux est un tableau.

Exemple : Ajouter des tableaux à une liste

List<int[]> listeTableaux = new List<int[]>
{
    new int[] { 1, 2, 3 },
    new int[] { 4, 5 },
    new int[] { 6, 7, 8, 9 }
};

Liste

Chaque élément ajouté à une liste est une valeur individuelle.

Exemple : Ajouter des éléments à une liste

List<int> liste = new List<int> { 1, 2, 3, 4, 5 };

4. Accès aux Éléments

Liste de Tableaux

Accédez aux éléments avec deux indices :

L’index du tableau dans la liste.
L’index de l’élément dans le tableau.

Exemple :

Console.WriteLine(listeTableaux[0][1]); // Accède au deuxième élément du premier tableau.

Liste

Accédez directement à l’élément avec son index.

Exemple :

Console.WriteLine(liste[1]); // Accède au deuxième élément.

5. Parcourir les Éléments

Liste de Tableaux

Vous devez parcourir chaque tableau, puis chaque élément à l’intérieur.

Exemple :

foreach (int[] tableau in listeTableaux)
{
    foreach (int valeur in tableau)
    {
        Console.Write(valeur + " ");
    }
    Console.WriteLine();
}

Liste

Vous parcourez directement les éléments.

Exemple :

foreach (int valeur in liste)
{
    Console.WriteLine(valeur);
}

6. Modification

Liste de Tableaux

Modifiez un tableau entier ou un élément spécifique dans un tableau.

Exemple :

listeTableaux[0][1] = 99; // Modifie le deuxième élément du premier tableau.

Liste

Modifiez directement un élément via son index.

Exemple :

liste[1] = 99; // Modifie le deuxième élément de la liste.

7. Tri

Liste de Tableaux

Vous pouvez trier la liste de tableaux par un critère, comme la longueur des tableaux ou une valeur spécifique.

Exemple : Trier par longueur des tableaux

listeTableaux.Sort((a, b) => a.Length.CompareTo(b.Length));

Liste

Vous pouvez trier directement les éléments avec Sort.

Exemple :

liste.Sort();

8. Comparaison des Usages

Critère	Liste de Tableaux	Liste
Flexibilité	Permet de regrouper des données similaires en groupes (tableaux).	Idéal pour des collections simples et homogènes.
Facilité d’accès	Nécessite deux indices pour accéder aux données.	Accès direct avec un seul index.
Performance	Plus complexe, mais offre des structures groupées.	Plus rapide pour des opérations simples.
Tri avancé	Possible avec des critères complexes (longueur, valeurs).	Limité à des tris simples sur les éléments.
Structure	Idéal pour des données structurées par groupe.	Idéal pour des données individuelles homogènes.

Exemple Pratique

Problème : Gestion d’un Système de Cours

Chaque cours contient plusieurs étudiants (un tableau).
Vous voulez gérer plusieurs cours dans un système dynamique (une liste).

Solution : Liste de Tableaux

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Liste de tableaux d'étudiants
        List<string[]> cours = new List<string[]>
        {
            new string[] { "Alice", "Bob", "Charlie" },
            new string[] { "David", "Emma" },
            new string[] { "Frank", "Grace", "Hannah", "Ivy" }
        };

        // Afficher les cours
        Console.WriteLine("=== Liste des cours ===");
        for (int i = 0; i < cours.Count; i++)
        {
            Console.WriteLine($"Cours {i + 1} : {string.Join(", ", cours[i])}");
        }

        // Trier les cours par nombre d'étudiants
        cours.Sort((a, b) => a.Length.CompareTo(b.Length));
        Console.WriteLine("\nCours triés par nombre d'étudiants :");
        for (int i = 0; i < cours.Count; i++)
        {
            Console.WriteLine($"Cours {i + 1} : {string.Join(", ", cours[i])}");
        }
    }
}

Solution : Liste

Si chaque étudiant est une entrée individuelle, utilisez une liste simple.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Liste d'étudiants
        List<string> etudiants = new List<string> { "Alice", "Bob", "Charlie", "David", "Emma" };

        // Afficher les étudiants
        Console.WriteLine("Liste des étudiants : " + string.Join(", ", etudiants));

        // Ajouter un étudiant
        etudiants.Add("Frank");

        // Trier les étudiants
        etudiants.Sort();

        // Afficher les étudiants triés
        Console.WriteLine("Étudiants triés : " + string.Join(", ", etudiants));
    }
}

Quand Utiliser Quelle Structure ?

Scénario	Liste de Tableaux	Liste
Groupes de données (ex. étudiants par cours).	✅ Parfait pour regrouper et manipuler des groupes distincts.	❌ Pas idéal pour les données groupées.
Collection simple (ex. liste d’étudiants).	❌ Complexe et inutile pour ce scénario.	✅ Idéal pour des collections homogènes.
Tri ou recherche sur des groupes.	✅ Plus adapté pour appliquer des critères complexes.	❌ Limité aux éléments simples.

Synthèse 😉

Utilisez une liste de tableaux lorsque vous avez besoin de regrouper des ensembles de données similaires (ex. étudiants par classe).
Utilisez une liste classique pour des collections homogènes d’éléments simples (ex. liste d’étudiants).

La structure que vous choisissez dépend de vos besoins en termes de structure des données, de flexibilité, et de complexité.

Guide : LINQ pour Manipuler des Listes en C#

LINQ (Language Integrated Query) est une fonctionnalité puissante en C# qui permet de manipuler et de requêter des collections, comme des listes, de manière concise et lisible. Elle offre des méthodes pour filtrer, trier, regrouper et transformer des données.

1. Configuration et Namespace

Pour utiliser LINQ, ajoutez le namespace suivant en haut de votre fichier :

using System.Linq;

2. Méthodes Principales de LINQ

Voici les principales méthodes LINQ pour manipuler des listes en C#.

Méthode	Description
`Where`	Filtre les éléments selon une condition.
`Select`	Projette chaque élément dans une nouvelle forme.
`OrderBy`	Trie les éléments en ordre croissant.
`OrderByDescending`	Trie les éléments en ordre décroissant.
`GroupBy`	Regroupe les éléments selon une clé.
`First` / `FirstOrDefault`	Retourne le premier élément (ou une valeur par défaut).
`Last` / `LastOrDefault`	Retourne le dernier élément (ou une valeur par défaut).
`Any`	Vérifie si au moins un élément satisfait une condition.
`All`	Vérifie si tous les éléments satisfont une condition.
`Count`	Retourne le nombre d’éléments satisfaisant une condition.
`Sum`, `Min`, `Max`, `Average`	Effectue des calculs sur des données numériques.

3. Exemples Pratiques

3.1. Filtrer une Liste (`Where`)

Problème : Filtrer les nombres pairs dans une liste.

List<int> nombres = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };

var nombresPairs = nombres.Where(n => n % 2 == 0).ToList();

Console.WriteLine(string.Join(", ", nombresPairs)); // Résultat : 2, 4, 6, 8

3.2. Transformer une Liste (`Select`)

Problème : Multiplier chaque élément d’une liste par 2.

List<int> nombres = new List<int> { 1, 2, 3, 4, 5 };

var doubles = nombres.Select(n => n * 2).ToList();

Console.WriteLine(string.Join(", ", doubles)); // Résultat : 2, 4, 6, 8, 10

3.3. Trier une Liste (`OrderBy` et `OrderByDescending`)

Problème : Trier les éléments d’une liste en ordre croissant et décroissant.

List<int> nombres = new List<int> { 5, 2, 8, 1, 3 };

var croissant = nombres.OrderBy(n => n).ToList();
var decroissant = nombres.OrderByDescending(n => n).ToList();

Console.WriteLine(string.Join(", ", croissant)); // Résultat : 1, 2, 3, 5, 8
Console.WriteLine(string.Join(", ", decroissant)); // Résultat : 8, 5, 3, 2, 1

3.4. Regrouper les Éléments (`GroupBy`)

Problème : Grouper les mots par leur première lettre.

List<string> mots = new List<string> { "Pomme", "Poire", "Banane", "Prune", "Cerise" };

var groupes = mots.GroupBy(m => m[0]);

foreach (var groupe in groupes)
{
    Console.WriteLine($"Clé : {groupe.Key}");
    foreach (var mot in groupe)
    {
        Console.WriteLine($" - {mot}");
    }
}

Résultat :

Clé : P
 - Pomme
 - Poire
 - Prune
Clé : B
 - Banane
Clé : C
 - Cerise

3.5. Obtenir un Élement Spécifique (`First`, `Last`, `Single`)

Problème : Obtenir le premier élément pair dans une liste.

List<int> nombres = new List<int> { 1, 2, 3, 4, 5 };

int premierPair = nombres.First(n => n % 2 == 0);
Console.WriteLine(premierPair); // Résultat : 2

Problème : Obtenir le dernier élément de la liste.

int dernier = nombres.Last();
Console.WriteLine(dernier); // Résultat : 5

3.6. Vérifications (`Any`, `All`)

Problème : Vérifier si la liste contient au moins un nombre impair.

List<int> nombres = new List<int> { 2, 4, 6, 8 };

bool contientImpair = nombres.Any(n => n % 2 != 0);
Console.WriteLine(contientImpair); // Résultat : False

Problème : Vérifier si tous les nombres sont positifs.

bool tousPositifs = nombres.All(n => n > 0);
Console.WriteLine(tousPositifs); // Résultat : True

3.7. Calculs (`Sum`, `Min`, `Max`, `Average`)

Problème : Calculer la somme, le minimum, le maximum et la moyenne d’une liste.

List<int> nombres = new List<int> { 1, 2, 3, 4, 5 };

int somme = nombres.Sum();
int minimum = nombres.Min();
int maximum = nombres.Max();
double moyenne = nombres.Average();

Console.WriteLine($"Somme : {somme}, Min : {minimum}, Max : {maximum}, Moyenne : {moyenne}");

Résultat :

Somme : 15, Min : 1, Max : 5, Moyenne : 3

3.8. Combiner LINQ

Problème : Filtrer les nombres pairs, les multiplier par 2, puis les trier en ordre décroissant.

List<int> nombres = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8 };

var resultat = nombres
    .Where(n => n % 2 == 0) // Filtrer les pairs
    .Select(n => n * 2) // Multiplier par 2
    .OrderByDescending(n => n) // Trier en ordre décroissant
    .ToList();

Console.WriteLine(string.Join(", ", resultat)); // Résultat : 16, 12, 8, 4

4. Avantages de LINQ

Lisibilité : Les requêtes sont concises et faciles à lire.
Puissance : Offre des opérations complexes comme le filtrage, le tri et la transformation avec une syntaxe simple.
Chaînage : Permet de combiner plusieurs opérations en une seule requête.
Interopérabilité : Fonctionne sur différents types de collections (listes, tableaux, bases de données, etc.).

5. Exemple Complet

Voici un exemple combinant plusieurs fonctionnalités LINQ pour analyser une liste d’étudiants.

using System;
using System.Collections.Generic;
using System.Linq;

public class Etudiant
{
    public string Nom { get; set; }
    public int Age { get; set; }
    public double Note { get; set; }
}

class Program
{
    static void Main()
    {
        List<Etudiant> etudiants = new List<Etudiant>
        {
            new Etudiant { Nom = "Alice", Age = 20, Note = 15.5 },
            new Etudiant { Nom = "Bob", Age = 22, Note = 12.3 },
            new Etudiant { Nom = "Charlie", Age = 21, Note = 9.8 },
            new Etudiant { Nom = "David", Age = 23, Note = 16.0 }
        };

        // Étudiants ayant une note supérieure à 10
        var admissibles = etudiants.Where(e => e.Note > 10).ToList();
        Console.WriteLine("Étudiants admissibles :");
        admissibles.ForEach(e => Console.WriteLine($"{e.Nom} - {e.Note}"));

        // Étudiant ayant la meilleure note
        var meilleur = etudiants.OrderByDescending(e => e.Note).First();
        Console.WriteLine($"\nMeilleur étudiant : {meilleur.Nom} - {meilleur.Note}");

        // Moyenne des notes
        double moyenne = etudiants.Average(e => e.Note);
        Console.WriteLine($"\nMoyenne des notes : {moyenne}");
    }
}

Conclusion

LINQ est une puissante abstraction pour manipuler des listes de manière déclarative.
Ses méthodes permettent d’effectuer des opérations complexes en peu de code.
Apprenez à combiner plusieurs méthodes pour résoudre des problèmes plus complexes de manière efficace.