Comprobando si el objeto es de tipo genérico en C#

Question

Me gustaría realizar una prueba si un objeto es de un tipo genérico. He intentado lo siguiente sin éxito:

public bool Test() 
{ 
    List<int> list = new List<int>(); 
    return list.GetType() == typeof(List<>); 
} 

¿Qué estoy haciendo mal y cómo se realiza esta prueba?

Answer 1

Si desea comprobar si se trata de una instancia de un tipo genérico:

return list.GetType().IsGenericType; 

Si desea comprobar si se trata de un genérico List<T>:

return list.GetType().GetGenericTypeDefinition() == typeof(List<>); 

Como Jon señala, esto cheques la equivalencia de tipo exacto. Devolver false no significa necesariamente list is List<T> devuelve false (es decir, el objeto no se puede asignar a una variable List<T>).

Answer 2

return list.GetType().IsGenericType; 

Answer 3

que suponer que usted no sólo quiere saber si el tipo es genérico, pero si un objeto es una instancia de un tipo genérico en particular, sin conocer los argumentos de tipo.

No es terriblemente simple, desafortunadamente. No es tan malo si el tipo genérico es una clase (como lo es en este caso), pero es más difícil para las interfaces. Aquí está el código para una clase:

using System; 
using System.Collections.Generic; 
using System.Reflection; 

class Test 
{ 
    static bool IsInstanceOfGenericType(Type genericType, object instance) 
    { 
     Type type = instance.GetType(); 
     while (type != null) 
     { 
      if (type.IsGenericType && 
       type.GetGenericTypeDefinition() == genericType) 
      { 
       return true; 
      } 
      type = type.BaseType; 
     } 
     return false; 
    } 

    static void Main(string[] args) 
    { 
     // True 
     Console.WriteLine(IsInstanceOfGenericType(typeof(List<>), 
                new List<string>())); 
     // False 
     Console.WriteLine(IsInstanceOfGenericType(typeof(List<>), 
                new string[0])); 
     // True 
     Console.WriteLine(IsInstanceOfGenericType(typeof(List<>), 
                new SubList())); 
     // True 
     Console.WriteLine(IsInstanceOfGenericType(typeof(List<>), 
                new SubList<int>())); 
    } 

    class SubList : List<string> 
    { 
    } 

    class SubList<T> : List<T> 
    { 
    } 
} 

EDIT: Como se señaló en los comentarios, esto puede funcionar para interfaces:

foreach (var i in type.GetInterfaces()) 
{ 
    if (i.IsGenericType && i.GetGenericTypeDefinition() == genericType) 
    { 
     return true; 
    } 
} 

Tengo la sospecha de que puede haber algunos casos extremos difíciles de todo esto, pero No puedo encontrar uno por el que falla por ahora.

Answer 4

Puede utilizar el código más corto usando althougth dinámico que esto puede ser más lenta que la pura reflexión:

public static class Extension 
{ 
    public static bool IsGenericList(this object o) 
    { 
     return IsGeneric((dynamic)o); 
    } 

    public static bool IsGeneric<T>(List<T> o) 
    { 
     return true; 
    } 

    public static bool IsGeneric(object o) 
    { 
     return false; 
    } 
} 



var l = new List<int>(); 
l.IsGenericList().Should().BeTrue(); 

var o = new object(); 
o.IsGenericList().Should().BeFalse(); 

Answer 5

Estos son mis dos métodos favoritos de extensión que cubren la mayoría de los casos extremos de comprobación de tipos genéricos:

Funciona con :

• múltiples (genéricos) interfaces de
clases
• múltiple (genérico) de base

• tiene una sobrecarga que será del tipo genérico de concreto 'hacia fuera' si devuelve verdadero (ver prueba de unidad para las muestras):

  public static bool IsOfGenericType(this Type typeToCheck, Type genericType) 
  { 
      Type concreteType; 
      return typeToCheck.IsOfGenericType(genericType, out concreteType); 
  } 
  
  public static bool IsOfGenericType(this Type typeToCheck, Type genericType, out Type concreteGenericType) 
  { 
      while (true) 
      { 
       concreteGenericType = null; 
  
       if (genericType == null) 
        throw new ArgumentNullException(nameof(genericType)); 
  
       if (!genericType.IsGenericTypeDefinition) 
        throw new ArgumentException("The definition needs to be a GenericTypeDefinition", nameof(genericType)); 
  
       if (typeToCheck == null || typeToCheck == typeof(object)) 
        return false; 
  
       if (typeToCheck == genericType) 
       { 
        concreteGenericType = typeToCheck; 
        return true; 
       } 
  
       if ((typeToCheck.IsGenericType ? typeToCheck.GetGenericTypeDefinition() : typeToCheck) == genericType) 
       { 
        concreteGenericType = typeToCheck; 
        return true; 
       } 
  
       if (genericType.IsInterface) 
        foreach (var i in typeToCheck.GetInterfaces()) 
         if (i.IsOfGenericType(genericType, out concreteGenericType)) 
          return true; 
  
       typeToCheck = typeToCheck.BaseType; 
      } 
  } 
  

Aquí está una prueba para demostrar la funcionalidad (básico):

[Test] 
    public void SimpleGenericInterfaces() 
    { 
     Assert.IsTrue(typeof(Table<string>).IsOfGenericType(typeof(IEnumerable<>))); 
     Assert.IsTrue(typeof(Table<string>).IsOfGenericType(typeof(IQueryable<>))); 

     Type concreteType; 
     Assert.IsTrue(typeof(Table<string>).IsOfGenericType(typeof(IEnumerable<>), out concreteType)); 
     Assert.AreEqual(typeof(IEnumerable<string>), concreteType); 

     Assert.IsTrue(typeof(Table<string>).IsOfGenericType(typeof(IQueryable<>), out concreteType)); 
     Assert.AreEqual(typeof(IQueryable<string>), concreteType); 


    }