obtention du type T à partir de IEnumerable<T>

Question

Existe-t-il un moyen de récupérer le type T de IEnumerable<T> par la réflexion ?

par exemple

j'ai une variable IEnumerable<Child> info ; Je veux récupérer le type de l'enfant par réflexion.

Answer 1

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

Ainsi,

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

imprime System.String .

Voir MSDN pour Type.GetGenericArguments .

Edit : Je pense que cela répondra aux préoccupations exprimées dans les commentaires :

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

Certains objets implémentent plus d'un générique IEnumerable il est donc nécessaire de renvoyer une énumération de ceux-ci.

Edit : Bien que, je dois dire, c'est une idée terrible pour une classe d'implémenter IEnumerable<T> pour plus d'un T .

Answer 2

Je ferais juste une méthode d'extension. Cela a fonctionné avec tout ce que j'ai lancé.

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

Answer 3

J'ai eu un problème similaire. La réponse sélectionnée fonctionne pour les instances réelles. Dans mon cas, je n'avais qu'un type (issu d'une PropertyInfo ).

La réponse sélectionnée échoue lorsque le type lui-même est typeof(IEnumerable<T>) pas une mise en œuvre de IEnumerable<T> .

Dans ce cas, la méthode suivante fonctionne :

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

Si vous connaissez le IEnumerable<T> (via les génériques), alors il suffit de typeof(T) devrait fonctionner. Sinon (pour object ou le non générique IEnumerable ), vérifiez les interfaces mises en œuvre :

        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

Merci beaucoup pour cette discussion. Je m'en suis servi comme base pour la solution ci-dessous, qui fonctionne bien pour tous les cas qui m'intéressent (IEnumerable, classes dérivées, etc). J'ai pensé que je devais la partager ici au cas où quelqu'un en aurait également besoin :

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