C# - Obtenga el tipo de elemento para una lista genérica

Question

¿Cuál sería la mejor manera de obtener el tipo de artículos que contiene una lista genérica? Es bastante fácil tomar el primer elemento de la colección y llamar a .GetType(), pero no siempre puedo estar seguro de que haya un elemento en la colección.

Espero que tenga sentido.

Gracias,
Sonny

Answer 1

Usted puede utilizar el método Type.GetGenericArguments para este propósito.

List<Foo> myList = ... 

Type myListElementType = myList.GetType().GetGenericArguments().Single(); 

Answer 2

list.GetType().GetGenericArguments()[0] 

Answer 3

Para un enfoque más robusto:

public static Type GetListType(object someList) 
{ 
    if (someList == null) 
     throw new ArgumentNullException("someList"); 

    var type = someList.GetType(); 

    if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(List<>)) 
     throw new ArgumentException("someList", "Type must be List<>, but was " + type.FullName); 

    return type.GetGenericArguments()[0]; 
} 

Pero si la variable se escribe List<T> a continuación, puedes utilizar typeof(T). Por ejemplo:

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

Tenga en cuenta que usted no necesita en realidad ni siquiera el parámetro someList. Este método es solo un ejemplo de cómo puede usar typeof si ya se encuentra en un método genérico. Solo necesita utilizar el enfoque de reflexión si no tiene acceso al token T (la lista se almacena en una variable no genérica, como la que se escribe IList, object, etc.).

Answer 4

Public Shared Function ListItemType(ListType As System.Type) As System.Type 

    If Not ListType.IsGenericType Then 
    If ListType.BaseType IsNot Nothing AndAlso ListType.BaseType.IsGenericType Then 
     Return ListItemType(ListType.BaseType) 
    End If 
    Else 
    Return ListType.GetGenericArguments.Single 
    End If 
End Function 

Answer 5

¿Qué hay de esto, su todo estáticos (por ejemplo, no hay casos necesarios), y rápido (no hay bucles, sin el uso de LINQ), y es simple :) éstos trabajan para las colecciones:

[System.Diagnostics.DebuggerHidden] 
    public static Type GetIndexedType(this ICollection poICollection) 
    { 
     PropertyInfo oPropertyInfo = poICollection == null ? null : poICollection.GetType().GetProperty("Item"); 
     return oPropertyInfo == null ? null : oPropertyInfo.PropertyType; 
    } 

    [System.Diagnostics.DebuggerHidden] 
    public static Type GetEnumeratedType(this ICollection poICollection) 
    { 
     PropertyInfo oPropertyInfo = poICollection == null ? null : poICollection.GetType().GetMethod("GetEnumerator").ReturnType.GetProperty("Current"); 
     return oPropertyInfo == null ? null : oPropertyInfo.PropertyType; 
    } 

y algunas pruebas de unidades simples:

 [Test] 
     public void GetIndexedType() 
     { 
      Assert.AreEqual(null, ((ICollection)null).GetIndexedType()); 
      Assert.AreEqual(typeof(int), (new List<int>()).GetIndexedType()); 
      Assert.AreEqual(typeof(bool), (new SortedList<string, bool>()).GetIndexedType()); 
     } 

     [Test] 
     public void GetEnumeratedType() 
     { 
      Assert.AreEqual(null, ((ICollection)null).GetEnumeratedType()); 
      Assert.AreEqual(typeof(int), (new List<int>()).GetEnumeratedType()); 
      Assert.AreEqual(typeof(KeyValuePair<string, bool>), (new SortedList<string, bool>()).GetEnumeratedType()); 
     } 

Aviso el hecho de que hay dos maneras de ver esto, un tipo pueden ser devueltos por el indexador y otro tipo pueden ser devueltos por el encuestador. La prueba unitaria muestra ambos.

Diviértete, Frans.

P.s. Para enumerables:

[System.Diagnostics.DebuggerHidden] 
    public static Type GetEnumeratedType(this System.Collections.IEnumerable poIEnumerable) 
    { 
     PropertyInfo oPropertyInfo = poIEnumerable == null ? null : poIEnumerable.GetType().GetMethod("GetEnumerator").ReturnType.GetProperty("Current"); 
     return oPropertyInfo == null ? null : oPropertyInfo.PropertyType; 
    } 

Y para empadronador:

[System.Diagnostics.DebuggerHidden] 
    public static Type GetEnumeratedType(this System.Collections.IEnumerator poIEnumerator) 
    { 
     PropertyInfo oPropertyInfo = poIEnumerator == null ? null : poIEnumerator.GetType().GetProperty("Current"); 
     return oPropertyInfo == null ? null : oPropertyInfo.PropertyType; 
    } 

Answer 6

Ésta es otra manera que trabaja para las colecciones no genéricas, también:

static Type GetItemType(Type collectionType) 
{ 
    return collectionType.GetMethod("get_Item").ReturnType; 
} 

Es decir, obtener el tipo de retorno de foo[x] , donde foo es del tipo especificado.

Ejemplos:

// Generic type; prints System.Int32 
Console.WriteLine(GetItemType(typeof(List<int>))); 

// Non-generic type; prints System.String 
Console.WriteLine(GetItemType(typeof(System.Collections.Specialized.StringCollection))); 

---

GetItemType El método anterior tiene un par de problemas, sin embargo:

• Se lanza una NullReferenceException si el tipo tiene ningún operador de indexación.

• lanza una AmbiguousMatchException si el tipo tiene varios sobrecargas para el operador de indexación (por ejemplo this[string] y this[int]).

Aquí es una versión más refinada:

public static Type GetItemType(this Type collectionType) 
{ 
    var types = 
     (from method in collectionType.GetMethods() 
     where method.Name == "get_Item" 
     select method.ReturnType 
     ).Distinct().ToArray(); 
    if (types.Length == 0) 
     return null; 
    if (types.Length != 1) 
     throw new Exception(string.Format("{0} has multiple item types", collectionType.FullName)); 
    return types[0]; 
} 

Answer 7

nuevo método cuestión antiguo con dynamic

void Foo(){ 
    Type type GetTypeT(data as dynamic); 
} 

private static Type GetTypeT<T>(IEnumerable<T> data) 
{ 
    return typeof(T); 
} 

Answer 8

public Type GetType(IEnumerable<object> resultList) 
    { 
     return resultList.GetType().GetElementType(); 
    }