例子：

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 */ }
}

不用反射就可以做到吗？我该怎么说C＃中的IEnumerable？因为IEnumerable <>实现了IEnumerable，我应该只使用IEnumerable吗？

解决方案

回答

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

回答

我不确定我是否理解意思。我们是否想知道对象是任何通用类型还是要测试它是否是特定的通用类型？还是只想知道是否可以枚举？

我认为第一个不可能。第二种绝对有可能，只要将其视为任何其他类型即可。对于第三个，只需按照建议针对IEnumerable对其进行测试。

同样，我们不能在类型上使用'is'运算符。

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

有关更多详细信息，请参见有关类型的问题。也许会对我们有帮助。

回答

我们想签出Type.IsInstanceOfType方法

回答

我会使用重载：

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

回答

先前接受的答案很好，但这是错误的。值得庆幸的是，该错误很小。如果我们真的想了解该接口的通用版本，那么仅检查" 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"。以下实现略有错误1，我将其留在此处仅出于历史目的。不要使用它。取而代之的是，James在回答中提供了一个出色而正确的实现。

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

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

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

Ive创建了包含一整套测试用例的要点。

回答

关于泛型类型和使用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 <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);
    }

/编辑：Konrad的新文章充分考虑了通用递归以及接口。非常好:)

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

回答

我曾经认为，这种情况可以通过类似于@Thomas Danecker的解决方案来解决，但是增加了另一个模板参数：

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 */ }

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

如果有人可以指出我在这里所做的任何错误，我将非常感谢。

回答

非常感谢这篇文章。我想提供一个对我更好的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);
}