web-dev-qa-db-fra.com

Déterminer si la collection est de type IEnumerable <T>

Comment déterminer si l'objet est de 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());
        }
    }
}

Sortie:

NS.1.Program+<GetInts>d__0

Si je modifie GetInts pour qu'il retourne IList, tout est OK Le résultat est le suivant:

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

Et cela retourne faux:

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>)));
        }
    }
}
c#.netlinqcollectionstypes
49
Valentin

Si vous voulez dire la collection , alors as:

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

Cependant, je suppose (d'après l'exemple) que vous avez un Type:

Object ne sera jamais "de" type IEnumerable<int> - mais il pourrait implémenter le; Je m'attendrais à ce que:

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

ferait. Si vous ne connaissez pas la T (int ci-dessus), vérifiez toutes les interfaces implémentées:

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

et appelez:

Type t = GetEnumerableType(type);

si c'est null, ce n'est pas IEnumerable<T> pour une T - sinon, cochez t.

99
Marc Gravell

Même technique que la réponse de Marc, mais 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);
        }
    }
}
14
Mark Rendle

Puisque IEnumerable <T> hérite de IEnumerable (non générique) et si vous n'avez pas besoin de savoir quand un type est juste IEnumerable et non IEnumerable <T>, vous pouvez utiliser:

if (typeof(IEnumerable).IsAssignableFrom(srcType))
13
Serge Intern

Comment déterminer si un objet est de type IEnumerable <T>?

N'hésitez pas à utiliser cette méthode d'extension générique, ultra petite et fine, pour déterminer si un objet implémente l'interface IEnumerable. Il étend le type Object pour que vous puissiez l'exécuter en utilisant n'importe quelle instance de n'importe quel objet que vous utilisez.

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

i est de type NS.1.Program+<GetInts>d__0, qui est un sous-type de IEnumerable<int>. Ainsi, vous pouvez utiliser soit

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

ou IsAssignableFrom (comme dans la réponse de Marc).

3
Heinzi

Vous pouvez utiliser le mot clé is.

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

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

Comment détecter si le type est un autre type générique devrait vous aider avec cela.

0
SwDevMan81