Génériques (guide de programmation C#)Generics (C# Programming Guide)

Les génériques ont été ajoutés à la version 2.0 du langage C# et du Common Language Runtime (CLR).Generics were added to version 2.0 of the C# language and the common language runtime (CLR). Les génériques introduisent le concept des paramètres de type dans .NET Framework, qui permettent de concevoir des classes et des méthodes qui diffèrent la spécification d’un ou de plusieurs types jusqu’à ce que la classe ou la méthode soit déclarée et instanciée par le code client.Generics introduce to the .NET Framework the concept of type parameters, which make it possible to design classes and methods that defer the specification of one or more types until the class or method is declared and instantiated by client 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 ou des opérations de boxing à l’exécution, comme illustré ici :For example, by using a generic type parameter T you can write a single class that other client code can use without incurring the cost or risk of runtime casts or boxing operations, as shown here:

// Declare the generic class.
public class GenericList<T>
{
    public void Add(T input) { }
}
class TestGenericList
{
    private class ExampleClass { }
    static void Main()
    {
        // Declare a list of type int.
        GenericList<int> list1 = new GenericList<int>();
        list1.Add(1);

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

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

Les méthodes et les classes génériques combinent la réutilisabilité, la cohérence des types et l’efficacité, ce que ne peuvent pas faire leurs équivalents non génériques.Generic classes and methods combine reusability, type safety and efficiency in a way that their non-generic counterparts cannot. Les génériques sont plus fréquemment utilisés dans des collections et des méthodes qui agissent sur eux.Generics are most frequently used with collections and the methods that operate on them. La version 2.0 de la bibliothèque de classes .NET Framework fournit un nouvel espace de noms, System.Collections.Generic, qui contient plusieurs nouvelles classes de collection génériques.Version 2.0 of the .NET Framework class library provides a new namespace, System.Collections.Generic, which contains several new generic-based collection classes. Pour toutes les applications qui ciblent le .NET Framework version 2.0 et ultérieures, il est recommandé d’utiliser les nouvelles classes de collection génériques plutôt que leurs équivalents non génériques, tels que ArrayList.It is recommended that all applications that target the .NET Framework 2.0 and later use the new generic collection classes instead of the older non-generic counterparts such as ArrayList. Pour plus d’informations, consultez Génériques en .NET.For more information, see Generics in .NET.

Bien sûr, vous pouvez également créer des types et des méthodes génériques personnalisés pour fournir des solutions et des modèles de conception généralisés qui soient efficaces et de type sécurisé.Of course, you can also create custom generic types and methods to provide your own generalized solutions and design patterns that are type-safe and efficient. L’exemple de code suivant montre une classe de liste liée générique simple, à des fins de démonstration.The following code example shows a simple generic linked-list class for demonstration purposes. Dans la plupart des cas, vous aurez tout intérêt à utiliser la classe List<T> fournie par la bibliothèque de classes .NET Framework plutôt que de créer la vôtre. Le paramètre de type T est utilisé dans plusieurs emplacements où un type concret est normalement utilisé pour indiquer le type de l’élément stocké dans la liste.(In most cases, you should use the List<T> class provided by the .NET Framework class library instead of creating your own.) The type parameter T is used in several locations where a concrete type would ordinarily be used to indicate the type of the item stored in the list. Il est utilisé de la façon suivante :It is used in the following ways:

  • Comme le type d’un paramètre de méthode dans la méthodeAddHead.As the type of a method parameter in the AddHead method.

  • Comme le type de retour de la propriété Data de la classe imbriquée Node.As the return type of the Data property in the nested Node class.

  • Comme le type de membre privé data de la classe imbriquée.As the type of the private member data in the nested class.

Notez que T est disponible pour la classe imbriquée Node.Note that T is available to the nested Node class. Quand GenericList<T> est instancié avec un type concret, par exemple comme un GenericList<int>, chaque occurrence de T est remplacée par int.When GenericList<T> is instantiated with a concrete type, for example as a GenericList<int>, each occurrence of T will be replaced with int.

// type parameter T in angle brackets
public class GenericList<T> 
{
    // The nested class is also generic on T.
    private class Node
    {
        // T used in non-generic constructor.
        public Node(T t)
        {
            next = null;
            data = t;
        }

        private Node next;
        public Node Next
        {
            get { return next; }
            set { next = value; }
        }
        
        // T as private member data type.
        private T data;

        // T as return type of property.
        public T Data  
        {
            get { return data; }
            set { data = value; }
        }
    }

    private Node head;
    
    // constructor
    public GenericList() 
    {
        head = null;
    }

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

    public IEnumerator<T> GetEnumerator()
    {
        Node current = head;

        while (current != 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.The following code example shows how client code uses the generic GenericList<T> class to create a list of integers. En changeant l’argument de type, vous pouvez facilement modifier le code suivant pour créer des listes de chaînes ou tout autre type personnalisé :Simply by changing the type argument, the following code could easily be modified to create lists of strings or any other custom type:

class TestGenericList
{
    static void Main()
    {
        // int is the type argument
        GenericList<int> list = new GenericList<int>();

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

        foreach (int i in list)
        {
            System.Console.Write(i + " ");
        }
        System.Console.WriteLine("\nDone");
    }
}

Vue d’ensemble des génériquesGenerics Overview

  • Utilisez des types génériques pour optimiser la réutilisation de code, la sécurité des types et les performances.Use generic types to maximize code reuse, type safety, and performance.

  • L’utilisation la plus courante des génériques est de créer des classes de collection.The most common use of generics is to create collection classes.

  • La bibliothèque de classes du .NET Framework contient plusieurs nouvelles classes de collection génériques dans l’espace de noms System.Collections.Generic.The .NET Framework class library contains several new generic collection classes in the System.Collections.Generic namespace. Celles-ci doivent être utilisées chaque fois que c’est possible, à la place de classes comme ArrayList dans l’espace de noms System.Collections.These should be used whenever possible instead of classes such as ArrayList in the System.Collections namespace.

  • Vous pouvez créer vos propres interfaces, classes, méthodes, événements et délégués génériques.You can create your own generic interfaces, classes, methods, events and delegates.

  • Les classes génériques peuvent être contraintes pour permettre l’accès à des méthodes sur des types de données particuliers.Generic classes may be constrained to enable access to methods on particular data types.

  • Des informations sur les types qui sont utilisés dans un type de données générique peuvent être obtenues à l’exécution à l’aide de la réflexion.Information on the types that are used in a generic data type may be obtained at run-time by using reflection.

Pour plus d'informations :For more information:

Spécification du langage C#C# Language Specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification.

Voir aussiSee also