.NET Reflection: Detecting IEnumerable<T>

Question

I'm trying to detect if a particular instance of a Type object is a generic "IEnumerable"...

The best I can come up with is:

// 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)

But this seems a bit indirect - is there a more direct/elegant way to do this?

Answer 1

You can use

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

EDIT: added the IsGenericType check, thanks for the useful comments

Answer 2

Note that you cannot call GetGenericTypeDefinition() on a non-generic type, therefore, first check with IsGenericType.

I'm not sure if you want to check whether a type implements a generic IEnumerable<> or if you want to see if an interface type is IEnumerable<>. For the first case, use the following code (the inner check with interfaceType is the second case):

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

You can use this piece of code to determine if a particular type implements the IEnumerable<T> interface.

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;

It will work for any interface, however it will not work if the type you pass in is IEnumerable<T>.

You should be able to modify it to check the type arguments passed to each interface.