contrainte générique NOT où T:! IEnumerable

Selon le titre, est-il possible de déclarer des contraintes de négation de type dans c # 4?

Non, il n’y a pas de tel concept en C # ou dans le CLR.

Pour autant que je sache, ce n’est pas possible.

Qu’est-ce que vous pouvez faire est une vérification de l’exécution:

 public bool MyGenericMethod() { // if (T is IEnumerable) // don't do this if (typeof(T).GetInterface("IEnumerable") == null) return false; // ... return true; } 

J’ai trouvé que je tentais de mettre en œuvre le même cas mentionné dans les commentaires:

 void doIt(IEnumerable what) { } void doIt(T whats) { } 

J’ai excepté le code suivant pour référencer la première méthode :

 doIt(new List()); 

Mais il fait référence au second .

Une solution consiste à lancer l’argument comme ceci:

 doIt(new List().AsEnumerable()); 

Le casting pourrait être caché par une autre surcharge:

 void doIt(List whats) { doIt(whats.AsEnumerable()); } 

Non, mais il serait possible de vérifier avec un “is” et de le gérer correctement …

Vous utilisez une contrainte pour vous assurer que le type que vous utilisez a des propriétés / méthodes / … que vous souhaitez utiliser .

Un générique avec une contrainte de négation de type n’a aucun sens, car il est inutile de connaître l’absence de certaines propriétés / méthodes que vous ne souhaitez pas utiliser .

une utilisation pour cela serait un type d’option.

 public class Option where A : !B where B : !A { private readonly A a; private readonly B b; private Option(){} public Option(A a) { this.a = a } public Option(B b) { this.b = b } } 

La vérification à l’exécution fonctionnerait bien sûr, mais vous ne bénéficieriez pas de la vérification de type au moment de la compilation.