Aller au contenu principal

Collections de base

Notions théoriques​

List<T> — liste dynamique​

Contrairement aux tableaux (taille fixe), une List<T> peut grandir ou rétrécir dynamiquement.

// Création
var prenoms = new List<string>();

// Ajout
prenoms.Add("Alice");
prenoms.Add("Bob");
prenoms.Add("Charlie");

// Taille : .Count (pas .Length comme pour les tableaux !)
Console.WriteLine(prenoms.Count);   // 3

// Accès par indice
Console.WriteLine(prenoms[0]);      // Alice

// Suppression
prenoms.Remove("Bob");              // supprime par valeur
prenoms.RemoveAt(0);               // supprime par indice

// Test d'existence
bool present = prenoms.Contains("Alice");

// Tri
prenoms.Sort();
.Count vs .Length
  • Tableaux : utilisent .Length
  • List, Dictionary, HashSet... : utilisent .Count

C'est l'une des différences les plus fréquentes à ne pas confondre.

Initialisation de List​

// Syntaxe classique
var notes = new List<double> { 14.5, 12.0, 17.5 };

// Collection expression C# 12
List<double> notes = [14.5, 12.0, 17.5];

// Convertir un tableau en liste
double[] tableau = { 1.0, 2.0, 3.0 };
var liste = tableau.ToList();

Dictionary<TKey, TValue> — dictionnaire clé/valeur​

var stock = new Dictionary<string, int>();

// Ajout
stock["clavier"] = 5;
stock["souris"]  = 0;
stock["écran"]   = 2;

// Mise à jour (même syntaxe)
stock["clavier"] = 3;

// Lecture sécurisée avec TryGetValue
if (stock.TryGetValue("souris", out int qte))
    Console.WriteLine($"Stock souris : {qte}");

// Test d'existence de clé
if (stock.ContainsKey("clavier"))
    Console.WriteLine("Clavier en catalogue");

// Parcours
foreach (var (produit, quantite) in stock)
    Console.WriteLine($"  {produit} : {quantite}");
Accès par clé inexistante

stock["inexistant"] lève une KeyNotFoundException. Utilisez toujours TryGetValue ou ContainsKey avant d'accéder à une clé dont l'existence n'est pas garantie.

HashSet<T> — ensemble sans doublons​

var tags = new HashSet<string>();

tags.Add("csharp");
tags.Add("dotnet");
tags.Add("csharp");    // doublon ignoré silencieusement

Console.WriteLine(tags.Count);              // 2
Console.WriteLine(tags.Contains("dotnet")); // true

// Opérations ensemblistes
var autres = new HashSet<string> { "java", "csharp" };
tags.IntersectWith(autres);   // garde l'intersection
tags.UnionWith(autres);       // ajoute l'union

Initialisation avec syntaxe objet​

var inventaire = new Dictionary<string, int>
{
    { "clavier", 5  },
    { "souris",  10 },
    { "écran",   2  },
};

// Syntaxe indexeur (C# 6+, équivalent)
var inventaire = new Dictionary<string, int>
{
    ["clavier"] = 5,
    ["souris"]  = 10,
    ["écran"]   = 2,
};

Exemple pratique​

// Gestion de stock avec Dictionary
var stock = new Dictionary<string, int>
{
    ["Clavier mécanique"] = 5,
    ["Souris ergonomique"] = 0,
    ["Câble USB-C 2m"]    = 12,
    ["Webcam HD"]         = 2,
    ["Tapis de souris"]   = 0,
};

Console.WriteLine("=== État du stock ===");
foreach (var (produit, qte) in stock)
{
    string statut = qte == 0 ? "⚠ RUPTURE" : $"{qte} unité(s)";
    Console.WriteLine($"  {produit,-25} : {statut}");
}

// Produits en rupture
var ruptures = new List<string>();
foreach (var (produit, qte) in stock)
    if (qte == 0) ruptures.Add(produit);

Console.WriteLine($"\n{ruptures.Count} produit(s) en rupture :");
foreach (var p in ruptures)
    Console.WriteLine($"  - {p}");

// Mise à jour d'un stock
string produitAReappro = "Souris ergonomique";
if (stock.ContainsKey(produitAReappro))
{
    stock[produitAReappro] = 8;
    Console.WriteLine($"\nStock '{produitAReappro}' mis à jour : {stock[produitAReappro]} unités");
}

Test de mémorisation/compréhension​


Quelle propriété donne le nombre d'éléments d'une `List<string>` ?


Que se passe-t-il si on ajoute un doublon dans un `HashSet<T>` ?


Quelle méthode lit une valeur de Dictionary sans risquer une KeyNotFoundException ?


Comment ajouter un élément à une `List<int>` ?


Quelle collection est la plus adaptée pour stocker des données sans doublons et tester rapidement si un élément est présent ?


TP pour réfléchir et résoudre des problèmes​

Vous allez gérer un inventaire de magasin avec un Dictionary.

Étape 1 — Créer le stock​

Créez un dictionnaire produit → quantité avec 5 articles.


Bonne pratique - Initialiser le Dictionary avec la syntaxe indexeur

La syntaxe ["clé"] = valeur est plus lisible que { "clé", valeur } car elle met en évidence la relation clé → valeur. Elle est aussi plus proche de la syntaxe d'accès utilisée ensuite : stock["Clavier"].

Étape 2 — Détecter les ruptures​

Créez une liste des produits en rupture (quantité = 0).


Bonne pratique - List pour les résultats de filtrage

Utilisez une List<string> pour collecter les résultats d'un filtrage. Elle est plus flexible qu'un tableau (taille inconnue à l'avance) et plus simple que d'autres collections. Vous pouvez ensuite la passer à string.Join ou la parcourir normalement.

Étape 3 — Réapprovisionner un produit​

Mettez à jour la quantité d'un produit après vérification de son existence.


Bonne pratique - Toujours vérifier l'existence de la clé

Avant d'accéder à stock[produit], vérifiez toujours avec ContainsKey ou TryGetValue. Un accès direct à une clé inexistante lève une KeyNotFoundException qui fait planter le programme.

📌 Une solution