Génériques dans le .NET Framework

Article
08/10/2011

Les génériques vous permettent d'adapter une méthode, une classe, une structure ou une interface au type de données précis sur lequel elle agit. Par exemple, au lieu d'utiliser la classe Hashtable, qui autorise des clés et de valeurs de n'importe quel type, vous pouvez utiliser la classe générique Dictionary<TKey, TValue> et spécifier le type autorisé pour la clé et le type autorisé pour la valeur. Les génériques offrent plusieurs avantages dont celui de pouvoir réutiliser le code et la sécurité de type.

Cette rubrique présente les génériques dans le .NET Framework et résume les types ou méthodes génériques. Elle contient les sections suivantes :

Définition et utilisation de génériques
Terminologie des génériques
Prise en charge des bibliothèques de classes et des langages
Types imbriqués et génériques
Rubriques connexes
Référence

Définition et utilisation de génériques

Les génériques sont des classes, des structures, des interfaces et des méthodes qui possèdent des espaces réservés (paramètres de type) pour un ou plusieurs des types qu'ils stockent ou utilisent. Une classe de collection générique peut utiliser un paramètre de type comme espace réservé du type d'objets qu'elle stocke ; les paramètres de type se présentent comme les types de ses champs et les types de paramètre de ses méthodes. Une méthode générique peut utiliser son paramètre de type en tant que type de sa valeur de retour ou en tant que type de l'un de ses paramètres formels. Le code suivant illustre une définition de classe générique simple.

Public Class Generic(Of T)
    Public Field As T

End Class

public class Generic<T>
{
    public T Field;
}

generic<typename T>
public ref class Generics
{
public:
    T Field;
};

Lorsque vous créez une instance d'une classe générique, vous spécifiez les types à substituer aux paramètres de type. Vous créez ainsi une nouvelle classe générique, désignée par le terme « classe générique construite », les types que vous avez choisis étant substitués là où les paramètres de type apparaissent. Le résultat est une classe de type sécurisé qui est adaptée à votre choix de types, comme l'illustre le code suivant.

Public Shared Sub Main()
    Dim g As New Generic(Of String)
    g.Field = "A string"
    '...
    Console.WriteLine("Generic.Field           = ""{0}""", g.Field)
    Console.WriteLine("Generic.Field.GetType() = {0}", g.Field.GetType().FullName)
End Sub

public static void Main()
{
    Generic<string> g = new Generic<string>();
    g.Field = "A string";
    //...
    Console.WriteLine("Generic.Field           = \"{0}\"", g.Field);
    Console.WriteLine("Generic.Field.GetType() = {0}", g.Field.GetType().FullName);
}

static void Main()
{
    Generics<String^>^ g = gcnew Generics<String^>();
    g->Field = "A string";
    //...
    Console::WriteLine("Generics.Field           = \"{0}\"", g->Field);
    Console::WriteLine("Generics.Field.GetType() = {0}", g->Field->GetType()->FullName);
}

Retour au début

Terminologie des génériques

La terminologie utilisée pour les génériques dans le .NET Framework est la suivante :

Une définition de type générique est une déclaration de classe, de structure ou d'interface qui fonctionne comme un modèle, avec des espaces réservés pour les types qu'elle peut contenir ou utiliser. Par exemple, la classe System.Collections.Generic.Dictionary<TKey, TValue> peut contenir deux types : des clés et des valeurs. Dans la mesure où une définition de type générique est simplement un modèle, vous ne pouvez pas créer des instances d'une classe, d'une structure ou d'une interface qui représente une définition de type générique.
Les paramètres de type générique, ou paramètres de type, représentent les espaces réservés dans une définition de type ou de méthode générique. Le type générique System.Collections.Generic.Dictionary<TKey, TValue> possède deux paramètres de type, TKey et TValue, qui représentent les types de ses clés et de ses valeurs.
Un type générique construit, ou type construit, est le résultat de la spécification de types pour les paramètres de type générique d'une définition de type générique.
Un argument de type générique représente tout type substitué à un paramètre de type générique.
Le terme général type générique comprend à la fois les types construits et les définitions de type générique.
La Covariance et la contravariance de paramètres de type générique vous permettent d'utiliser des types génériques construits dont les arguments de type sont plus dérivés (covariance) ou moins dérivés (contravariance) qu'un type construit cible. La covariance et la contravariance sont désignées collectivement sous le nom de variation. Pour plus d'informations, consultez Covariance et contravariance dans les génériques.
Les contraintes sont des limites placées sur les paramètres de type générique. Par exemple, vous pouvez limiter un paramètre de type aux types qui implémentent l'interface générique System.Collections.Generic.IComparer<T>, pour garantir que les instances du type puissent être classées. Vous pouvez également limiter les paramètres de type à des types possédant une classe de base particulière, un constructeur par défaut ou représentant des types référence ou des types valeur. Les utilisateurs du type générique ne peuvent pas substituer les arguments de type qui ne respectent pas les contraintes.
Une définition de méthode générique est une méthode avec deux listes de paramètres : une liste des paramètres de type générique et une liste des paramètres formels. Les paramètres de type peuvent apparaître sous la forme du type de retour ou des types des paramètres formels, comme l'illustre le code suivant.

Function Generic(Of T)(ByVal arg As T) As T
    Dim temp As T = arg
    '...
    Return temp
End Function

T Generic<T>(T arg)
{
    T temp = arg;
    //...
    return temp;
}

generic<typename T>
T Generic(T arg)
{
    T temp = arg;
    //...
    return temp;
}

Les méthodes génériques peuvent apparaître sur des types génériques ou non génériques. Il est important de noter qu'une méthode n'est pas générique simplement en raison de son appartenance à un type générique, ou encore parce qu'elle a des paramètres formels dont les types sont les paramètres génériques du type englobant. Une méthode est générique uniquement si elle possède sa propre liste de paramètres de type. Dans le code suivant, seule la méthode G est générique.

Class A
    Function G(Of T)(ByVal arg As T) As T
        Dim temp As T = arg
        '...
        Return temp
    End Function
End Class
Class Generic(Of T)
    Function M(ByVal arg As T) As T
        Dim temp As T = arg
        '...
        Return temp
    End Function
End Class

class A
{
    T G<T>(T arg)
    {
        T temp = arg;
        //...
        return temp;
    }
}
class Generic<T>
{
    T M(T arg)
    {
        T temp = arg;
        //...
        return temp;
    }
}

ref class A
{
    generic<typename T>
    T G(T arg)
    {
        T temp = arg;
        //...
        return temp;
    }
};
generic<typename T>
ref class Generic
{
    T M(T arg)
    {
        T temp = arg;
        //...
        return temp;
    }
};

Retour au début

Prise en charge des bibliothèques de classes et des langages

Le .NET Framework fournit plusieurs classes de collections génériques dans les espaces de noms suivants :

L'espace de noms System.Collections.Generic catalogue la plupart des types de collections génériques fournis par le .NET Framework, tels que les classes génériques List<T> et Dictionary<TKey, TValue>.
L'espace de noms System.Collections.ObjectModel catalogue d'autres types de collections génériques, tels que la classe générique ReadOnlyCollection<T>, utiles pour exposer des modèles objet aux utilisateurs de vos classes.

Les interfaces génériques destinées à implémenter le tri et les comparaisons d'égalité sont fournies dans l'espace de noms System ainsi que des types délégués génériques pour les gestionnaires d'événements, les conversions et les prédicats de recherche.

La prise en charge des génériques a été ajoutée à l'espace de noms System.Reflection pour l'examen des types et des méthodes génériques, à System.Reflection.Emit pour l'émission d'assemblys dynamiques qui contiennent des types et des méthodes génériques, et à System.CodeDom pour la génération de graphiques de code source qui incluent des génériques.

Le Common Language Runtime fournit de nouveaux opcodes et préfixes pour prendre en charge les types génériques dans le code MSIL (Microsoft Intermediate Language), notamment Stelem, Ldelem, Unbox_Any, Constrained et Readonly.

Visual C++, C# et Visual Basic fournissent tous une prise en charge totale de la définition et de l'utilisation des génériques. Pour plus d'informations sur la prise en charge des langages, consultez Types génériques en Visual Basic (Visual Basic), Introduction aux génériques (guide de programmation C#)et Overview of Generics in Visual C++.

Retour au début

Types imbriqués et génériques

Un type imbriqué dans un type générique peut dépendre des paramètres de type du type générique englobant. Le Common Language Runtime considère les types imbriqués comme étant génériques, même s'ils ne possèdent pas leurs propres paramètres de type générique. Lorsque vous créez une instance d'un type imbriqué, vous devez spécifier des arguments de type pour tous les types génériques englobants.

Retour au début

Rubriques connexes

Titre	Description
Collections génériques dans le .NET Framework	Décrit des classes de collections génériques et d'autres types génériques dans le .NET Framework.
Délégués génériques pour la manipulation de tableaux et de listes	Décrit les délégués génériques pour les conversions, les prédicats de recherche et les actions à effectuer sur les éléments d'un tableau ou d'une collection.
Interfaces génériques	Décrit les interfaces génériques qui fournissent des fonctionnalités communes à toutes les familles de types génériques.
Covariance et contravariance dans les génériques	Décrit la covariance et la contravariance dans les paramètres de type générique.
Avantages et limitations des génériques	Résume les avantages et les restrictions liés à l'utilisation de génériques.
Types de collections couramment utilisés	Décrit brièvement les caractéristiques et les scénarios d'usage des types de collections dans le .NET Framework, notamment des types génériques.
Quand utiliser les collections génériques	Décrit les règles générales visant à déterminer quand il convient d'utiliser des types collection génériques.
Comment : définir un type générique avec l'émission de réflexion	Explique comment générer des assemblys dynamiques qui incluent des types et des méthodes génériques.
Types génériques en Visual Basic (Visual Basic)	Décrit la fonctionnalité des génériques pour les utilisateurs de Visual Basic et propose des rubriques "Comment" expliquant comment utiliser et définir des types génériques.
Introduction aux génériques (guide de programmation C#)	Propose une vue d'ensemble de la définition et de l'utilisation des types génériques pour les utilisateurs C#.
Overview of Generics in Visual C++	Décrit la fonctionnalité des génériques pour les utilisateurs C++, et notamment les différences entre génériques et modèles.

Retour au début

Référence

System.Collections.Generic

System.Collections.ObjectModel

System.Reflection.Emit.OpCodes

Retour au début

Partager via

Génériques dans le .NET Framework

Définition et utilisation de génériques

Terminologie des génériques

Prise en charge des bibliothèques de classes et des langages

Types imbriqués et génériques

Rubriques connexes

Référence

Ressources supplémentaires