从 IEnumerable 获取类型 T；

Question

有没有办法通过反射从 IEnumerable 检索类型 T ？

例如

我有一个变量 IEnumerable info；我想通过反射检索 Child 的类型

Answer 1

IEnumerable<T> myEnumerable;
Type type = myEnumerable.GetType().GetGenericArguments()[0]; 

因此，

IEnumerable<string> strings = new List<string>();
Console.WriteLine(strings.GetType().GetGenericArguments()[0]);

打印System.String。

请参阅 MSDN 了解 Type.GetGenericArguments.

编辑：我相信这将解决评论中的问题：

// returns an enumeration of T where o : IEnumerable<T>
public IEnumerable<Type> GetGenericIEnumerables(object o) {
    return o.GetType()
            .GetInterfaces()
            .Where(t => t.IsGenericType
                && t.GetGenericTypeDefinition() == typeof(IEnumerable<>))
            .Select(t => t.GetGenericArguments()[0]);
}

某些对象实现多个通用IEnumerable，因此有必要返回它们的枚举。

编辑：尽管如此，我不得不说，对于一个类来说，为多个 T 实现 IEnumerable 是一个糟糕的主意。

Answer 2

我只是做一个扩展方法。这与我投入的一切都有效。

public static Type GetItemType<T>(this IEnumerable<T> enumerable)
{
    return typeof(T);
}

Answer 3

我有类似的问题。所选答案适用于实际情况。
就我而言，我只有一个类型（来自 PropertyInfo）。

当类型本身是 typeof(IEnumerable) 而不是 IEnumerable 的实现时，所选答案将失败。

对于这种情况，可以进行以下操作：

public static Type GetAnyElementType(Type type)
{
   // Type is Array
   // short-circuit if you expect lots of arrays 
   if (type.IsArray)
      return type.GetElementType();

   // type is IEnumerable<T>;
   if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof (IEnumerable<>))
      return type.GetGenericArguments()[0];

   // type implements/extends IEnumerable<T>;
   var enumType = type.GetInterfaces()
                           .Where(t => t.IsGenericType && 
                                  t.GetGenericTypeDefinition() == typeof(IEnumerable<>))
                           .Select(t => t.GenericTypeArguments[0]).FirstOrDefault();
   return enumType ?? type;
}

Answer 4

如果您知道 IEnumerable （通过泛型），那么只需 typeof(T) 就可以了。否则（对于 object 或非泛型 IEnumerable），检查实现的接口：

        object obj = new string[] { "abc", "def" };
        Type type = null;
        foreach (Type iType in obj.GetType().GetInterfaces())
        {
            if (iType.IsGenericType && iType.GetGenericTypeDefinition()
                == typeof(IEnumerable<>))
            {
                type = iType.GetGenericArguments()[0];
                break;
            }
        }
        if (type != null) Console.WriteLine(type);

Answer 5

非常感谢您的讨论。我用它作为下面解决方案的基础，它适用于我感兴趣的所有情况（IEnumerable、派生类等）。我想我应该在这里分享，以防有人也需要它：

  Type GetItemType(object someCollection)
  {
    var type = someCollection.GetType();
    var ienum = type.GetInterface(typeof(IEnumerable<>).Name);
    return ienum != null
      ? ienum.GetGenericArguments()[0]
      : null;
  }

Answer 6

我知道这有点老了，但我相信这种方法将涵盖评论中指出的所有问题和挑战。感谢 Eli Algranti 对我​​工作的启发。

/// <summary>Finds the type of the element of a type. Returns null if this type does not enumerate.</summary>
/// <param name="type">The type to check.</param>
/// <returns>The element type, if found; otherwise, <see langword="null"/>.</returns>
public static Type FindElementType(this Type type)
{
   if (type.IsArray)
      return type.GetElementType();

   // type is IEnumerable<T>;
   if (ImplIEnumT(type))
      return type.GetGenericArguments().First();

   // type implements/extends IEnumerable<T>;
   var enumType = type.GetInterfaces().Where(ImplIEnumT).Select(t => t.GetGenericArguments().First()).FirstOrDefault();
   if (enumType != null)
      return enumType;

   // type is IEnumerable
   if (IsIEnum(type) || type.GetInterfaces().Any(IsIEnum))
      return typeof(object);

   return null;

   bool IsIEnum(Type t) => t == typeof(System.Collections.IEnumerable);
   bool ImplIEnumT(Type t) => t.IsGenericType && t.GetGenericTypeDefinition() == typeof(IEnumerable<>);
}

Answer 7

public static Type GetInnerGenericType(this Type type)
{
  // Attempt to get the inner generic type
  Type innerType = type.GetGenericArguments().FirstOrDefault();

  // Recursively call this function until no inner type is found
  return innerType is null ? type : innerType.GetInnerGenericType();
}

这是一个递归函数，它将首先深入泛型类型列表，直到获得没有内部泛型类型的具体类型定义。

我用这种类型测试了这个方法：
ICollection>>>

应该返回 T

Answer 8

只需使用 typeof(T)

编辑：
或者，如果您没有 T，请在实例化对象上使用 .GetType().GetGenericParameter()。

Answer 9

对于更简单的情况，它是 IEnumerable 或 T 的替代方案 - 请注意使用 GenericTypeArguments 而不是 GetGenericArguments ()。

Type inputType = o.GetType();
Type genericType;
if ((inputType.Name.StartsWith("IEnumerable"))
    && ((genericType = inputType.GenericTypeArguments.FirstOrDefault()) != null)) {

    return genericType;
} else {
    return inputType;
}

Answer 10

这是对 Eli Algranti 解决方案的改进，因为它也适用于 IEnumerable 类型位于继承树中任何级别的情况。

此解决方案将从任何 Type 获取元素类型。如果类型不是 IEnumerable，它将返回传入的类型。对于对象，请使用 GetType。对于类型，请使用 typeof，然后对结果调用此扩展方法。

public static Type GetGenericElementType(this Type type)
{
    // Short-circuit for Array types
    if (typeof(Array).IsAssignableFrom(type))
    {
        return type.GetElementType();
    }

    while (true)
    {
        // Type is IEnumerable<T>
        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            return type.GetGenericArguments().First();
        }

        // Type implements/extends IEnumerable<T>
        Type elementType = (from subType in type.GetInterfaces()
            let retType = subType.GetGenericElementType()
            where retType != subType
            select retType).FirstOrDefault();

        if (elementType != null)
        {
            return elementType;
        }

        if (type.BaseType == null)
        {
            return type;
        }

        type = type.BaseType;
    }
}

Answer 11

typeof(IEnumerable)。GetGenericArguments()[0] 将返回第一个泛型参数 - 在本例中为 typeof(Foo)。

Answer 12

这就是我通常这样做的方式（通过扩展方法）：

public static Type GetIEnumerableUnderlyingType<T>(this T iEnumerable)
    {
        return typeof(T).GetTypeInfo().GetGenericArguments()[(typeof(T)).GetTypeInfo().GetGenericArguments().Length - 1];
    }

Answer 13

这是我不可读的 Linq 查询表达式版本。

public static Type GetEnumerableType(this Type t) {
    return !typeof(IEnumerable).IsAssignableFrom(t) ? null : (
    from it in (new[] { t }).Concat(t.GetInterfaces())
    where it.IsGenericType
    where typeof(IEnumerable<>)==it.GetGenericTypeDefinition()
    from x in it.GetGenericArguments() // x represents the unknown
    let b = it.IsConstructedGenericType // b stand for boolean
    select b ? x : x.BaseType).FirstOrDefault()??typeof(object);
}

请注意，该方法还考虑了非泛型 IEnumerable，在这种情况下它返回 object，因为它需要 Type 而不是一个具体的实例作为参数。顺便说一下，对于x代表未知，我发现这个视频很有趣，尽管它无关紧要..