cómo determinar si un tipo implementa un tipo específico interfaz genérica

Question

asumir las siguientes definiciones de tipos:

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

¿Cómo puedo saber si el tipo Foo implementa la interfaz genérica IBar<T> cuando sólo el tipo mutilado está disponible?

Answer 1

Mediante el uso de la responder desde TCKs también se puede hacer con la siguiente consulta LINQ:

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

Answer 2

Tiene que verificar contra un tipo construido de la interfaz genérica.

Usted tendrá que hacer algo como esto:

foo is IBar<String> 

porque IBar<String> representa ese tipo construido. La razón por la que tiene que hacer esto es porque si T no está definido en su cheque, el compilador no sabe si se refiere a IBar<Int32> o IBar<SomethingElse>.

Answer 3

usted tiene que ir a través del árbol de herencia y encontrar todas las interfaces para cada clase en el árbol, y compara typeof(IBar<>) con el resultado de llamar Type.GetGenericTypeDefinition si la interfaz es genérico. Todo es un poco doloroso, sin duda.

Consulte this answer y these ones para obtener más información y código.

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

En primer lugar public class Foo : IFoo<T> {} no se compila porque es necesario especificar una clase en lugar de T, pero suponiendo que hacer algo como public class Foo : IFoo<SomeClass> {}

continuación, si lo hace

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

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

Answer 6

Como una extensión método de ayuda

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); 
} 

Ejemplo de uso:

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

Answer 7

estoy usando una versión ligeramente más simple del método de extensión @GenericProgrammers:

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)); 
} 

Uso:

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

Answer 8

No debe haber nada malo lo siguiente:

Para crédito adicional se puede coger AmbiguousMatchException si desea proporcionar un tipo de parámetro genérico específico con su consulta IBar.

Answer 9

Para abordar completamente el sistema de tipos, creo que debe manejar la recursividad, p. IList<T>: ICollection<T>: IEnumerable<T>, sin el cual no sabría que IList<int> finalmente implementa IEnumerable<>.respuesta

/// <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

En caso de que quería un método de extensión que apoyaría tipos base genéricos, así como interfaces, he ampliado 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étodo para comprobar si el tipo hereda o implementa un genérico tipo:

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)); 
    }