如何从泛型类或方法的成员中获取T的类型？

假设我在类或方法中有一个通用成员，因此：

public class Foo<T>
{
    public List<T> Bar { get; set; }

    public void Baz()
    {
        // get type of T
    }   
}

当我实例化该类时，T变为MyTypeObject1，因此该类具有一个通用列表属性：List<MyTypeObject1>。非泛型类中的泛型方法也是如此：

public class Foo
{
    public void Bar<T>()
    {
        var baz = new List<T>();

        // get type of T
    }
}

我想知道，我的类列表包含什么类型的对象。因此，名为Bar的列表属性或局部变量baz包含什么类型的T？

我无法执行Bar[0].GetType()，因为列表可能包含零个元素。我该怎么办？

#1 楼

如果我理解正确，则您的列表与容器类本身具有相同的类型参数。如果是这种情况，则：

Type typeParameterType = typeof(T);

如果您很幸运地将object作为类型参数，请参阅Marc的答案。

我喜欢typeof的可读性。如果您想知道T的类型，只需使用typeof（T）:)

– demoncodemonkey
2012年2月17日的13:00

我实际上只是使用了typeof（Type），效果很好。

–安东
17-6-26 at 14:39

但是，不能将typeof（）与泛型参数一起使用。

– Reynevan
19 Mar 8 '19 at 17:52

@Reynevan当然，您可以将typeof（）与通用参数一起使用。您是否有无法使用的示例？还是您混淆类型参数和引用？

–罗安
19年7月26日在7:41

#2 楼

（注意：我假设您所知道的只是object或IList或类似名称，并且列表在运行时可以是任何类型）

如果您知道它是List<T>，则：

Type type = abc.GetType().GetGenericArguments()[0];

另一种选择是查看索引器：

Type type = abc.GetType().GetProperty("Item").PropertyType;

使用新的TypeInfo：

using System.Reflection;
// ...
var type = abc.GetType().GetTypeInfo().GenericTypeArguments[0];

类型type = abc.GetType（）。GetGenericArguments（）[0]; ==>越界数组索引...

–帕特里克·德斯贾丁（Patrick Desjardins）
09年2月17日在15:31

@Daok：那么它不是列表

– Marc Gravell♦
09年2月17日在15:32

对于BindingList或List或任何包含的对象，需要一些东西。我在做什么使用自定义BindingListView

–帕特里克·德斯贾丁（Patrick Desjardins）
09年2月17日在15:34

尝试使用BindingList ，我们的BindingListView 继承自BindingList ，而我都尝试了两种选择，但均无效。我可能做错了什么...但是我认为此解决方案适用于List 类型，但不适用于其他类型的list。

–帕特里克·德斯贾丁（Patrick Desjardins）
09年2月17日在15:49

类型type = abc.GetType（）。GetProperty（“ Item”）。PropertyType;返回BindingListView 而不是MyObject ...

–帕特里克·德斯贾丁（Patrick Desjardins）
09年2月17日在15:57

#3 楼

使用以下扩展方法，您可以不费吹灰之力：

public static Type GetListType<T>(this List<T> _)
{
    return typeof(T);
}

或更笼统：

public static Type GetEnumeratedType<T>(this IEnumerable<T> _)
{
    return typeof(T);
}

用法：

List<string>        list    = new List<string> { "a", "b", "c" };
IEnumerable<string> strings = list;
IEnumerable<object> objects = list;

Type listType    = list.GetListType();           // string
Type stringsType = strings.GetEnumeratedType();  // string
Type objectsType = objects.GetEnumeratedType();  // BEWARE: object

仅当您在编译时已经知道T的类型时，此功能才有用。在这种情况下，您实际上根本不需要任何代码。

–递归
15年2月12日在20:42

'返回默认值（T）;'

–庆典
2015年6月3日14:42

@recursive：如果要处理匿名类型的列表，这将很有用。

– JJJ
16年6月17日在12:15

#4 楼

尝试

list.GetType().GetGenericArguments()

新的List （）。GetType（）。GetGenericArguments（）返回System.Type [1]，其中System.Int32作为条目

–Rauhotz
09年2月17日在15:40

@Rauhotz的GetGenericArguments方法返回Type的Array对象，然后您需要解析其所需的Generic Type的位置。如Type ：您将需要GetGenericArguments（）[0]以获取TKey类型，并需要GetGenericArguments（）[1]以获取TValue类型。

– GoldBishop
18年4月18日在16:37

#5 楼

那对我有用。其中myList是某种未知的列表。

IEnumerable myEnum = myList as IEnumerable;
Type entryType = myEnum.AsQueryable().ElementType;

我收到一个错误，它要求一个类型参数（即）

–约瑟夫·汉弗莱（Joseph Humfrey）
2015年5月21日在14:26

约瑟夫和其他人，为了摆脱该错误，它在System.Collections中。

–user2334883
16年1月16日在4:58

我只需要第二行。 List已经是IEnumerable的实现，因此强制转换似乎未添加任何内容。但是，谢谢，这是一个很好的解决方案。

– Pipedreambomb
16-11-22在13:44

#6 楼

如果您不需要整个Type变量，而只想检查类型，则可以轻松地创建一个temp变量，并使用运算符。

T checkType = default(T);

if (checkType is MyClass)
{}

这应该是公认的答案，当然是表现最好的答案。

–塞尔吉·萨根（Serj Sagan）
11月5日18:52

#7 楼

您可以将其用于通用列表的返回类型：

public string ListType<T>(T value)
{
    var valueType = value.GetType().GenericTypeArguments[0].FullName;
    return valueType;
}

#8 楼

考虑一下：
我用它以相同的方式导出20个类型列表：

private void Generate<T>()
{
    T item = (T)Activator.CreateInstance(typeof(T));

    ((T)item as DemomigrItemList).Initialize();

    Type type = ((T)item as DemomigrItemList).AsEnumerable().FirstOrDefault().GetType();
    if (type == null) return;
    if (type != typeof(account)) //account is listitem in List<account>
    {
        ((T)item as DemomigrItemList).CreateCSV(type);
    }
}

如果T是实际添加的对象的抽象超类，则此方法不起作用。更不用说，只是新的T（）;与（T）Activator.CreateInstance（typeof（T））;具有相同的作用。它确实要求您在类/函数定义中添加T：new（），但是如果要创建对象，则无论如何都应这样做。

– Nyerguds
13年7月11日在7:48

同样，您正在FirstOrDefault条目上调用GetType，从而导致潜在的空引用异常。如果您确定它将返回至少一项，那么为什么不使用First呢？

– Mathias Lykkegaard Lorenzen
15年3月16日在5:56

#9 楼

必须在实例的基本类型上设置GetGenericArgument()方法（其类是泛型类myClass<T>）。否则，它返回类型[0]

示例：

Myclass<T> instance = new Myclass<T>();
Type[] listTypes = typeof(instance).BaseType.GetGenericArguments();

#10 楼

我使用这种扩展方法来完成类似的操作：

public static string GetFriendlyTypeName(this Type t)
{
    var typeName = t.Name.StripStartingWith("`");
    var genericArgs = t.GetGenericArguments();
    if (genericArgs.Length > 0)
    {
        typeName += "<";
        foreach (var genericArg in genericArgs)
        {
            typeName += genericArg.GetFriendlyTypeName() + ", ";
        }
        typeName = typeName.TrimEnd(',', ' ') + ">";
    }
    return typeName;
}

public static string StripStartingWith(this string s, string stripAfter)
{
    if (s == null)
    {
        return null;
    }
    var indexOf = s.IndexOf(stripAfter, StringComparison.Ordinal);
    if (indexOf > -1)
    {
        return s.Substring(0, indexOf);
    }
    return s;
}

您可以这样使用它：

[TestMethod]
public void GetFriendlyTypeName_ShouldHandleReallyComplexTypes()
{
    typeof(Dictionary<string, Dictionary<string, object>>).GetFriendlyTypeName()
        .ShouldEqual("Dictionary<String, Dictionary<String, Object>>");
}

这并不是您要找的东西，但是对演示所涉及的技术很有帮助。

#11 楼

您可以通过以下任何方式从实现IEnumerable 的任何集合类型中获取“ T”类型：

public static Type GetCollectionItemType(Type collectionType)
{
    var types = collectionType.GetInterfaces()
        .Where(x => x.IsGenericType 
            && x.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        .ToArray();
    // Only support collections that implement IEnumerable<T> once.
    return types.Length == 1 ? types[0].GetGenericArguments()[0] : null;
}

请注意，它不支持两次实现IEnumerable ，例如

public class WierdCustomType : IEnumerable<int>, IEnumerable<string> { ... }

如果您需要支持此类型，我想您可以返回一个类型数组...

此外，您可能还想如果您经常执行此操作（例如循环执行），则按每种收集类型缓存结果。

#12 楼

public bool IsCollection<T>(T value){
  var valueType = value.GetType();
  return valueType.IsArray() || typeof(IEnumerable<object>).IsAssignableFrom(valueType) || typeof(IEnumerable<T>).IsAssignableFrom(valuetype);
}

这似乎是在解决类型是否为list-y之类的问题，但是问题更多地是关于如何确定已使用其初始化为List的类型的通用类型参数。

–内森·塔吉（Nathan Tuggy）
2015年5月6日，0：38

#13 楼

使用3dGrabber的解决方案：

public static T GetEnumeratedType<T>(this IEnumerable<T> _)
{
    return default(T);
}

//and now 

var list = new Dictionary<string, int>();
var stronglyTypedVar = list.GetEnumeratedType();

#14 楼

如果要了解属性的基础类型，请尝试以下操作：

propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0]

#15 楼

这就是我的做法

internal static Type GetElementType(this Type type)
{
        //use type.GenericTypeArguments if exist 
        if (type.GenericTypeArguments.Any())
         return type.GenericTypeArguments.First();

         return type.GetRuntimeProperty("Item").PropertyType);
}

然后像这样称呼它

var item = Activator.CreateInstance(iListType.GetElementType());

或

var item = Activator.CreateInstance(Bar.GetType().GetElementType());

#16 楼

类型：

type = list.AsEnumerable().SingleOrDefault().GetType();

如果列表中没有要测试的元素，则将抛出NullReferenceException。

–rossisdead
2010年7月14日在2:26

当有两个或多个元素时，SingleOrDefault（）也将引发InvalidOperationException。

– devgeezer
2012年3月14日15:08

正如\ @rossisdead和\ @devgeezer正确指出的，此答案是错误的。

–奥利弗
2013年1月23日9:53

编程黑洞网