Partager via

Classes et méthodes génériques

Les génériques introduisent le concept de paramètres de type dans .NET. Les génériques permettent de concevoir des classes et des méthodes qui reportent la spécification d’un ou plusieurs paramètres de type jusqu’à ce que vous utilisiez la classe ou la méthode dans votre code. Par exemple, à l’aide d’un paramètre de type générique T, vous pouvez écrire une seule classe qui peut être utilisée par un autre code client sans impliquer le coût ou le risque des casts de runtime ou des opérations de boxing à l’exécution, comme illustré ici :

// Declare the generic class.
public class GenericList<T>
{
    public void Add(T item) { }
}

public class ExampleClass { }

class TestGenericList
{
    static void Main()
    {
        // Create a list of type int.
        GenericList<int> list1 = new();
        list1.Add(1);

        // Create a list of type string.
        GenericList<string> list2 = new();
        list2.Add("");

        // Create a list of type ExampleClass.
        GenericList<ExampleClass> list3 = new();
        list3.Add(new ExampleClass());
    }
}

Les classes et méthodes génériques combinent la réutilisation, la sécurité des types et l’efficacité d’une manière que leurs équivalents non génériques ne peuvent pas. Les paramètres de type générique sont remplacés par les arguments de type pendant la compilation. Dans l’exemple précédent, le compilateur remplace T par int. Les génériques sont les plus fréquemment utilisés avec des collections et les méthodes qui fonctionnent dessus. Le namespace System.Collections.Generic contient plusieurs classes de collections basées sur des génériques. Les collections non génériques, telles que ArrayList celles qui ne sont pas recommandées, sont conservées uniquement à des fins de compatibilité. Pour plus d’informations, consultez Génériques dans .NET.

Vous pouvez également créer des types et méthodes génériques personnalisés pour fournir vos propres solutions généralisées et modèles de conception qui sont fiables et efficaces. L’exemple de code suivant montre une classe de liste liée générique simple à des fins de démonstration. (Dans la plupart des cas, vous devez utiliser la List<T> classe fournie par .NET au lieu de créer votre propre fichier.) Le paramètre T de type est utilisé dans plusieurs emplacements où un type concret serait généralement utilisé pour indiquer le type de l’élément stocké dans la liste :

  • En tant que type de paramètre de méthode dans la AddHead méthode.
  • Comme type de retour de la propriété Data dans la classe imbriquée Node.
  • Comme le type de membre privé data de la classe imbriquée.

T est disponible pour la classe imbriquée Node . Lorsqu’elle GenericList<T> est instanciée avec un type concret, par exemple sous la forme d’un GenericList<int>, chaque occurrence de T est remplacée par int.

// Type parameter T in angle brackets.
public class GenericList<T>
{
    // The nested class is also generic, and
    // holds a data item of type T.
    private class Node(T t)
    {
        // T as property type.
        public T Data { get; set; } = t;

        public Node? Next { get; set; }
    }

    // First item in the linked list
    private Node? head;

    // T as parameter type.
    public void AddHead(T t)
    {
        Node n = new(t);
        n.Next = head;
        head = n;
    }

    // T in method return type.
    public IEnumerator<T> GetEnumerator()
    {
        Node? current = head;

        while (current is not null)
        {
            yield return current.Data;
            current = current.Next;
        }
    }
}

L’exemple de code suivant montre comment le code client utilise la classe générique GenericList<T> pour créer une liste d’entiers. Si vous modifiez l’argument de type, le code suivant crée des listes de chaînes ou tout autre type personnalisé :

// A generic list of int.
GenericList<int> list = new();

// Add ten int values.
for (int x = 0; x < 10; x++)
{
    list.AddHead(x);
}

// Write them to the console.
foreach (int i in list)
{
    Console.WriteLine(i);
}

Console.WriteLine("Done");

Remarque

Les types génériques ne sont pas limités aux classes. Les exemples précédents utilisent des types class, mais vous pouvez définir des types génériques interface et struct, y compris record.

Vue d’ensemble des génériques

  • Utilisez des types génériques pour optimiser la réutilisation du code, la sécurité des types et les performances.
  • L’utilisation la plus courante des génériques consiste à créer des classes de collection.
  • La bibliothèque de classes .NET contient plusieurs classes de collection génériques dans l'espace de noms System.Collections.Generic. Les collections génériques doivent être utilisées chaque fois que cela est possible au lieu de classes telles que ArrayList dans l’espace System.Collections de noms.
  • Vous pouvez créer vos propres interfaces génériques, classes, méthodes, événements et délégués.
  • Les classes génériques peuvent être contraintes pour permettre l’accès aux méthodes sur des types de données particuliers.
  • Vous pouvez obtenir des informations au moment de l’exécution sur les types utilisés dans un type de données générique à l’aide de la réflexion.

Spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#.

Voir aussi