Comment faire pour déterminer si un type est un type de collection?

Je suis en train d'essayer de déterminer si un runtime type est une sorte de type de collection. Ce que j'ai ci-dessous fonctionne, mais il semble étrange que j'ai pour nom les types que je crois être les types de collection dans un tableau comme je l'ai fait.

Dans le code ci-dessous, la raison pour le générique de la logique en est que, dans mon application, je m'attends à toutes les collections génériques.

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));
}

Comment aurais-je refactoriser ce code pour être plus intelligent ou plus simple?

  • Une chose à garder à l'esprit est que vous n'avez généralement pas envisager de string comme une collection de chars, même si elle met en œuvre IEnumerable<char>.
InformationsquelleAutor Byron Sommardahl | 2012-06-02
  1. 73

    Vraiment tous ces types héritent (IEnumerable. Vous pouvez vérifier que:

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

    ou si vous avez vraiment besoin de vérifier pour ICollection:

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

    Regardez la "Syntaxe" de la partie:

    • Haha. C'était vraiment aussi simple QUE cela. Pour une raison que je pensais que ça ne marcherait pas et je ne l'ai pas essayé.
    • Hiérarchie d'héritage dans la doc ne dit pas mis en œuvre les interfaces. Mais en regardant la section Syntaxe de la volonté.
    • Qu'en public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable ?
    • c'est exactement ce que je voulais dire, mais ce n'est pas dans la Hiérarchie d'Héritage de la section.
    • J'ai tendance à réfléchir à des problèmes simples ainsi 😉
    • La vérification de IEnumerable a le problème d'une mauvaise interprétation de string comme une collection. Ce n'est pas souhaitable, la plupart du temps.
    • Ne fonctionne pas pour moi du tout. ICollection<CPerson> retourné null sur type.GetInterface("ICollection") et sur type.GetInterface("System.Collections.Generic.ICollection")
    • C'est pourquoi vous devez utiliser nameof(ICollection) à la place.
    • Assurez-vous d'utiliser nameof(System.Collections.IEnumerable), dans mon cas, j'ai une référence à using System.Collections.Generic; et c'était une confusion avec System.Collections.Generic.IEnumerable<T>.
    • Soyez prudent avec cela, comme une chaîne de caractères aussi implémentant IEnumerable
    • À l'aide de nameof va appliquer afin de vous fournir l'argument de type générique aussi, au lieu de cela, vous pouvez utiliser .GetInterface("IEnumerable")
    • Elle renvoie true (vrai pour le type de Chaîne :O

    InformationsquelleAutor Ruben
  2. 3

    Je sais que ce fil est vieux, mais ici est un exemple moderne au 20 juillet 2015, selon Microsoft est mot-clé.

    if(collection is ICollection) return true;
    • La question est de savoir comment déterminer si un type est un ensemble, pas une instance d'objet.
    InformationsquelleAutor Jeffrey Ferreiras
  3. 2

    Vous pouvez utiliser cette méthode d'aide à vérifier si un type implémente une ouverture d'interface générique. Dans votre cas, vous pouvez utiliser 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;
}

    Ou vous pouvez vérifier simplement la non générique IEnumerable. Collection de toutes les interfaces hériter d'elle. Mais je ne voudrais pas appeler n'importe quel type qui implémente IEnumerable une collection.

    • Ou utiliser la solution de trouvé ici, qui travaille pour les types génériques en plus à des interfaces génériques.
    InformationsquelleAutor CodesInChaos
  4. 1

    Tous hériter IEnumerable(), ce qui signifie vérifier son là devrait être suffisant:

    • Donc n'chaîne menant à un faux positif
    InformationsquelleAutor YavgenyP
  5. 1

    Vous pouvez utiliser linq, recherche pour un nom d'interface comme

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

    Si cela a des valeurs est une instance de IEnumerable.

    • Donc n'chaîne menant à un faux positif
    • Chaîne de caractères est une collection de personnages, il n'est donc pas un faux positif. C'est peut-être pas ce que vous cherchez
    InformationsquelleAutor salvador