Kiểm tra nếu đối tượng thuộc loại chung trong C #

Tôi muốn thực hiện một thử nghiệm nếu một đối tượng thuộc loại chung chung. Tôi đã thử những cách sau mà không thành công:

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

Tôi đang làm gì sai và làm thế nào để tôi thực hiện bài kiểm tra này?

Nếu bạn muốn kiểm tra xem đó có phải là một thể loại chung không:

return list.GetType().IsGenericType;

Nếu bạn muốn kiểm tra nếu đó là chung chung List<T>:

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

Như Jon chỉ ra, điều này kiểm tra sự tương đương loại chính xác. Trả về falsekhông nhất thiết có nghĩa là list is List<T>trả về false(tức là đối tượng không thể được gán cho một List<T>biến).

Tôi giả sử rằng bạn không chỉ muốn biết loại đó là chung chung, nhưng nếu một đối tượng là một thể hiện của một loại chung cụ thể, mà không biết các đối số loại.

Thật không đơn giản, thật không may. Nó không quá tệ nếu loại chung là một lớp (như trong trường hợp này) nhưng khó hơn cho các giao diện. Đây là mã cho một lớp:

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: Như đã lưu ý trong các bình luận, điều này có thể hoạt động cho các giao diện:

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

Tôi có một nghi ngờ lén lút có thể có một số trường hợp khó xử xung quanh vấn đề này, nhưng tôi không thể tìm thấy nó thất bại ngay bây giờ.

Bạn có thể sử dụng mã ngắn hơn bằng cách sử dụng althougth, điều này có thể chậm hơn so với phản xạ thuần túy:

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

Đây là hai phương thức mở rộng yêu thích của tôi bao gồm hầu hết các trường hợp kiểm tra loại chung:

Hoạt động với:

• Nhiều giao diện (chung)
• Nhiều lớp cơ sở (chung)

• Có một tình trạng quá tải sẽ loại ra loại chung chung cụ thể nếu nó trả về đúng (xem thử nghiệm đơn vị cho các mẫu):

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

Đây là một thử nghiệm để chứng minh chức năng (cơ bản):

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