Que sont les génériques et les contraintes ?

Question

Accepted Answer

**Les génériques** vous permettent d'écrire des classes et des méthodes paramétrées par un type, offrant **la sécurité des types et la réutilisabilité** sans duplication de code ni conversion de type. **Les contraintes** restreignent les types qu'un paramètre générique peut être, ce qui permet l'utilisation sûre de leurs membres. Les génériques sont omniprésents en C# (toute la bibliothèque des collections les utilise). ## Le problème que les génériques résolvent ```csharp // without generics — either duplicate per type, or use `object` (unsafe, requires casts) object Get(object[] arr, int i) => arr[i]; // returns object → cast needed, runtime errors // with generics — type-safe and reusable T Get(T[] arr, int i) => arr[i]; // works for any T, returns the exact type int x = Get(new[] { 1, 2, 3 }, 0); // T inferred as int, no cast ``` Les génériques déplacent les erreurs de type de l'exécution (conversion `object`) vers la compilation, et éliminent les conversions — un code sûr et réutilisable. ## Classes et méthodes génériques ```csharp public class Box // a generic class { private T _value; public void Set(T value) => _value = value; public T Get() => _value; } var box = new Box(); // T = string, type-safe // generic method public T Max(T a, T b) where T : IComparable // constraint (see below) => a.CompareTo(b) > 0 ? a : b; ``` ## Contraintes — restreindre le paramètre de type ```csharp where T : class // T must be a reference type where T : struct // T must be a value type where T : new() // T must have a parameterless constructor where T : IComparable // T must implement an interface (so you can call its members) where T : BaseClass // T must derive from BaseClass // example: constraint lets you call CompareTo safely public T Max(T a, T b) where T : IComparable => a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint ``` **Les contraintes** (`where T : ...`) restreignent ce que `T` peut être, ce qui vous permet d'utiliser les membres de ce type en toute sécurité (par exemple, la contrainte à `IComparable` vous permet d'appeler `CompareTo`). Sans contrainte, `T` pourrait être n'importe quoi, donc vous ne pouvez présumer d'aucun membre. ## Les génériques partout dans .NET ```text List, Dictionary, IEnumerable, Task, Nullable ... → the entire collections library and much of .NET is generic. ``` ## Pourquoi c'est important Les génériques sont fondamentaux en C# — ils sont utilisés de manière omniprésente (toute la bibliothèque des collections, `Task`, `IEnumerable` et d'innombrables API sont génériques), donc les comprendre est essentiel pour tout développement C#. Les génériques résolvent un vrai problème : écrire du code réutilisable qui fonctionne pour plusieurs types tout en préservant la **sécurité des types** — l'alternative (utiliser `object` et les conversions) sacrifie la sécurité au moment de la compilation et nécessite des conversions sujettes aux erreurs, tandis que la duplication de code par type est difficile à maintenir. Les génériques vous donnent un code réutilisable et type-safe sans conversion et avec une vérification des erreurs à la compilation. **Les contraintes** (`where T : ...`) sont un complément important : elles restreignent ce qu'un paramètre de type peut être, ce qui à la fois permet l'utilisation sûre des membres du type (la contrainte à une interface vous permet d'appeler ses méthodes) et assure une utilisation correcte. Comprendre les classes et méthodes génériques, comment fonctionne l'inférence de type et les contraintes (`class`, `struct`, `new()`, contraintes d'interface/classe de base) est nécessaire à la fois pour utiliser efficacement les bibliothèques .NET fortement génériques et pour écrire vos propres abstractions réutilisables et type-safe. Puisque les génériques sous-tendent les collections de C# et une grande partie du framework, et puisqu'ils sont la clé du code réutilisable type-safe, maîtriser les génériques et les contraintes est une connaissance fondamentale et fréquemment appliquée pour un développement C# efficace et un sujet courant reflétant la compréhension de la conception réutilisable et type-safe.