CODEWITHSUNDEEP
c#genericsforeachienumerable
Earlz
Earlz

Reputation: 63835

How to check if a variable is an IEnumerable of some sort

basically I'm building a very generic T4 template and one of the things I need it to do is say print variable.ToString(). However, I want it to evaluate lists and foreach through them and instead print ListItem.ToString() My T4 template does not know what type variable will be ahead of time, that is why this is so generic.

But my current code that gets generated looks like this:

if(variable!=null)
  if(variable is IEnumerable) //error here
    foreach(var item in variable)
      Write(item.ToString());

I get a compiler error on the marked line for "Using the generic type System.Generic.Collections.IEnumerable requires one type argument"

I don't actually care what type it is though, I just want to know if you can foreach through the variable. What code should I use instead?

Upvotes: 55

Views: 46327

Answers (9)

Pawel Cioch
Pawel Cioch

Reputation: 3184

If you don't care about object type and you are not in Generic method in C# 7.0+

        if (item is IEnumerable<object> enumVar)
        {
            foreach (var e in enumVar)
            {
                    e.ToString();

            }
        }

In C# < 7.0

        if (item is IEnumerable<object>)
        {
            var enumVar = item as IEnumerable<object>;
            foreach (var e in enumVar)
            {
                e.ToString();

            }
            //or you can cast an array to set values, 
            //since IEnumerable won't let you, unless you cast to IList :) 
            //but array version here 
            //https://stackoverflow.com/a/9783253/1818723
        }

Upvotes: 2

Tobi
Tobi

Reputation: 5519

Since C# 7.0 you can also achieve this so:

if (variable is IEnumerable enumVar)
{
    foreach (var e in enumVar)
    {
        ...
    }
}

Upvotes: 10

Rob Deary
Rob Deary

Reputation: 997

You can actually test the base class of any generic type directly. 

instance.GetGenericTypeDefinition()  == typeof(IEnumerable<>)

Upvotes: 3

user152949
user152949

Reputation:

This is an old question, but I wanted to show an alternative method for determining if a SomeType is IEnumerable:

var isEnumerable = (typeof(SomeType).Name == "IEnumerable`1");

Upvotes: -3

LukeH
LukeH

Reputation: 269368

If you want to test for the non-generic IEnumerable then you'll need to include a using System.Collections directive at the top of your source file.

If you want to test for an IEnumerable<T> of some kind then you'll need something like this instead:

if (variable != null)
{
    if (variable.GetType().GetInterfaces().Any(
            i => i.IsGenericType &&
            i.GetGenericTypeDefinition() == typeof(IEnumerable<>)))
    {
        // foreach...
    }
}

Upvotes: 28

user164771
user164771

Reputation:

You have already accepted an answer however,since generic IEnumerable<T> implements the non generic IEnumerable you can just cast to that.

// Does write handle null? Might need some sanity aswell.

var enumerable = variable as System.Collections.IEnumerable; 

if (enumerable != null)
    foreach(var item in enumerable)
         Write(item);
else
    Write(item);

Upvotes: 77

Schultz9999
Schultz9999

Reputation: 8926

Well, somewhat simple but... if you only have:

using System.Collections.Generic;

you might need to add:

using System.Collections;

The former defines IEnumerable<T> and latter defines IEnumerable.

Upvotes: 9

Josh
Josh

Reputation: 69262

The other answers have pointed out the generic/non-generic IEnumerable difference but I should also point out that you will also want to test for String specifically because it implements IEnumerable but I doubt you'll want to treat it as a collection of characters.

Upvotes: 20

user166390
user166390

Reputation:

In general, with no non-generic base type/interface, this requires GetType and a recursive look-up through the base types/interfaces.

However, that doesn't apply here :-) Just use the non-generic IEnumerable (System.Collections.IEnumerable), from which the generic IEnumerable (System.Collections.Generic.IEnumerable<T>) inherits.

Upvotes: 3

Related Questions