Vérifier si ‘T’ hérite ou implémente une classe / interface

Est-il possible de tester si T hérite / implémente une classe / interface?

private void MyGenericClass () { if(T ... inherits or implements some class/interface } 

Il existe une méthode appelée Type.IsAssignableFrom () .

Pour vérifier si T hérite / implémente Employee :

 typeof(Employee).IsAssignableFrom(typeof(T)); 

Si vous ciblez .NET Core, la méthode a été déplacée vers TypeInfo:

 typeof(Employee).GetTypeInfo().IsAssignableFrom(typeof(T).Ge‌​tTypeInfo()) 

Vous pouvez utiliser des contraintes sur la classe.

 MyClass where T : Employee 

Jetez un oeil à http://msdn.microsoft.com/en-us/library/d5x73970.aspx

Les réponses fournies sont en fait le moyen de vérifier si T implémente une certaine classe / interface, cependant si vous effectuez la vérification afin d’empêcher les appels à la méthode si T n’installe PAS l’interface / la classe souhaitée, vous pouvez utiliser les éléments suivants. contrainte

 public void MyRessortingctedMethod() where T : MyInterface1, MyInterface2, MySuperClass { //Code of my method here, clean without any check for type constraints. } 

J’espère que ça aide.

La syntaxe correcte est

 typeof(Employee).IsAssignableFrom(typeof(T)) 

Documentation

Valeur de retour: true si c et le Type actuel représentent le même type ou si le Type actuel est dans la hiérarchie d’inheritance de c , ou si le Type actuel est une interface implémentée par c , ou si c est un paramètre de type générique et current Type représente l’une des contraintes de c , ou si c représente un type de valeur et que le Type actuel représente Nullable ( Nullable(Of c) dans Visual Basic). false si aucune de ces conditions n’est true ou si c est null .

la source

Explication

Si Employee IsAssignableFrom T T hérite de Employee .

L’usage

 typeof(T).IsAssignableFrom(typeof(Employee)) 

retourne true seulement quand soit

  1. T et l’ Employee représentent le même type; ou,
  2. Employee hérite de T

Cela peut être l’usage prévu dans certains cas, mais pour la question d’origine (et l’utilisation la plus courante), pour déterminer quand T hérite ou implémente une class / une interface , utilisez:

 typeof(Employee).IsAssignableFrom(typeof(T)) 

Ce que tout le monde veut vraiment dire c’est:

 typeof(BaseType).IsAssignableFrom(typeof(DerivedType)) // => true 

car vous pouvez littéralement affecter d’ une instance d’un DerivedType à une instance d’un BaseType :

 DerivedType childInstance = new DerivedType(); BaseType parentInstance = childInstance; // okay, assigning base from derived childInstance = (DerivedType) parentInstance; // not okay, assigning derived from base 

quand

 public class BaseType {} public class DerivedType : BaseType {} 

Et quelques exemples concrets si vous avez du mal à vous en passer:

(via LinqPad, d’où le HorizontalRun et le Dump )

 void Main() { // http://stackoverflow.com/questions/10718364/check-if-t-inherits-or-implements-a-class-interface var b1 = new BaseClass1(); var c1 = new ChildClass1(); var c2 = new ChildClass2(); var nb = new nobase(); Util.HorizontalRun( "baseclass->baseclass,child1->baseclass,baseclass->child1,child2->baseclass,baseclass->child2,nobase->baseclass,baseclass->nobase", b1.IsAssignableFrom(typeof(BaseClass1)), c1.IsAssignableFrom(typeof(BaseClass1)), b1.IsAssignableFrom(typeof(ChildClass1)), c2.IsAssignableFrom(typeof(BaseClass1)), b1.IsAssignableFrom(typeof(ChildClass2)), nb.IsAssignableFrom(typeof(BaseClass1)), b1.IsAssignableFrom(typeof(nobase)) ).Dump("Results"); var results = new List(); ssortingng test; test = "c1 = b1"; try { c1 = (ChildClass1) b1; results.Add(test); } catch { results.Add("FAIL: " + test); } test = "b1 = c1"; try { b1 = c1; results.Add(test); } catch { results.Add("FAIL: " + test); } test = "c2 = b1"; try { c2 = (ChildClass2) b1; results.Add(test); } catch { results.Add("FAIL: " + test); } test = "b1 = c2"; try { b1 = c2; results.Add(test); } catch { results.Add("FAIL: " + test); } results.Dump(); } // Define other methods and classes here public static class exts { public static bool IsAssignableFrom(this T entity, Type baseType) { return typeof(T).IsAssignableFrom(baseType); } } class BaseClass1 { public int id; } class ChildClass1 : BaseClass1 { public ssortingng name; } class ChildClass2 : ChildClass1 { public ssortingng descr; } class nobase { public int id; public ssortingng name; public ssortingng descr; } 

Résultats

baseclass-> baseclass

Vrai

child1-> baseclass

Faux

classe de base-> enfant1

Vrai

child2-> baseclass

Faux

classe de base-> enfant2

Vrai

nobase-> baseclass

Faux

baseclass-> nobase

Faux

et

  • FAIL: c1 = b1
  • b1 = c1
  • FAIL: c2 = b1
  • b1 = c2

Je pense que la syntaxe est la suivante: typeof(Employee).IsAssignableFrom(typeof(T));

Bien que IsAssignableFrom soit le meilleur moyen, comme d’autres l’ont indiqué, si vous devez uniquement vérifier si une classe hérite d’une autre, typeof(T).BaseType == typeof(SomeClass) effectue également le travail.