How to determine if a type is a type of collection?

Question

I am trying to determine if a runtime type is some sort of collection type. What I have below works, but it seems strange that I have to name the types that I believe to be collection types in an array like I have done.

In the code below, the reason for the generic logic is because, in my app, I expect all collections to be generic.

bool IsCollectionType(Type type)
{
    if (!type.GetGenericArguments().Any())
        return false;

    Type genericTypeDefinition = type.GetGenericTypeDefinition();
    var collectionTypes = new[] { typeof(IEnumerable<>), typeof(ICollection<>), typeof(IList<>), typeof(List<>) };
    return collectionTypes.Any(x => x.IsAssignableFrom(genericTypeDefinition));
}

How would I refactor this code to be smarter or simpler?

One thing to keep in mind is that you usually don't want to consider `string` as a collection of `char`s, even though it implements `IEnumerable`. — svick, Jun 02 '12 at 18:01

score 96 · Accepted Answer · edited Apr 18 '22 at 03:04

96

Really all of these types inherit IEnumerable. You can check only for it:

bool IsEnumerableType(Type type)
{
    return (type.GetInterface(nameof(IEnumerable)) != null);
}

or if you really need to check for ICollection:

bool IsCollectionType(Type type)
{
    return (type.GetInterface(nameof(ICollection)) != null);
}

Look at "Syntax" part:

If you need to exclude strings (which are essentially an IEnumerable<char>), use the following function:

bool IsEnumerableType(Type type)
{
    return (type.Name != nameof(String) 
        && type.GetInterface(nameof(IEnumerable)) != null);
}

edited Apr 18 '22 at 03:04

airsouth

43
4

answered Jun 02 '12 at 17:53

Ruben

2,488
1
18
22

Haha. It really was THAT simple. For some reason I thought that wouldn't work and I didn't try it. – Byron Sommardahl Jun 02 '12 at 17:55
1

Inheritance hierarchy in the doc doesn't tell you implemented interfaces. But looking at the Syntax section will. – svick Jun 02 '12 at 18:03
@svick: What about public class List : IList, ICollection, IEnumerable, IList, ICollection, IEnumerable ? – Ruben Jun 02 '12 at 18:05
1

@Ruben, that's exactly what I meant, but that's not in the Inheritance Hierarchy section. – svick Jun 02 '12 at 18:29
I tend to over think simple problems as well ;) – Tanner Watson Jun 02 '12 at 20:32
25

Checking `IEnumerable` has the problem of incorrectly interpreting `string` as a collection. This is not desirable most of the time. – Mohammad Dehghan Apr 29 '15 at 06:35
2

Didn't work for me at all. `ICollection` returned `null` on `type.GetInterface("ICollection")` and on `type.GetInterface("System.Collections.Generic.ICollection")` – Roman Mar 08 '16 at 08:05
@MohammadDehghan This is why you should use `nameof(ICollection)` instead. – Alexandre Daubricourt Dec 02 '17 at 16:18
Make sure you use `nameof(System.Collections.IEnumerable)`, in my case I have a reference to `using System.Collections.Generic;` and it was a confusion with `System.Collections.Generic.IEnumerable`. – Jaider Jun 01 '18 at 18:41
Be careful with this, as string also implements IEnumerable – Igneous01 Feb 07 '19 at 00:57
Using nameof will enforce you to provide the generic type argument too, instead you can use .GetInterface("IEnumerable") – Vahid Farahmandian Feb 16 '19 at 10:58
This returns true for String type :O – Rahul May 08 '19 at 20:14

score 4 · Answer 2 · answered Jun 02 '12 at 17:54

You can use this helper method to check if a type implements an open generic interface. In your case you can use DoesTypeSupportInterface(type, typeof(Collection<>))

public static bool DoesTypeSupportInterface(Type type,Type inter)
{
    if(inter.IsAssignableFrom(type))
        return true;
    if(type.GetInterfaces().Any(i=>i. IsGenericType && i.GetGenericTypeDefinition()==inter))
        return true;
    return false;
}

Or you can simply check for the non generic IEnumerable. All collection interfaces inherit from it. But I wouldn't call any type that implements IEnumerable a collection.

Or use the solution [found here](http://stackoverflow.com/a/1075059/122781) which works for generic types in addition to generic interfaces. — HappyNomad, Sep 21 '13 at 23:50

score 1 · Answer 3 · edited Sep 25 '15 at 19:50

1

You can use linq, search for an interface name like

yourobject.GetType().GetInterfaces().Where(s => s.Name == "IEnumerable")

If this has values is a instance of IEnumerable.

edited Sep 25 '15 at 19:50

Jones

1,480
19
34

answered Sep 25 '15 at 19:18

salvador

19
1

4

So does string leading to a false positive – War Oct 24 '16 at 13:23
String is a character collection, so it's not a false positive. Maybe it's not what you are looking for – edc65 Jul 19 '19 at 09:12

score 1 · Answer 4 · answered May 18 '21 at 08:27

This solution will take care of ICollection and ICollection<T>.

    static bool IsCollectionType(Type type)
    {
        return type.GetInterfaces().Any(s => s.Namespace == "System.Collections.Generic" && (s.Name == "ICollection" || s.Name.StartsWith("ICollection`")));
    }

score 0 · Answer 5 · edited Jul 06 '22 at 03:36

0

This work for me.

private static bool IsCollectionType(Type type)
{
    return type.GetInterfaces().Any(s => s.Namespace == "System.Collections.Generic" && (s.Name == "IEnumerable" || s.Name.StartsWith("IEnumerable`")));
}

edited Jul 06 '22 at 03:36

Henry Ecker

34,399
18
41
57

answered Jul 06 '22 at 03:29

Fantasmita

1
1

How to determine if a type is a type of collection?

5 Answers5

Linked