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


674

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

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

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

当我实例化该类时,T它将变为MyTypeObject1,因此该类具有通用的list属性:List<MyTypeObject1>。非泛型类中的泛型方法也是如此:

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

        // get type of T
    }
}

我想知道,我的班级列表包含什么类型的对象。那么被称为list的属性Bar或局部变量baz包含什么类型的T

我不能这样做Bar[0].GetType(),因为列表可能包含零个元素。我该怎么做?

Answers:


693

如果我理解正确,则您的列表具有与容器类本身相同的类型参数。如果是这样,则:

Type typeParameterType = typeof(T);

如果您很幸运object拥有类型参数,请参阅Marc的答案


4
大声笑-是的,非常真实;我假设OP仅具有objectIList或类似名称-但这很可能是正确的答案。
马克·格雷韦尔

32
我喜欢它的可读性typeof。如果您想知道T的类型,请使用typeof(T):)
demoncodemonkey 2012年

2
我实际上只是使用typeof(Type),它的效果很好。
安东

1
但是,不能将typeof()与泛型参数一起使用。
Reynevan

2
@Reynevan当然可以typeof()与泛型参数一起使用。您是否有无法使用的示例?还是您混淆类型参数和引用?
a安

520

(注:我假设你知道objectIList或类似的,并且这个名单可以是任何类型的在运行时)

如果您知道它是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];

1
类型type = abc.GetType()。GetGenericArguments()[0]; ==>数组索引越界...
Patrick Desjardins

28
@ Daok:那不是列表<T>
Marc Gravell

对于BindingList或List或任何包含<T>的对象,需要一些东西。我在做什么使用自定义BindingListView <T>
Patrick Desjardins,2009年

1
尝试使用BindingList <T>,我们的BindingListView <T>继承自BindingList <T>,而我都尝试了两种选择,但均不起作用。我可能做错了什么...但是我认为此解决方案适用于List <T>类型,但不适用于其他类型的list。
Patrick Desjardins,2009年

类型type = abc.GetType()。GetProperty(“ Item”)。PropertyType; 返回BindingListView <MyObject>而不是MyObject ...
Patrick Desjardins

49

使用以下扩展方法,您可以不加思索地逃脱:

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

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

'返回默认值(T);'
fantastory 2015年

1
@recursive:如果要使用匿名类型的列表,这将很有用。
JJJ

在阅读您的回答之前,我做过完全相同的事情,但是我给我打了电话ItemType
toddmo '16

31

尝试

list.GetType().GetGenericArguments()

7
新的List <int>()。GetType()。GetGenericArguments()返回System.Type [1],其中System.Int32作为条目
Rauhotz,2009年

@Rauhotz GetGenericArguments方法返回的Array对象Type,然后需要解析其所需的Generic Type的位置。如Type<TKey, TValue>:您将需要GetGenericArguments()[0]获取TKey类型并GetGenericArguments()[1]获取TValue类型
GoldBishop 18'Apr

14

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

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

1
我收到一个错误,它要求一个类型参数(即<T>
Joseph Humfrey 2015年

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

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

10

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

T checkType = default(T);

if (checkType is MyClass)
{}

9

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

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

1
如果T是实际添加的对象的抽象超类,则此方法不起作用。更不用说,new T();只会做与相同的事情(T)Activator.CreateInstance(typeof(T));。它确实需要添加where T : new()到类/函数定义中,但是如果创建对象,则无论如何都应该这样做。
Nyerguds

另外,您正在调用GetType一个FirstOrDefault条目,从而导致潜在的空引用异常。如果您确定它将返回至少一项,那么为什么不使用它First呢?
Mathias Lykkegaard Lorenzen 2015年

6

我使用此扩展方法来完成类似的操作:

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

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


嗨,谢谢您的回答,您也可以为“ StripStartingWith”添加扩展名吗?
Cedric Arnould'1

1
@CedricArnould-添加。
肯·史密斯,

5

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

例:

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

5

您可以从实现IEnumerable <T>的任何集合类型中通过以下方式获取“ 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 <T>的集合类型,例如

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

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

另外,如果您经常这样做(例如循环执行),则可能还希望按集合类型缓存结果。


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

1
这似乎是在解决类型是否为list-y之类的问题,但问题更多是关于如何确定已知是List的类型的初始类型使用了哪个泛型类型参数。
内森·塔吉

1

使用3dGrabber的解决方案:

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

//and now 

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


0

这就是我做的

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

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.