Les types génériques en C#

Bienvenue dans la première leçon sur les « fonctionnalités avancées de C# » ! Dans cette leçon, vous apprendrez ce que sont les types génériques, une fonctionnalité puissante de C# qui vous permet de créer du code flexible et réutilisable. Commençons !

Que sont les types génériques ?

Les types génériques sont une fonctionnalité de C# qui vous permet de définir des classes, des méthodes et des structures de données avec un espace réservé pour le type de données qu’elles stockent ou utilisent. Les types génériques permettent d’assurer la sûreté du typage et de réutiliser le code.

Exemple : une liste générique (List<T>) peut stocker des éléments de n’importe quel type tout en garantissant la sûreté du typage.

Créer des classes génériques

Vous pouvez définir une classe générique à l’aide de la syntaxe <T>, où T représente un paramètre de type. Exemple :

Point clé : utilisez les types génériques pour créer des classes qui fonctionnent avec n’importe quel type de données tout en préservant la sûreté du typage.

using System;

class GenericBox<T> {
    public T Value { get; set; }

    public void Display() {
        Console.WriteLine("Value: " + Value);
    }
}

class Program {
    static void Main() {
        GenericBox<int> intBox = new GenericBox<int> { Value = 42 };
        intBox.Display(); // Outputs: Value: 42

        GenericBox<string> stringBox = new GenericBox<string> { Value = "Hello, Generics!" };
        stringBox.Display(); // Outputs: Value: Hello, Generics!
    }
}

Créer des méthodes génériques

Vous pouvez définir une méthode générique au sein d’une classe. Exemple :

Conseil : utilisez les méthodes génériques pour les opérations qui s’appliquent à plusieurs types de données.

using System;

class Program {
    static void Main() {
        PrintValue(42);
        PrintValue("Generics are powerful!");
    }

    static void PrintValue<T>(T value) {
        Console.WriteLine("Value: " + value);
    }
}

Contraintes des types génériques

Les contraintes restreignent les types qui peuvent être utilisés comme paramètres de type. Exemple :

• where T : struct - T doit être un type valeur.
• where T : class - T doit être un type référence.
• where T : new() - T doit avoir un constructeur sans paramètre.

Exemple :

Point clé : les contraintes rendent les types génériques plus flexibles et adaptés à des scénarios spécifiques.

using System;

class Program {
    static void Main() {
        DisplayDefault<int>();
        DisplayDefault<string>();
    }

    static void DisplayDefault<T>() where T : new() {
        T instance = new T();
        Console.WriteLine("Created instance of: " + typeof(T));
    }
}

Collections génériques

C# fournit plusieurs collections génériques intégrées :

• Liste<T> : stocke une collection d’éléments dans un tableau dynamique.
• Dictionnaire<TKey, TValue> : stocke des paires clé-valeur pour des recherches rapides.
• File<T> : implémente une structure premier entré, premier sorti (FIFO).

Exemple : utiliser une liste générique :

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        names.Add("Diana");

        foreach (string name in names) {
            Console.WriteLine(name);
        }
    }
}

Exercice pratique

Créez une classe générique Pair<TKey, TValue> qui stocke une paire clé-valeur, ainsi qu’une méthode générique Swap() qui échange la clé et la valeur. Exemple :

using System;

class Pair<TKey, TValue> {
    public TKey Key { get; set; }
    public TValue Value { get; set; }

    public void Swap() {
        (Key, Value) = ((TKey)(object)Value, (TValue)(object)Key);
    }

    public void Display() {
        Console.WriteLine($"Key: {Key}, Value: {Value}");
    }
}

class Program {
    static void Main() {
        Pair<string, int> pair = new Pair<string, int> { Key = "Age", Value = 30 };
        pair.Display();
        pair.Swap();
        pair.Display();
    }
}

Bonnes pratiques d’utilisation des types génériques

Voici quelques bonnes pratiques :

• Utilisez les types génériques pour créer des classes et des méthodes réutilisables et sûres du point de vue du typage.
• Appliquez des contraintes lorsque des exigences de type spécifiques sont nécessaires.
• Préférez les collections génériques aux collections non génériques pour de meilleures performances et une plus grande sécurité.

Conseil : utilisez des noms explicites pour les paramètres de type, comme T pour le type ou TKey et TValue pour les paires clé-valeur.

Bravo !

Félicitations ! Vous avez appris à utiliser les génériques pour créer du code réutilisable et flexible en C#. Dans la prochaine leçon, nous explorerons la programmation asynchrone avec async et await. Continuons à coder !