การทดสอบว่าวัตถุเป็นประเภททั่วไปใน C # หรือไม่

ฉันต้องการทำการทดสอบว่าวัตถุเป็นประเภททั่วไปหรือไม่ ฉันได้ลองทำสิ่งต่อไปนี้แล้วไม่ประสบความสำเร็จ:

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

ฉันทำอะไรผิดและฉันจะทำการทดสอบนี้ได้อย่างไร?

หากคุณต้องการตรวจสอบว่าเป็นอินสแตนซ์ของประเภททั่วไปหรือไม่:

return list.GetType().IsGenericType;

หากคุณต้องการตรวจสอบว่าเป็นยาสามัญหรือไม่List<T>:

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

ดังที่จอนชี้ให้เห็นสิ่งนี้จะตรวจสอบความเท่าเทียมกันของประเภทที่แน่นอน การส่งคืนfalseไม่จำเป็นต้องหมายถึงlist is List<T>ผลตอบแทนfalse(กล่าวคือไม่สามารถกำหนดวัตถุให้กับList<T>ตัวแปรได้)

ฉันคิดว่าคุณไม่เพียงต้องการทราบว่าประเภทเป็นแบบทั่วไปหรือไม่ แต่ถ้าวัตถุเป็นตัวอย่างของประเภททั่วไปโดยไม่ทราบประเภทอาร์กิวเมนต์

มันไม่ง่ายอย่างน่าเสียดาย ไม่เลวร้ายนักหากประเภททั่วไปเป็นคลาส (เช่นในกรณีนี้) แต่อินเทอร์เฟซจะยากกว่า นี่คือรหัสสำหรับชั้นเรียน:

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

แก้ไข: ตามที่ระบุไว้ในความคิดเห็นสิ่งนี้อาจใช้ได้กับอินเทอร์เฟซ:

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

ฉันแอบสงสัยว่าอาจมีบางกรณีที่น่าอึดอัดใจในเรื่องนี้ แต่ฉันไม่พบว่ามันล้มเหลวในตอนนี้

นี่คือสองวิธีการขยายที่ฉันชอบซึ่งครอบคลุมกรณีขอบส่วนใหญ่ของการตรวจสอบประเภททั่วไป:

ทำงานร่วมกับ:

• หลายอินเทอร์เฟซ (ทั่วไป)
• คลาสพื้นฐานหลายคลาส (ทั่วไป)

• มีโอเวอร์โหลดที่จะ 'ออก' ประเภททั่วไปที่เฉพาะเจาะจงหากส่งคืนจริง (ดูการทดสอบหน่วยสำหรับตัวอย่าง):

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

นี่คือการทดสอบเพื่อสาธิตการทำงาน (พื้นฐาน):

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


    }

คุณสามารถใช้โค้ดที่สั้นกว่าได้โดยใช้ไดนามิกอัลทูกซึ่งอาจช้ากว่าการสะท้อนแสง:

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

return list.GetType().IsGenericType;