Programmation C sharp/Types génériques

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
Programmation C#
Programmation C#
Sommaire
Le langage
Programmation avancée
API .Net
Ressources
Modifier ce modèle

Un type générique est en fait un type non spécifié à l'implémentation d'une méthode ou d'une classe. Le type sera déterminé lors de l'utilisation de cette méthode ou classe. En fait, pour chaque type différent utilisé, le compilateur génèrera une nouvelle version de la méthode ou de la classe.

Les types génériques sont utilisés pour effectuer un même traitement sur différents types de données.

Syntaxe[modifier | modifier le wikicode]

Les types génériques sont identifiés par un nom, et spécifiés entre les signes < et > placés juste après le nom de la méthode ou la classe.

Exemple de méthode[modifier | modifier le wikicode]

Soit une méthode statique retournant la valeur maximale entre deux valeurs passées en paramètre :

public static T max<T>(T a, T b) // Retourne la valeur maximale
{
    return a > b ? a : b ;
}
 
int entier = max ( 10 , 22 );
double vmax = max ( 3.14 , 1.618 );

Le compilateur détermine le type utilisé pour T d'après les valeurs des arguments. Dans le cas précédent, il génère deux versions surchargées de la méthode statique :

  • public static int max(int a, int b)
  • public static double max(double a, double b)

Exemple de classe[modifier | modifier le wikicode]

La syntaxe est similaire. Soit une classe gérant une structure en arbre de valeurs de type quelconque :

public class Arbre<T>
{
    public T valeur;
    private Arbre<T> _gauche, _droite;

    public Arbre<T> ArbreGauche
    {
        get { return _gauche; }
    }
}

L'utilisation de cette classe exige de spécifier explicitement le type utilisé :

Arbre<int> ArbreDesEntiers = new Arbre<int>();
ArbreDesEntiers.valeur = 100;

Exemple de structure[modifier | modifier le wikicode]

Les types génériques sont également utilisables avec les structures :

public struct Taille<T>
{
    public T largeur, hauteur;
}

Plusieurs types génériques[modifier | modifier le wikicode]

Il est possible d'utiliser plusieurs types génériques pour une méthode ou une classe :

public static void affiche<T,U>(T a, U b) // Affiche a et b
{
    Console.WriteLine("A vaut {0}, et B vaut {1}", a, b);
}
 
affiche(10,3.1415926);

Contraintes sur les types génériques[modifier | modifier le wikicode]

Il est possible de restreindre les types utilisables à ceux qui implémentent une ou plusieurs interfaces.

Syntaxe[modifier | modifier le wikicode]

Pour chaque type à contraindre, il faut ajouter une clause where :

where type : liste_des_interfaces

Exemple :

public class TableauTriable<T>
    where T : IComparable
{
    //...
}

Il est possible d'utiliser class ou struct pour limiter le type à une classe ou une structure.

Exemple :

public class TableauTriable<T>
    where T : struct
{
    //...
}

Il est également possible d'ajouter des contraintes sur les constructeurs du type générique :

public class TableauTriable<T>
    where T : new()   // T doit avoir un constructeur sans paramètre
{
    public T Creer()
    {
        return new T(); // appel au constructeur de T
    }
}

Opérateur default[modifier | modifier le wikicode]

L'opérateur default retourne la valeur par défaut du type générique spécifié. Il s'agit de la valeur quand une variable de ce type n'est pas initialisée (0 pour les nombres, null pour les types références).

Exemple:

public T maxAbsolu(T a,T b)
{
    if (a==b) return default(T);
    else return a>b ? a : b;
}

Alias[modifier | modifier le wikicode]

Il est possible de définir un alias d'une classe générique spécifique, en utilisant le mot clé using :

using Entiers = TableauTriable<int>;
Entiers entiers = new Entiers();

Équivaut à :

TableauTriable<int> entiers = new TableauTriable<int>();