Determine if collection is of type IEnumerable

Question

How to determine if object is of type IEnumerable <T>?

Code:

namespace NS {
    class Program {
        static IEnumerable<int> GetInts() {
            yield return 1;
        }
        static void Main() {
            var i = GetInts();
            var type = i.GetType();
            Console.WriteLine(type.ToString());
        }
    }
}

Output:

NS.1.Program+<GetInts>d__0

If I change GetInts to return IList, everything is OK the output is:

 System.Collections.Generic.List`1[System.Int32]

And this returns false:

namespace NS {
    class Program {
        static IEnumerable<int> GetInts() {
            yield return 1;
        }
        static void Main() {
            var i = GetInts();
            var type = i.GetType();
            Console.WriteLine(type.Equals(typeof(IEnumerable<int>)));
        }
    }
}

score 111 · Accepted Answer · edited Jul 07 '20 at 23:01

111

If you mean the collection, then just as:

var asEnumerable = i as IEnumerable<int>;
if(asEnumerable != null) { ... }

However, I'm assuming (from the example) that you have a Type:

The object will never be "of" type IEnumerable<int> - but it might implement it; I would expect that:

if(typeof(IEnumerable<int>).IsAssignableFrom(type)) {...}

would do. If you don't know the T (int in the above), then check all the implemented interfaces:

static Type GetEnumerableType(Type type) {
    if (type.IsInterface && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        return type.GetGenericArguments()[0];
    foreach (Type intType in type.GetInterfaces()) {
        if (intType.IsGenericType
            && intType.GetGenericTypeDefinition() == typeof(IEnumerable<>)) {
            return intType.GetGenericArguments()[0];
        }
    }
    return null;
}

and call:

Type t = GetEnumerableType(type);

if this is null, it isn't IEnumerable<T> for any T - otherwise check t.

edited Jul 07 '20 at 23:01

Marcel

1,688
1
14
25

answered Dec 04 '09 at 12:33

Marc Gravell

1,026,079
266
2,566
2,900

25

Just remember that `System.String` implements `IEnumerable`. – tymtam Sep 19 '12 at 07:42
2

@Tymek indeed - I do quite a lot of library work that handles primitive, inbuilt types and collections - and it is virtually always necessary to pull out scenarios such as `string` *before* applying generalizations, for exactly those reasons. – Marc Gravell Sep 19 '12 at 08:40
4

if the type is ICollection, which implements IEnumerable, the if statement doesn't evaluate to true. Is there a way to tell that it is IEnumerable or any of its subclasses? – Thiago Silva Jun 24 '14 at 17:18
1

There's a bug. The GetEnumerableType function does not work: for example, IEnumerable in input will return null. This is because IEnumerable implements IEnumerable, not IEnumerable<>. Any other suggestion? – sthiers Aug 04 '17 at 13:20

score 20 · Answer 2 · edited Jan 16 '18 at 15:10

20

Since IEnumerable<T> inherit IEnumerable (non generic) and if you don't need to know when a type is just IEnumerable and not IEnumerable<T> then you can use:

if (typeof(IEnumerable).IsAssignableFrom(srcType))

edited Jan 16 '18 at 15:10

johnnyRose

7,310
17
40
61

answered Apr 11 '16 at 14:58

Serge Intern

2,669
3
22
39

1

string is also IEnumerable, and above check return true for string type. – M.Hassan Sep 25 '20 at 15:20

score 14 · Answer 3 · answered Dec 04 '09 at 13:27

Same technique as Marc's answer, but Linqier:

namespace NS
{
    class Program
    {
        static IEnumerable<int> GetInts()
        {
            yield return 1;
        }

        static void Main()
        {
            var i = GetInts();
            var type = i.GetType();
            var isEnumerableOfT = type.GetInterfaces()
                .Any(ti => ti.IsGenericType
                     && ti.GetGenericTypeDefinition() == typeof(IEnumerable<>));
            Console.WriteLine(isEnumerableOfT);
        }
    }
}

score 7 · Answer 4 · edited Nov 20 '12 at 15:24

How to determine if object is of type IEnumerable <T>?

Please feel free to use this fine, ultra small, generic extension method to determine if any object implements IEnumerable interface. It extends the Object type, so you can execute it using any instance of any object you're using.

public static class CollectionTestClass
{
    public static Boolean IsEnumerable<T>(this Object testedObject)
    {
        return (testedObject is IEnumerable<T>);
    }
}

score 4 · Answer 5 · answered Dec 04 '09 at 12:35

4

i is of type NS.1.Program+<GetInts>d__0, which is a subtype of IEnumerable<int>. Thus, you can use either

if (i is IEnumerable<int>) { ... }

or IsAssignableFrom (like in Marc's answer).

answered Dec 04 '09 at 12:35

Heinzi

167,459
57
363
519

score 1 · Answer 6 · answered Dec 04 '09 at 12:37

You can use the is keyword.

[TestFixture]
class Program
{
    static IEnumerable<int> GetInts()
    {
        yield return 1;
    }

    [Test]
    static void Maasd()
    {
        var i = GetInts();
        Assert.IsTrue(i is IEnumerable<int>);
    }
}

Pham Bien · Answer 7 · 2020-02-07T08:37:24.603

0

Try

type.GetInterface("IEnumerable") != null && type.IsGenericType

edited Feb 07 '20 at 08:37

answered Feb 07 '20 at 08:30

Pham Bien

31
4

Jonathan Tiefer · Answer 8 · 2020-02-29T08:31:16.710

I believe the best way to solve this should be simple.. You first write code that returns the generic arguments (or argument in your case) of the IEnumerable<T> then write another line to make a comparison of the argument type you desire to compare to the type contained in the IEnumerable<T> object (int, in your case). I have an example that displays two simple functions that handles both tasks.

    public static Type GetEnumerableArgumentType(Type type)
    {
        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
            return type.GetGenericArguments()[0];
        else
            return null;            
    }        

    public static bool EnumerableContainsArgumentType(Type tEnumerable, Type tGenArg)
    {
        return GetEnumerableArgumentType(tEnumerable) == tGenArg;
    }

score 0 · Answer 9 · answered Oct 11 '20 at 11:54

For anyone searching for this who just wants to know how to return true or false on if an object is or inherits from IEnumerable, I've used Marcs original answer to create this generic method I'm now using.

private static bool ImplementsIEnumerable<T>(T obj)
    {
        var type = obj.GetType();
        if (type.IsInterface && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
        {
            return true;
        }
        foreach (Type interfaceUsed in type.GetInterfaces())
        {
            if (interfaceUsed.IsGenericType
                && interfaceUsed.GetGenericTypeDefinition() == typeof(IEnumerable<>))
            {
                return true;
            }
        }
        return false;
    }

Determine if collection is of type IEnumerable

9 Answers9

Linked