Module C#.8 – Collections

Objectif

Maîtriser les collections C# : Array, List, Dictionary, HashSet et bases de LINQ pour manipuler efficacement les données.

Théorie

Array (Tableaux)

Les tableaux sont de taille fixe.

Création

// Déclaration et initialisation
int[] nombres = {10, 20, 30};
int[] autres = new int[5];  // Taille fixe : 5 éléments

// Déclaration puis initialisation
int[] nombres2;
nombres2 = new int[] {10, 20, 30};

Accès et modification

int[] nombres = {10, 20, 30};

nombres[0];           // 10 (premier élément, index 0)
nombres[1] = 25;      // Modifie le deuxième élément
nombres.Length;       // 3 (propriété, pas méthode)

Limitations

• Taille fixe (ne peut pas grandir/rétrécir)
• Performance optimale pour accès direct
• Pas de méthodes utilitaires intégrées

List<T>

Liste dynamique qui peut grandir.

Création et utilisation

using System.Collections.Generic;

List<string> noms = new List<string>();
noms.Add("Jean");
noms.Add("Marie");
noms.Insert(0, "Pierre");  // Insère à l'index 0

noms[0];            // "Pierre"
noms.Count;         // 3
noms.Remove("Jean"); // Retire "Jean"
noms.RemoveAt(0);   // Retire l'élément à l'index 0
noms.Contains("Marie"); // true
noms.Clear();       // Vide la liste

Initialisation

List<int> nombres = new List<int> {10, 20, 30};
var noms = new List<string> {"Jean", "Marie"};

Méthodes utiles

List<int> nombres = new List<int> {10, 20, 30, 20};

nombres.IndexOf(20);        // 1 (première occurrence)
nombres.LastIndexOf(20);     // 3
nombres.Find(n => n > 15);   // 20 (premier élément > 15)
nombres.FindAll(n => n > 15); // [20, 30, 20]
nombres.Sort();              // Trie en place
nombres.Reverse();           // Inverse

Dictionary<TKey, TValue>

Structure clé-valeur pour stocker des paires.

Création et utilisation

using System.Collections.Generic;

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Jean"] = 30;
ages["Marie"] = 25;
ages.Add("Pierre", 35);

ages["Jean"];              // 30
ages.ContainsKey("Jean");   // true
ages.ContainsValue(30);     // true
ages.Remove("Jean");       // Retire la paire
ages.Count;                // 2
ages.Clear();              // Vide

Parcourir

// Par clés
foreach (string nom in ages.Keys)
{
    Console.WriteLine($"{nom}: {ages[nom]}");
}

// Par valeurs
foreach (int age in ages.Values)
{
    Console.WriteLine(age);
}

// Par paires
foreach (KeyValuePair<string, int> entry in ages)
{
    Console.WriteLine($"{entry.Key}: {entry.Value}");
}

// Avec var
foreach (var entry in ages)
{
    Console.WriteLine($"{entry.Key}: {entry.Value}");
}

HashSet<T>

Collection de valeurs uniques.

Création et utilisation

HashSet<string> noms = new HashSet<string>();
noms.Add("Jean");
noms.Add("Marie");
noms.Add("Jean");  // Ignoré (déjà présent)

noms.Contains("Jean");  // true
noms.Count;             // 2
noms.Remove("Jean");

Opérations ensemblistes

HashSet<int> set1 = new HashSet<int> {1, 2, 3};
HashSet<int> set2 = new HashSet<int> {3, 4, 5};

set1.UnionWith(set2);        // set1 devient {1, 2, 3, 4, 5}
set1.IntersectWith(set2);     // set1 devient {3}
set1.ExceptWith(set2);        // set1 devient {1, 2}

LINQ (Language Integrated Query)

Système de requêtes intégré pour manipuler les collections.

Méthodes essentielles

Where : Filtre

using System.Linq;

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

Select : Transforme

var doubles = nombres.Select(n => n * 2).ToList();
var noms = etudiants.Select(e => e.Nom).ToList();

OrderBy / OrderByDescending : Trie

var tries = etudiants.OrderBy(e => e.Nom).ToList();
var triesDesc = etudiants.OrderByDescending(e => e.Age).ToList();

First / FirstOrDefault :

var premier = nombres.First(n => n > 15);  // Lance exception si aucun
var premierOuDefaut = nombres.FirstOrDefault(n => n > 100);  // 0 si aucun

Any / All :

bool aGrand = nombres.Any(n => n > 25);
bool tousPositifs = nombres.All(n => n > 0);

Count / Sum / Average / Max / Min :

int count = nombres.Count(n => n > 15);
int somme = nombres.Sum();
double moyenne = nombres.Average();
int max = nombres.Max();
int min = nombres.Min();

GroupBy :

var groupes = etudiants.GroupBy(e => e.Ecole);
foreach (var groupe in groupes)
{
    Console.WriteLine($"École : {groupe.Key}");
    foreach (var etudiant in groupe)
    {
        Console.WriteLine($"  - {etudiant.Nom}");
    }
}

Syntaxe de requête (Query Syntax)

Alternative à la syntaxe de méthode.

var resultat = from n in nombres
               where n > 15
               orderby n descending
               select n * 2;

Exercice

1. Tableaux

   • Créez et manipulez des tableaux
   • Testez les limites (IndexOutOfRangeException)
   • Comprenez la taille fixe

2. List

   • Créez des listes dynamiques
   • Testez toutes les méthodes
   • Parcourez de différentes manières

3. Dictionary

   • Créez des dictionaries
   • Stockez et récupérez des valeurs
   • Parcourez avec foreach

4. HashSet

   • Retirez les doublons d'une liste
   • Testez les opérations ensemblistes
   • Utilisez pour vérifier l'appartenance

5. LINQ

   • Utilisez Where, Select, OrderBy
   • Testez GroupBy, Aggregate
   • Comparez avec les boucles classiques

Quiz

1. Quelle est la différence entre Array et List ?

   • Aucune différence
   • Array taille fixe, List dynamique
   • List est plus rapide

2. Comment parcourir un Dictionary ?

   • for (int i = 0; i < dict.Count; i++)
   • foreach (var entry in dict)
   • dict.ForEach()

3. Que fait HashSet ?

   • Trie les éléments
   • Stocke des valeurs uniques
   • Permet les doublons

4. Que fait Where() en LINQ ?

   • Transforme les éléments
   • Filtre les éléments
   • Trie les éléments

5. Que fait Select() en LINQ ?

   • Filtre les éléments
   • Transforme les éléments
   • Trie les éléments

Mini défi

Mission : Créer un système de gestion de données complet

Créez un système qui gère une collection de produits :

Données :

class Produit
{
    public int Id { get; set; }
    public string Nom { get; set; }
    public double Prix { get; set; }
    public int Stock { get; set; }
    public string Categorie { get; set; }
}

Fonctionnalités :

1. Recherche par nom, ID, catégorie (LINQ Where)
2. Tri par prix, stock, nom (LINQ OrderBy)
3. Calculs (prix moyen, total stock) (LINQ Average, Sum)
4. Filtres (stock > 0, prix < seuil) (LINQ Where)
5. Groupement par catégorie (LINQ GroupBy)

Critères :

• ✅ Utilisation de List et Dictionary
• ✅ LINQ approprié (Where, Select, GroupBy)
• ✅ Code organisé
• ✅ Performance optimisée

Objectif : Maîtriser toutes les collections C# et LINQ pour manipuler efficacement les données.

---

Validation : Vous pouvez passer au module suivant quand vous maîtrisez Array, List, Dictionary, HashSet et LINQ de base.