Avantages et limitations des génériques
Mise à jour : novembre 2007
La fonctionnalité des génériques vous permet de spécifier les types sur lesquels agit une méthode ou une classe générique. Dès lors, ce n'est plus à vous mais au compilateur qu'il incombe de vérifier la sécurité de type. Il est inutile d'écrire du code pour tester le type de données correct dans la mesure où la sécurité de type est appliquée au moment de la compilation. Le besoin de casting de type et la possibilité d'erreurs d'exécution s'en trouvent réduits.
Les génériques fournissent la sécurité de type sans la charge liée à l'existence de plusieurs implémentations. Vous pouvez, par exemple, créer une liste liée de chaînes avec la déclaration de variable suivante :
Dim llist As New LinkedList(Of String)
LinkedList<string> llist = new LinkedList<string>();
LinkedList<String^>^ llist = gcnew LinkedList<String^>();
Il n'est pas nécessaire d'hériter d'un type de base et de substituer des membres. La liste liée est prête à être immédiatement utilisée. Pour connaître les types collection génériques fournis par le .NET Framework, consultez System.Collections.Generic et System.Collections.ObjectModel.
Outre la sécurité de type, les types collections génériques affichent généralement de meilleures performances pour le stockage et la manipulation des types valeur car il est inutile d'exécuter une conversion boxing des types valeur.
Les délégués génériques permettent les rappels de type sécurisé sans avoir à créer plusieurs classes de délégués. Par exemple, le délégué générique Predicate<T> vous permet de créer une méthode qui implémente vos propres critères de recherche d'un type particulier et d'utiliser cette méthode avec les méthodes du type Array telles que Find<T>, FindLast<T> et FindAll<T>.
Les délégués génériques peuvent également être utilisés dans du code généré dynamiquement sans nécessiter la génération d'un type délégué. Vous multipliez ainsi les scénarios où il est possible d'utiliser des méthodes dynamiques allégées au lieu de générer des assemblys entiers. Pour plus d'informations, consultez Comment : définir et exécuter des méthodes dynamiques et DynamicMethod.
Dans la plupart des cas, les compilateurs Visual Basic, Visual C++ et C# sont capables de déterminer à partir du contexte les types utilisés par un appel de méthode générique, ce qui simplifie considérablement la syntaxe nécessaire à l'utilisation des méthodes génériques. Par exemple, le code suivant illustre les formes longue et courte d'un appel à la méthode générique BinarySearch pour exécuter une recherche dans un tableau de chaînes. Sous sa forme courte, les compilateurs déduisent le paramètre de type correct à partir des types des arguments de la méthode.
Dim index As Integer = Array.BinarySearch(myArray, "test string")
Dim index As Integer = _
Array.BinarySearch(Of String)(myArray, "test string")
int index = Array.BinarySearch(myArray, "test string");
int index = Array.BinarySearch<string>(myArray, "test string");
int index = Array::BinarySearch(myArray, "test string");
int index = Array::BinarySearch<String^>(myArray, "test string");
Limitations des génériques
Voici quelques limitations des génériques dans .NET Framework version 2.0 :
Les types génériques peuvent être dérivés de la plupart des classes de base, telles que MarshalByRefObject (et des contraintes peuvent être utilisées pour que les paramètres de type générique dérivent obligatoirement de classes de base, comme MarshalByRefObject), mais dans cette version du .NET Framework, les types génériques liés au contexte ne sont pas pris en charge. Un type générique peut être dérivé de ContextBoundObject, mais toute tentative de création d'une instance de ce type déclenche TypeLoadException.
Les énumérations ne peuvent pas avoir de paramètres de type générique. Une énumération ne peut être générique qu'incidemment, par exemple parce qu'elle est imbriquée dans un type générique défini à l'aide de Visual Basic, C# ou C++. Pour plus d'informations, consultez Énumérations dans le système de type commun.
Les méthodes dynamiques légères ne peuvent pas être génériques. Pour plus d'informations sur les méthodes dynamiques, consultez Scénarios de méthodes dynamiques avec émission de réflexion.
En Visual Basic, C# et C++, un type imbriqué inclus dans un type générique ne peut pas être instancié sans que les types aient été assignés aux paramètres de type de tous les types englobants. En d'autres termes, un type imbriqué défini à l'aide de ces langages inclut les paramètres de type de tous ses types englobants. Cela permet d'utiliser les paramètres de type des types englobants dans les définitions de membre d'un type imbriqué. Pour plus d'informations, consultez « Types imbriqués » dans MakeGenericType.
.gif "Remarque")
Remarque :Un type imbriqué qui est défini en émettant un code dans un assembly dynamique ou en utilisant Assembleur MSIL (Ilasm.exe) n'est pas requis pour inclure les paramètres de type de ses types englobants ; toutefois, s'il ne les inclut pas, les paramètres de type ne sont pas dans la portée de la classe imbriquée.
Pour plus d'informations, consultez « Types imbriqués » dans MakeGenericType.
Voir aussi
Concepts
Vue d'ensemble des génériques dans le .NET Framework
Collections génériques dans le .NET Framework
Délégués génériques pour la manipulation de tableaux et de listes
Référence
System.Collections.ObjectModel