Partager via

Méthodes génériques (guide de programmation C#)

Une méthode générique est une méthode déclarée avec des paramètres de type, comme suit :

static void Swap<T>(ref T lhs, ref T rhs)
{
    T temp;
    temp = lhs;
    lhs = rhs;
    rhs = temp;
}

L’exemple de code suivant montre un moyen d’appeler la méthode à l’aide int de l’argument de type :

public static void TestSwap()
{
    int a = 1;
    int b = 2;

    Swap<int>(ref a, ref b);
    System.Console.WriteLine(a + " " + b);
}

Vous pouvez également omettre l’argument de type et le compilateur l’déduit. L’appel suivant à Swap est équivalent à l’appel précédent.

Swap(ref a, ref b);

Les mêmes règles d’inférence de type s’appliquent aux méthodes statiques et aux méthodes d’instance. Le compilateur peut déduire les paramètres de type en fonction des arguments de méthode que vous transmettez ; il ne peut déduire les paramètres de type qu’à partir d’une contrainte ou d’une valeur de retour. Par conséquent, l’inférence de type ne fonctionne pas avec les méthodes qui n’ont aucun paramètre. L’inférence de type se produit au moment de la compilation avant que le compilateur tente de résoudre les signatures de méthode surchargées. Le compilateur applique la logique d’inférence de type à toutes les méthodes génériques qui partagent le même nom. À l’étape de résolution de surcharge, le compilateur inclut uniquement les méthodes génériques sur lesquelles l’inférence de type a réussi.

Dans une classe générique, les méthodes non génériques peuvent accéder aux paramètres de type au niveau de la classe, comme suit :

class SampleClass<T>
{
    void Swap(ref T lhs, ref T rhs) { }
}

Si vous définissez une méthode générique qui accepte les mêmes paramètres de type que la classe conteneur, le compilateur génère l’avertissement CS0693 , car dans l’étendue de la méthode, l’argument fourni pour l’intérieur T masque l’argument fourni pour l’extérieur T. Si vous avez besoin de la flexibilité nécessaire pour appeler une méthode de classe générique avec des arguments de type autres que ceux fournis lorsque la classe a été instanciée, envisagez de fournir un autre identificateur pour le paramètre de type de la méthode, comme illustré dans GenericList2<T> l’exemple suivant.

class GenericList<T>
{
    // CS0693.
    void SampleMethod<T>() { }
}

class GenericList2<T>
{
    // No warning.
    void SampleMethod<U>() { }
}

Utilisez des contraintes pour activer des opérations plus spécialisées sur les paramètres de type dans les méthodes. Cette version de Swap<T>, désormais nommée SwapIfGreater<T>, ne peut être utilisée qu'avec des arguments de type qui implémentent IComparable<T>.

void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : System.IComparable<T>
{
    T temp;
    if (lhs.CompareTo(rhs) > 0)
    {
        temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
}

Les méthodes génériques peuvent être surchargées sur plusieurs paramètres de type. Par exemple, les méthodes suivantes peuvent toutes se trouver dans la même classe :

void DoWork() { }
void DoWork<T>() { }
void DoWork<T, U>() { }

Vous pouvez également utiliser le paramètre de type comme type de retour d’une méthode. L’exemple de code suivant montre une méthode qui retourne un tableau de type T:

T[] Swap<T>(T a, T b)
{
    return [b, a];
}

Spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#.

Voir aussi