如何检测类型是否是另一种泛型类型

Question

例子：

public static void DoSomething<K,V>(IDictionary<K,V> items) {
   items.Keys.Each(key => {
      if (items[key] **is IEnumerable<?>**) { /* do something */ }
      else { /* do something else */ }
}

这可以在不使用反射的情况下完成吗？ IEnumerable 在 C# 中怎么说？ 我应该只使用 IEnumerable，因为 IEnumerable<> 实现了 IEnumerable？

Answer 1

非常感谢这篇文章。 我想提供一个更适合我的 Konrad Rudolph 解决方案版本。 我在那个版本中遇到了一些小问题，特别是在测试 Type 是否为可空值类型时：

public static bool IsAssignableToGenericType(Type givenType, Type genericType)
{
    var interfaceTypes = givenType.GetInterfaces();

    foreach (var it in interfaceTypes)
    {
        if (it.IsGenericType && it.GetGenericTypeDefinition() == genericType)
            return true;
    }

    if (givenType.IsGenericType && givenType.GetGenericTypeDefinition() == genericType)
        return true;

    Type baseType = givenType.BaseType;
    if (baseType == null) return false;

    return IsAssignableToGenericType(baseType, genericType);
}

Answer 2

先前接受的答案很好，但它是错误的。 值得庆幸的是，这个错误很小。 如果您真的想了解接口的通用版本，检查IEnumerable是不够的； 有很多类只实现了非泛型接口。 我会在一分钟内给出答案。 不过，首先，我想指出接受的答案过于复杂，因为在给定的情况下，以下代码将实现相同的效果：

if (items[key] is IEnumerable)

这甚至更多，因为它分别适用于每个项目（而不是它们的公共子类V ）。

现在，对于正确的解决方案。 这有点复杂，因为我们必须采用泛型类型IEnumerable`1 （即带有一个类型参数的IEnumerable<>类型）并注入正确的泛型参数：

static bool IsGenericEnumerable(Type t) {
    var genArgs = t.GetGenericArguments();
    if (genArgs.Length == 1 &&
            typeof(IEnumerable<>).MakeGenericType(genArgs).IsAssignableFrom(t))
        return true;
    else
        return t.BaseType != null && IsGenericEnumerable(t.BaseType);
}

您可以轻松测试此代码的正确性：

var xs = new List<string>();
var ys = new System.Collections.ArrayList();
Console.WriteLine(IsGenericEnumerable(xs.GetType()));
Console.WriteLine(IsGenericEnumerable(ys.GetType()));

产量：

True
False

不要过分担心这会使用反射。 虽然这确实增加了运行时开销，但is运算符的使用也是如此。

当然，上面的代码受到了IsAssignableToGenericType限制，可以扩展为更普遍适用的方法IsAssignableToGenericType 。 下面的实现有点不正确¹ ，我将它留在这里仅用于历史目的。 不要使用它。 相反，詹姆斯在他的回答中提供了一个极好的、正确的实现。

public static bool IsAssignableToGenericType(Type givenType, Type genericType) {
    var interfaceTypes = givenType.GetInterfaces();

    foreach (var it in interfaceTypes)
        if (it.IsGenericType)
            if (it.GetGenericTypeDefinition() == genericType) return true;

    Type baseType = givenType.BaseType;
    if (baseType == null) return false;

    return baseType.IsGenericType &&
        baseType.GetGenericTypeDefinition() == genericType ||
        IsAssignableToGenericType(baseType, genericType);
}

¹当genericType与genericType相同时givenType ； 出于同样的原因，它对于可空类型失败，即

IsAssignableToGenericType(typeof(List<int>), typeof(List<>)) == false
IsAssignableToGenericType(typeof(int?), typeof(Nullable<>)) == false

我已经创建了一个包含一整套测试用例的要点。

Answer 3

关于泛型类型和使用 IsAssignableFrom() 的警告...

假设您有以下内容：

public class MyListBase<T> : IEnumerable<T> where T : ItemBase
{
}

public class MyItem : ItemBase
{
}

public class MyDerivedList : MyListBase<MyItem>
{
}

在基本列表类型或派生列表类型上调用 IsAssignableFrom 将返回 false，但显然MyDerivedList继承了MyListBase<T> 。 （给 Jeff 的一个简短说明，泛型绝对必须包含在代码块或波浪号中才能获得<T> ，否则将被省略。这是有意的吗？）问题源于MyListBase<MyItem>被视为完全与MyListBase<T>不同的类型。 下面的文章可以更好地解释这一点。 http://mikehadlow.blogspot.com/2006/08/reflecting-generics.html

相反，请尝试以下递归函数：

    public static bool IsDerivedFromGenericType(Type givenType, Type genericType)
    {
        Type baseType = givenType.BaseType;
        if (baseType == null) return false;
        if (baseType.IsGenericType)
        {
            if (baseType.GetGenericTypeDefinition() == genericType) return true;
        }
        return IsDerivedFromGenericType(baseType, genericType);
    }

/编辑：康拉德的新帖子考虑了通用递归以及接口。 很不错的作品。 :)

/EDIT2：如果检查 genericType 是否是接口，则可以实现性能优势。 检查可以是围绕当前接口代码的 if 块，但如果您对使用 .NET 3.5 感兴趣，我的一个朋友提供了以下内容：

    public static bool IsAssignableToGenericType(Type givenType, Type genericType)
    {
        var interfaces = givenType.GetInterfaces().Where(it => it.IsGenericType).Select(it => it.GetGenericTypeDefinition());
        var foundInterface = interfaces.FirstOrDefault(it => it == genericType);
        if (foundInterface != null) return true;

        Type baseType = givenType.BaseType;
        if (baseType == null) return false;

        return baseType.IsGenericType ?
            baseType.GetGenericTypeDefinition() == genericType :
            IsAssignableToGenericType(baseType, genericType);
    }

Answer 4

if (typeof(IEnumerable).IsAssignableFrom(typeof(V))) {

Answer 5

感谢您提供的信息。 为方便起见，我已将其重构为一个扩展方法并将其简化为单个语句。

public static bool IsAssignableToGenericType(this Type givenType, Type genericType)
{
  return givenType.GetInterfaces().Any(t => t.IsGenericType && t.GetGenericTypeDefinition() == genericType) ||
         givenType.BaseType != null && (givenType.BaseType.IsGenericType && givenType.BaseType.GetGenericTypeDefinition() == genericType ||
                                        givenType.BaseType.IsAssignableToGenericType(genericType));
}

现在可以很容易地调用它：

sometype.IsAssignableToGenericType(typeof(MyGenericType<>))

Answer 6

我会使用重载：

public static void DoSomething<K,V>(IDictionary<K,V> items)
  where V : IEnumerable
{
   items.Keys.Each(key => { /* do something */ });
}

public static void DoSomething<K,V>(IDictionary<K,V> items)
{
   items.Keys.Each(key => { /* do something else */ });
}

Answer 7

我曾经认为这种情况可以通过类似于@Thomas Danecker's solution的方式解决，但添加另一个模板参数：

public static void DoSomething<K, V, U>(IDictionary<K,V> items)
    where V : IEnumerable<U> { /* do something */ }
public static void DoSomething<K, V>(IDictionary<K,V> items)
                             { /* do something else */ }

但我现在注意到，除非我明确指定第一个方法的模板参数，否则它不起作用。 这显然不是按字典中的每个项目定制的，但它可能是一种穷人的解决方案。

如果有人能指出我在这里可能做的任何不正确的事情，我将非常感激。

Answer 8

我不确定我明白你在这里的意思。 您想知道对象是否属于任何泛型类型，还是想测试它是否是特定的泛型类型？ 或者你只是想知道是否可枚举？

我不认为第一个是可能的。 第二种绝对是可能的，只是把它当作任何其他类型。 对于第三个，只需按照您的建议对 IEnumerable 进行测试。

此外，您不能在类型上使用“is”运算符。

// Not allowed
if (string is Object)
  Foo();
// You have to use 
if (typeof(object).IsAssignableFrom(typeof(string))
  Foo();

有关更多详细信息，请参阅有关类型的此问题。 也许它会帮助你。

Answer 9

您想查看Type.IsInstanceOfType方法