Comment la nullité des contraintes génériques affecte-t-elle la surcharge des méthodes C# ?

Contraintes et surcharges

En C#, des contraintes génériques peuvent être appliquées aux paramètres de type pour restreindre les types pouvant être utilisés. Cependant, lorsqu'une contrainte est placée sur un paramètre, cela affecte le processus de résolution de surcharge.

Considérez le code suivant :

static void Foo<T>(T a) where T : struct { } // 1

static void Foo<T>(T? a) where T : struct { } // 2

Ces deux fonctions surchargent Foo et se différencient en fonction de la nullité de T. Cependant, tenter d'ajouter une troisième surcharge avec une contrainte sur les types de classe échoue :

static void Foo<T>(T a) where T : class { } // 3

C'est parce que les paramètres de cette fonction correspondent les paramètres de Foo(T a) où T : struct. Pour contourner ce problème, nous devons placer la contrainte sur un paramètre différent :

class RequireStruct<T> where T : struct { }
class RequireClass<T> where T : class { }

static void Foo<T>(T a, RequireStruct<T> ignore = null) where T : struct { } // 1
static void Foo<T>(T? a) where T : struct { } // 2
static void Foo<T>(T a, RequireClass<T> ignore = null) where T : class { } // 3

Maintenant, Foo peut être surchargé pour gérer les trois cas :

• Types de valeurs simples (par ex. int) sont mappés à Foo(T a, RequireStruct ignore = null) où T : struct.
• Les types de valeurs nullables (par exemple int ?) sont mappés à Foo(T? a) où T : struct.
• Les types de référence (par exemple string) sont mappés à Foo< T>(T a, RequireClass ignore = null) où T : classe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!