如何判断一个类型是否实现了 IList<>？

Question

我想编写一个使用反射来判断给定类型是否实现IList<T> 的方法。例如：

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

在我的使用中，我可以假设该类型将始终是实例化的泛型类型（或根本不是泛型的东西）。

不幸的是，这并不像应该的那么容易。显而易见的解决方案：

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

不起作用；它总是返回假。显然，像 IList<> 这样的非实例化泛型类型并没有像我期望的那样实现 IsAssignableFrom：IList<> 不能从 List<T> 分配。

我也试过这个：

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

即，将 type 转换为其非实例化泛型，例如 IList<int> -> IList<>，然后再次尝试 IsAssignableFrom。当类型是实例化的IList<T>（例如IList<int>、IList<object> 等）时，这将返回true。但是对于实现IList<T> 的类（例如List<int>、ObservableCollection<double> 等），它返回false，所以显然IList<> 不能从 List<> 分配。再次，不是我所期望的。

如何编写 IsGenericList 并使其像上面的示例一样工作？

Answer 1

事实上，您不能拥有泛型类型定义的实例。因此，IsAssignableFrom() 方法按预期工作。要实现您想要的，请执行以下操作：

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

只是出于好奇，你需要这个做什么？

Answer 2

我也想测试一个类型是否为某些 T 实现 IList<T>。我对 Lucero's answer 进行了明显的更改，但它导致 subtle bug 在原始答案中不存在。这是我的最终编辑：

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

Answer 3

Lucero/Reed Copsey 现在都有正确的解决方案。为了更简洁，这里是 LINQified 形式：

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

Answer 4

使用这个： http://msdn.microsoft.com/en-us/library/system.type.findinterfaces.aspx

我试过了：

 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 5

这通过了你的测试......

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

Answer 6

我喜欢Colonel Panic's answer，但我决定让答案更通用一点，这样我就可以在其他场景中重复使用它：

    public static bool InstanceOfGenericType(this Type self, Type genericType)
    {
        return self.IsGenericType && self.GetGenericTypeDefinition() == genericType;
    }

    public static bool InstanceOfGenericInterface(this Type self, Type ifaceType)
    {
        return self.InstanceOfGenericType(ifaceType) 
            || self.GetInterfaces().Any(i => i.InstanceOfGenericType(ifaceType));
    }

    public static bool IsIList(this Type t)
    {
        return t.InstanceOfGenericInterface(typeof(IList<>));
    }

Answer 7

你试过打电话给Type.GetInterface()吗？从帮助中并不完全清楚，但我认为它会搜索由基类型实现的接口，除了类型本身。如果没有，您可以随时循环访问Type.BaseType 并再次调用GetInterface()。

Answer 8

使用“is”运算符：

is 运算符用于检查 对象的运行时类型是否 与给定类型兼容。