¿Cómo obtener el tipo de T de un miembro de una clase o método genérico?

Digamos que tengo un miembro genérico en una clase o método, así que:

public class Foo { public List Bar { get; set; } public void Baz() { // get type of T } } 

Cuando instanciamos la clase, la T convierte en MyTypeObject1 , por lo que la clase tiene una propiedad de lista genérica: List . Lo mismo se aplica a un método genérico en una clase no genérica:

 public class Foo { public void Bar() { var baz = new List(); // get type of T } } 

Me gustaría saber qué tipo de objetos contiene la lista de mi clase. Entonces la propiedad de la lista llamada Bar o la variable local baz , ¿qué tipo de T ?

No puedo hacer Bar[0].GetType() , porque la lista puede contener cero elementos. ¿Cómo puedo hacerlo?

Si entiendo correctamente, su lista tiene el mismo parámetro de tipo que la clase contenedor. Si este es el caso, entonces:

 Type typeParameterType = typeof(T); 

Si está en la situación afortunada de tener un object como parámetro de tipo, vea la respuesta de Marc .

(nota: asumo que todo lo que sabes es object o IList o similar, y que la lista podría ser de cualquier tipo en tiempo de ejecución)

Si sabes que es una List , entonces:

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

Otra opción es mirar el indexador:

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

Usando nuevo TypeInfo:

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

Con el siguiente método de extensión puede escapar sin reflexionar:

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

O más general:

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

Uso:

 List list = new List { "a", "b", "c" }; IEnumerable strings = list; IEnumerable objects = list; Type listType = list.GetListType(); // string Type stringsType = strings.GetEnumeratedType(); // string Type objectsType = objects.GetEnumeratedType(); // BEWARE: object 

Tratar

 list.GetType().GetGenericArguments() 

Eso es trabajo para mí. Donde myList es un tipo de lista desconocida.

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

Considere esto: lo uso para exportar 20 listas tipadas de la misma manera:

 private void Generate() { 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 { ((T)item as DemomigrItemList).CreateCSV(type); } } 

Si no necesita toda la variable Tipo y solo desea verificar el tipo, puede crear fácilmente una variable de temperatura y usar es el operador.

 T checkType = default(T); if (checkType is MyClass) {} 

El método GetGenericArgument() debe establecerse en el tipo de base de su instancia (cuya clase es una clase genérica myClass ). De lo contrario, devuelve un tipo [0]

Ejemplo:

 Myclass instance = new Myclass(); Type[] listTypes = typeof(instance).BaseType.GetGenericArguments(); 
 public string ListType(T value){ var valueType = value.GetType().GenericTypeArguments[0].FullName; return value; } 

Puede usar este para volver a ejecutar el tipo de lista genérica.

Puede obtener el tipo de “T” de cualquier tipo de colección que implemente IEnumerable con lo siguiente:

 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 once. return types.Length == 1 ? types[0].GetGenericArguments()[0] : null; } 

Tenga en cuenta que no admite tipos de colecciones que implementen IEnumerable dos veces, por ejemplo

 public class WierdCustomType : IEnumerable, IEnumerable { ... } 

Supongo que podría devolver una variedad de tipos si necesitara apoyar esto …

Además, es posible que desee almacenar en caché el resultado por tipo de colección si está haciendo esto mucho (por ejemplo, en un bucle).

Yo uso este método de extensión para lograr algo similar:

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

Lo usas así:

 [TestMethod] public void GetFriendlyTypeName_ShouldHandleReallyComplexTypes() { typeof(Dictionary>).GetFriendlyTypeName() .ShouldEqual("Dictionary>"); } 

Esto no es exactamente lo que está buscando, pero es útil para demostrar las técnicas involucradas.

Usando la solución de 3dGrabber:

 public static T GetEnumeratedType(this IEnumerable _) { return default(T); } //and now var list = new Dictionary(); var stronglyTypedVar = list.GetEnumeratedType(); 
 public bool IsCollection(T value){ var valueType = value.GetType(); return valueType.IsArray() || typeof(IEnumerable).IsAssignableFrom(valueType) || typeof(IEnumerable).IsAssignableFrom(valuetype); } 

Si quieres saber el tipo subyacente de una propiedad, prueba esto:

 propInfo.PropertyType.UnderlyingSystemType.GenericTypeArguments[0] 

Así es como lo hice

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

Entonces llámalo así

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

O

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

Tipo:

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