Generics en C# : pourquoi sont-ils nécessaires et comment les utiliser pour les débutants

Generics en C# : pourquoi sont-ils nécessaires et comment les utiliser

Lors du développement en C#, tôt ou tard, chacun se retrouve dans une situation où le même algorithme doit être appliqué à différents types de données. Auparavant, pour cela, il fallait soit écrire plusieurs versions d'une même méthode, soit utiliser le type object, ce qui entraînait une perte de performance et un risque d'erreurs. La solution à ce problème est Generics (types génériques). Dans cet article, nous allons voir ce que sont les generics, pourquoi ils sont nécessaires et comment les utiliser correctement en C#.

Que sont les Generics en C# ?

Les Generics (génériques) sont un mécanisme du langage C# qui permet de créer des classes, méthodes, interfaces et délégués fonctionnant avec différents types de données, sans perdre pour autant la typage strict. Au lieu d'écrire du code pour chaque type séparément, vous créez un modèle universel qui substitue le type nécessaire lors de la compilation.

Imaginez que vous deviez écrire une méthode pour échanger les valeurs de deux variables. Sans generics, vous devriez créer des méthodes distinctes pour int, string, double, etc. Avec les generics, vous écrivez une seule méthode qui fonctionne avec n'importe quel type.

Voici un exemple très simple de déclaration d'une méthode générique :

public void Swap<T>(ref T a, ref T b)\n{\n    T temp = a;\n    a = b;\n    b = temp;\n}

Ici, <T> est le paramètre de type. La lettre T est une notation courante (de Type), mais vous pouvez utiliser n'importe quel nom. Lorsque vous appelez la méthode, vous spécifiez le type concret :

int x = 5, y = 10;\nSwap<int>(ref x, ref y);\n// Maintenant x = 10, y = 5\n\nstring first = "Hello", second = "World";\nSwap<string>(ref first, ref second);\n// Maintenant first = "World", second = "Hello"

Pourquoi les Generics sont-ils nécessaires : principaux avantages

L'utilisation des generics offre plusieurs avantages importants qui rendent le code meilleur et plus sûr.

1. Sécurité des types (Type Safety)

Contrairement à l'utilisation de object, les generics vérifient les types lors de la compilation. Vous ne pourrez pas accidentellement passer une chaîne là où un nombre est attendu. Le compilateur signalera immédiatement l'erreur.

2. Performance

Lors de l'utilisation de object, un boxing (encapsulation) des types valeur (int, double, struct) en type référence et un unboxing (désencapsulation) inverse se produisent. Ce sont des opérations coûteuses. Les generics éliminent complètement ces processus, car le compilateur génère un code spécialisé pour chaque type.

3. Réutilisation du code

Vous n'avez pas besoin d'écrire le même algorithme pour différents types. Une seule classe ou méthode générique peut fonctionner avec des milliers de types différents.

4. Lisibilité et maintenabilité

Le code devient plus propre et plus compréhensible. Vous voyez clairement avec quels types la méthode ou la classe fonctionne, et la logique est séparée des types de données concrets.

Comment utiliser les Generics : exemples pratiques

Examinons quelques scénarios réels d'utilisation des generics en C#.

Classes génériques

L'exemple le plus courant est celui des collections. Au lieu de créer votre propre classe pour stocker une liste de nombres, de chaînes ou d'objets personnalisés, vous utilisez List<T> :

List<int> numbers = new List<int>();\nnumbers.Add(1);\nnumbers.Add(2);\n\nList<string> names = new List<string>();\nnames.Add("Alice");\nnames.Add("Bob");\n\n// Votre propre classe générique\npublic class Repository<T>\n{\n    private List<T> _items = new List<T>();\n\n    public void Add(T item) => _items.Add(item);\n    public T Get(int index) => _items[index];\n}\n\nRepository<int> intRepo = new Repository<int>();\nintRepo.Add(100);\nint value = intRepo.Get(0); // 100

Méthodes génériques

Les méthodes peuvent être génériques même à l'intérieur de classes ordinaires :