Réflexion .NET: Détection IEnumerable <T>

Question

J'essaie de détecter si une instance particulière d'un objet type est un « IEnumerable » générique ...

Le meilleur que je peux trouver est:

// theType might be typeof(IEnumerable<string>) for example... or it might not 
bool isGenericEnumerable = theType.GetGenericTypeDefinition() == typeof(IEnumerable<object>).GetGenericTypeDefinition() 
if(isGenericEnumerable) 
{ 
    Type enumType = theType.GetGenericArguments()[0]; 
    etc. ...// enumType is now typeof(string) 

Mais cela semble un peu indirect - existe-t-il un moyen plus direct/élégant de le faire?

Answer 1

Vous pouvez utiliser

if(theType.IsGenericType && theType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) 
{ 
    Type underlyingType = theType.GetGenericArguments()[0]; 
    //do something here 
} 

EDIT: ajout de la vérification des IsGenericType, merci pour les commentaires utiles

Answer 2

Notez que vous ne pouvez pas appeler GetGenericTypeDefinition() sur un type non générique, donc, tout d'abord vérifier avec IsGenericType.

Je ne suis pas sûr si vous voulez vérifier si un type implémente un générique IEnumerable<> ou si vous voulez voir si un type d'interface est IEnumerable<>. Pour le premier cas, utilisez le code suivant (la vérification interne avec interfaceType est le second cas):

if (typeof(IEnumerable).IsAssignableFrom(type)) { 
    foreach (Type interfaceType in type.GetInterfaces()) { 
     if (interfaceType.IsGenericType && (interfaceType.GetGenericTypeDefinition() == typeof(IEnumerable<>))) { 
      Console.WriteLine("{0} implements {1} enumerator", type.FullName, interfaceType.FullName); // is a match 
     } 
    } 
} 

Answer 3

Vous pouvez utiliser ce morceau de code pour déterminer si un type particulier implémente l'interface IEnumerable<T>.

Type type = typeof(ICollection<string>); 

bool isEnumerable = type.GetInterfaces()  // Get all interfaces. 
    .Where(i => i.IsGenericType)    // Filter to only generic. 
    .Select(i => i.GetGenericTypeDefinition()) // Get their generic def. 
    .Where(i => i == typeof(IEnumerable<>)) // Get those which match. 
    .Count() > 0; 

Il fonctionnera pour toute interface, mais il ne sera pas travail si le type que vous passer est IEnumerable<T>.

Vous devriez pouvoir le modifier pour vérifier les arguments de type transmis à chaque interface.