Comment déterminer si un type implémente un type d'interface générique spécifique

Question

On suppose les définitions de type:

public interface IFoo<T> : IBar<T> {} 
public class Foo<T> : IFoo<T> {} 

Comment puis-je savoir si le type Foo implémente l'interface générique IBar<T> lorsque seul le type déchiqueté est disponible?

Answer 1

En utilisant le réponse de TcKs il peut également être fait avec la requête LINQ suivante:

bool isBar = foo.GetType().GetInterfaces().Any(x => 
    x.IsGenericType && 
    x.GetGenericTypeDefinition() == typeof(IBar<>)); 

Answer 2

Vous devez vérifier par rapport à un type construit de l'interface générique.

Vous devrez faire quelque chose comme ceci:

foo is IBar<String> 

parce IBar<String> représente ce type construit. La raison pour laquelle vous devez faire ceci est parce que si T est indéfini dans votre vérification, le compilateur ne sait pas si vous voulez dire IBar<Int32> ou IBar<SomethingElse>.

Answer 3

Vous devez monter dans l'arbre d'héritage et de trouver toutes les interfaces pour chaque classe dans l'arbre, et comparer typeof(IBar<>) avec le résultat de l'appel Type.GetGenericTypeDefinitionsi l'interface est générique. C'est un peu douloureux, certainement.

Voir this answer et these ones pour plus d'informations et de code.

Answer 4

public interface IFoo<T> : IBar<T> {} 
public class Foo : IFoo<Foo> {} 

var implementedInterfaces = typeof(Foo).GetInterfaces(); 
foreach(var interfaceType in implementedInterfaces) { 
    if (false == interfaceType.IsGeneric) { continue; } 
    var genericType = interfaceType.GetGenericTypeDefinition(); 
    if (genericType == typeof(IFoo<>)) { 
     // do something ! 
     break; 
    } 
} 

Answer 5

d'abord public class Foo : IFoo<T> {} ne compile pas parce que vous devez spécifier une classe au lieu de T, mais en supposant que vous faites quelque chose comme public class Foo : IFoo<SomeClass> {}

alors si vous faites

Foo f = new Foo(); 
IBar<SomeClass> b = f as IBar<SomeClass>; 

if(b != null) //derives from IBar<> 
    Blabla(); 

Answer 6

En tant que méthode d'aide l'extension

public static bool Implements<I>(this Type type, I @interface) where I : class 
{ 
    if(((@interface as Type)==null) || !(@interface as Type).IsInterface) 
     throw new ArgumentException("Only interfaces can be 'implemented'."); 

    return (@interface as Type).IsAssignableFrom(type); 
} 

Exemple d'utilisation:

var testObject = new Dictionary<int, object>(); 
result = testObject.GetType().Implements(typeof(IDictionary<int, object>)); // true! 

Answer 7

J'utilise une version légèrement plus simple de @GenericProgrammers méthode d'extension:

public static bool Implements<TInterface>(this Type type) where TInterface : class { 
    var interfaceType = typeof(TInterface); 

    if (!interfaceType.IsInterface) 
     throw new InvalidOperationException("Only interfaces can be implemented."); 

    return (interfaceType.IsAssignableFrom(type)); 
} 

Utilisation:

if (!featureType.Implements<IFeature>()) 
     throw new InvalidCastException(); 

Answer 8

Il ne devrait pas être quelque chose de mal ce qui suit:

Pour le crédit supplémentaire que vous pourriez attraper AmbiguousMatchException si vous vouliez fournir un type paramètre générique spécifique avec votre requête IBar.

Answer 9

Pour attaquer complètement le système de types, je pense que vous devez gérer la récursivité, par ex. IList<T>: ICollection<T>: IEnumerable<T>, sans lequel vous ne sauriez pas que IList<int> implémente finalement IEnumerable<>.

/// <summary>Determines whether a type, like IList&lt;int&gt;, implements an open generic interface, like 
    /// IEnumerable&lt;&gt;. Note that this only checks against *interfaces*.</summary> 
    /// <param name="candidateType">The type to check.</param> 
    /// <param name="openGenericInterfaceType">The open generic type which it may impelement</param> 
    /// <returns>Whether the candidate type implements the open interface.</returns> 
    public static bool ImplementsOpenGenericInterface(this Type candidateType, Type openGenericInterfaceType) 
    { 
     Contract.Requires(candidateType != null); 
     Contract.Requires(openGenericInterfaceType != null); 

     return 
      candidateType.Equals(openGenericInterfaceType) || 
      (candidateType.IsGenericType && candidateType.GetGenericTypeDefinition().Equals(openGenericInterfaceType)) || 
      candidateType.GetInterfaces().Any(i => i.IsGenericType && i.ImplementsOpenGenericInterface(openGenericInterfaceType)); 

    } 

Answer 10

Si vous voulez une méthode d'extension qui soutiendrait les types de base génériques, ainsi que des interfaces, j'ai développé la réponse de sduplooy:

public static bool InheritsFrom(this Type t1, Type t2) 
    { 
     if (null == t1 || null == t2) 
      return false; 

     if (null != t1.BaseType && 
      t1.BaseType.IsGenericType && 
      t1.BaseType.GetGenericTypeDefinition() == t2) 
     { 
      return true; 
     } 

     if (InheritsFrom(t1.BaseType, t2)) 
      return true; 

     return 
      (t2.IsAssignableFrom(t1) && t1 != t2) 
      || 
      t1.GetInterfaces().Any(x => 
       x.IsGenericType && 
       x.GetGenericTypeDefinition() == t2); 
    } 

Answer 11

Méthode pour vérifier si le type hérite ou implémente un générique tapez:

public static bool IsTheGenericType(this Type candidateType, Type genericType) 
    { 
     return 
      candidateType != null && genericType != null && 
      (candidateType.IsGenericType && candidateType.GetGenericTypeDefinition() == genericType || 
      candidateType.GetInterfaces().Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == genericType) || 
      candidateType.BaseType != null && candidateType.BaseType.IsTheGenericType(genericType)); 
    }