¿Cómo puedo saber si un Type implementa IList <>?

Question

Quiero escribir un método que use Reflection para indicar si un Type dado implementa IList<T>. Por ejemplo:

IsGenericList(typeof(int))      // should return false 
IsGenericList(typeof(ArrayList))     // should return false 
IsGenericList(typeof(IList<int>))    // should return true 
IsGenericList(typeof(List<int>))     // should return true 
IsGenericList(typeof(ObservableCollection<int>)) // should return true 

En mi uso, que se puede suponer que el tipo siempre será una instancia de tipo genérico (o algo que no es genérica en absoluto).

Desafortunadamente, esto no es tan fácil como debería ser. La solución obvia:

public bool IsGenericList(Type type) 
{ 
    return typeof(IList<>).IsAssignableFrom(type); 
} 

no funciona; siempre devuelve falso. Aparentemente, los tipos genéricos no instanciados como IList<> no implementan IsAssignableFrom la forma en que yo esperaba: IList<> no se puede asignar desde List<T>.

También he intentado esto:

public bool IsGenericList(Type type) 
{ 
    if (!type.IsGenericType) 
     return false; 
    var genericTypeDefinition = type.GetGenericTypeDefinition(); 
    return typeof(List<>).IsAssignableFrom(genericTypeDefinition); 
} 

es decir, girar type en su no una instancia genérica, como IList<int> ->IList<>, y luego tratar IsAssignableFrom nuevo. Que devolverá verdadero si el tipo es una instancia IList<T> como IList<int>, IList<object>, etc, pero que devuelve false para clases que implementan IList<T> como List<int>, ObservableCollection<double>, etc., por lo que aparentemente IList<> no es asignable a partir List<>. Nuevamente, no es lo que esperaría.

¿Cómo hago para escribir IsGenericList y hacer que funcione como en los ejemplos anteriores?

Answer 1

De hecho, no puede tener una instancia de una definición de tipo genérico. Por lo tanto, el método IsAssignableFrom() funciona como se esperaba. Para lograr lo que quiere, haga lo siguiente:

public bool IsGenericList(Type type) 
{ 
    if (type == null) { 
     throw new ArgumentNullException("type"); 
    } 
    foreach (Type @interface in type.GetInterfaces()) { 
     if (@interface.IsGenericType) { 
      if (@interface.GetGenericTypeDefinition() == typeof(ICollection<>)) { 
       // if needed, you can also return the type used as generic argument 
       return true; 
      } 
     } 
    } 
    return false; 
} 

Sólo por curiosidad, ¿para qué necesita esto?

Answer 2

Utilice la "is" operador:

El es el operador se utiliza para comprobar si el tipo de tiempo de ejecución de un objeto es compatible con un tipo dado.

Answer 3

Lucero/Reed Copsey ambos tienen la solución correcta ahora. Sólo para que sea más concisa, aquí está en forma LINQified:

var isGenericList = type.GetInterfaces().Any(t => t.IsGenericType && 
    t.GetGenericTypeDefinition() == typeof(IList<>)); 

Answer 4

Esto pasa sus pruebas ...

public static bool IsGenericList(Type type) 
{ 
    return type.Name == "IList`1" || type.GetInterface("IList`1") != null; 
} 

Answer 5

Ha intentado llamar Type.GetInterface()? No está del todo claro con la ayuda, pero creo que buscará interfaces implementadas por tipos básicos, además del tipo en sí. De lo contrario, siempre puede recorrer el Type.BaseType y llamar al GetInterface() nuevamente.

Answer 6

El uso de este: http://msdn.microsoft.com/en-us/library/system.type.findinterfaces.aspx

yo probamos este:

public class Test : IList<string> 
{ 
//implementation left out... 
} 

class Program 
    { 
     static void Main(string[] args) 
     { 
      Test t = new Test(); 
      TypeFilter myFilter = new TypeFilter(MyInterfaceFilter); 

      Type type = t.GetType(); 
      Type[] x = type.FindInterfaces(myFilter, "System.Collections.Generic.IList"); 
      Console.WriteLine(x.Length); 

     } 

     public static bool MyInterfaceFilter(Type typeObj, Object criteriaObj) 
     { 
      if (typeObj.ToString().Contains(criteriaObj.ToString())) 
       return true; 
      else 
       return false; 
     } 
    } 

Answer 7

yo también quieren probar si un tipo implementa IList<T> por alguna T. hice el cambio obvio a Lucero's answer pero causó una subtle bug no presente en la respuesta original. Aquí está mi edición final:

/// <summary> 
    /// Test if a type derives from IList of T, for any T. 
    /// </summary> 
    public bool TestIfGenericList(Type type) 
    { 
     if (type == null) 
     { 
      throw new ArgumentNullException("type"); 
     } 

     var interfaceTest = new Predicate<Type>(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IList<>)); 

     return interfaceTest(type) || type.GetInterfaces().Any(i => interfaceTest(i)); 
    }