Génériques dans le .NET Framework
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 |
|---|---|
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. |
Décrit les interfaces génériques qui fournissent des fonctionnalités communes à toutes les familles de types génériques. |
|
Décrit la covariance et la contravariance dans les paramètres de type générique. |
|
Résume les avantages et les restrictions liés à l'utilisation de génériques. |
|
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. |
|
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. |
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. |
|
Propose une vue d'ensemble de la définition et de l'utilisation des types génériques pour les utilisateurs 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.ObjectModel
System.Reflection.Emit.OpCodes
Retour au début