Testando se o objeto é do tipo genérico em C #

Eu gostaria de realizar um teste se um objeto é de um tipo genérico. Eu tentei o seguinte sem sucesso:

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

O que estou fazendo de errado e como faço esse teste?

Se você deseja verificar se é uma instância de um tipo genérico:

return list.GetType().IsGenericType;

Se você deseja verificar se é genérico List<T>:

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

Como Jon aponta, isso verifica a equivalência exata do tipo. Retornar falsenão significa necessariamente list is List<T>retornos false(ou seja, o objeto não pode ser atribuído a uma List<T>variável).

Suponho que você não queira apenas saber se o tipo é genérico, mas se um objeto é uma instância de um tipo genérico específico, sem conhecer os argumentos de tipo.

Infelizmente, não é muito simples. Não é tão ruim se o tipo genérico for uma classe (como é neste caso), mas é mais difícil para interfaces. Aqui está o código para uma classe:

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 observado nos comentários, isso pode funcionar para interfaces:

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

Eu tenho uma suspeita furtiva de que possa haver alguns casos estranhos em torno disso, mas não consigo encontrar um no qual ele falhe agora.

Você pode usar um código mais curto usando a dinâmica, mas isso pode ser mais lento que o reflexo puro:

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

Estes são meus dois métodos de extensão favoritos que abrangem a maioria dos casos extremos de verificação de tipo genérico:

Funciona com:

• Múltiplas interfaces (genéricas)
• Várias classes base (genéricas)

• Tem uma sobrecarga que 'expulsa' o tipo genérico específico se retornar verdadeiro (consulte o teste de unidade para obter amostras):

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

Aqui está um teste para demonstrar a funcionalidade (básica):

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


    }

return list.GetType().IsGenericType;