La manipulation de l'avertissement d'une possible plusieurs énumération de IEnumerable

Dans mon code dans le besoin d'utiliser un IEnumerable<> plusieurs fois ainsi obtenir la Resharper erreur de "multiples énumération de IEnumerable".

Exemple de code:

public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null || !objects.Any())
        throw new ArgumentException();

    var firstObject = objects.First();
    var list = DoSomeThing(firstObject);        
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}
  • Je peux changer le objects paramètre à List et puis éviter les multiples énumération, mais alors je ne comprends pas la plus haute de l'objet que je peux gérer.
  • Une autre chose que je peux faire est de convertir le IEnumerable à List au début de la méthode: 
 public List<object> Foo(IEnumerable<object> objects)
 {
    var objectList = objects.ToList();
    //...
 }

Mais c'est juste maladroit.

Que feriez-vous dans ce scénario?

InformationsquelleAutor gdoron is supporting Monica | 2011-11-23
  1. 455

    Le problème avec la prise IEnumerable comme un paramètre, c'est qu'il indique appelants "je tiens à énumérer ce". Il ne dit pas quel est le nombre de fois que vous le souhaitez à énumérer.

    Je peut changer les objets en paramètre à la Liste et puis éviter les multiples énumération, mais ensuite je n'ai pas le plus élevé de l'objet que je peux gérer.

    L'objectif de la prise la plus haute de l'objet est noble, mais il laisse de la place pour un trop grand nombre d'hypothèses. Voulez-vous vraiment quelqu'un pour passer un LINQ to SQL de la requête à cette méthode, seulement pour vous les énumérer deux fois (potentiellement des résultats différents à chaque fois?)

    La sémantique qui manque ici, c'est que l'appelant, qui n'a peut-être pas prendre le temps de lire les détails de la méthode, peuvent supposer que vous seulement itérer une fois, de sorte qu'ils vous passent un cher objet. Votre signature de la méthode n'indique pas de toute façon.

    Par la modification de la signature de la méthode de IList/ICollection, vous aurez au moins le rendre plus clair pour l'appelant quelles sont vos attentes, et ils peuvent éviter des erreurs coûteuses.

    Sinon, la plupart des développeurs à la recherche à la méthode pourrait supposer que vous ne itérer une fois. Si vous prenez un IEnumerable est si important, vous devriez envisager de le faire la .ToList() au début de la méthode.

    C'est une honte .NET ne dispose pas d'une interface IEnumerable + Count + Indexeur, sans Ajouter/Supprimer etc. les méthodes, ce qui est ce que je soupçonne, il permettrait de résoudre ce problème.

    • Ne ReadOnlyCollection<T> répondre à votre interface exigences? msdn.microsoft.com/en-us/library/ms132474.aspx
    • Je dirais IReadOnlyCollection(T) (de nouveaux avec de .net 4.5) comme la meilleure interface pour transmettre l'idée que c'est un IEnumerable(T) qui est destiné à être énuméré plusieurs fois. Comme cette réponse unis, IEnumerable(T) lui-même est tellement générique qu'il peut même se référer à l'onu-resetable contenu qui ne peuvent être énumérées plus de nouveau sans effets secondaires. Mais IReadOnlyCollection(T) implique de re-iterability.
    • Si vous ne le .ToList() au début de la méthode, vous devez d'abord vérifier si le paramètre n'est pas null. Cela signifie que vous obtiendrez deux endroits où vous jetez un ArgumentException: si le paramètre est null, et si elle n'a pas tous les éléments.
    • J'ai lu cet article sur la sémantique de IReadOnlyCollection<T> vs IEnumerable<T> et puis publié en ligne question sur l'utilisation de IReadOnlyCollection<T> comme paramètre, et dans quels cas. Je pense que le conclusion je suis finalement arrivé à la logique à suivre. Qu'il doit être utilisé lorsque l'énumération est attendu, pas forcément là où il pourrait y avoir plusieurs énumération.
    InformationsquelleAutor Paul Stovell
  2. 30

    Si vos données est toujours va être reproductible, peut-être ne vous inquiétez pas à ce sujet. Cependant, vous pouvez dérouler trop - ce qui est particulièrement utile si les données entrantes pourrait être de grande taille (par exemple, la lecture à partir du disque/réseau):

    if(objects == null) throw new ArgumentException();
using(var iter = objects.GetEnumerator()) {
    if(!iter.MoveNext()) throw new ArgumentException();

    var firstObject = iter.Current;
    var list = DoSomeThing(firstObject);  

    while(iter.MoveNext()) {
        list.Add(DoSomeThingElse(iter.Current));
    }
    return list;
}

    Remarque j'ai changé la sémantique de DoSomethingElse un peu, mais c'est surtout pour montrer déroulé d'utilisation. Vous pourriez re-wrap l'itérateur, par exemple. Vous pourriez faire un itérateur bloc de trop, ce qui pourrait être sympa; alors il n'y a pas de list - et vous yield return les éléments que vous les obtenez, plutôt que de l'ajouter à une liste à renvoyer.

    • +1 Bien que c'est un très joli code, mais je lâche la joliesse et la lisibilité du code.
    • tout n'est pas assez ;p je n'ai pas la le ci-dessus est illisible, bien que. Surtout si elle est faite dans un itérateur bloc - tout à fait mignon, de l'OMI.
    • Je peux juste écrire: "var objectList = objets.ToList();" et enregistrer toutes les Énumérateur de la manipulation.
    • dans la question que vous avez explicitement dit que vous n'avez pas vraiment envie de le faire ;p Aussi, un ToList() est une approche qui peut ne pas convenir si les données si elles sont très grandes (potentiellement infini de séquences n'ont pas besoin d'être finis, mais peut encore être itérée). En fin de compte, je suis juste de présenter une option. Seulement, vous savez le contexte complet pour voir si elle est justifiée. Si vos données sont reproductibles, une autre option valable est: ne changez rien! Ignorer R# à la place... tout dépend du contexte.
    • Je pense que Marc solution est très agréable. 1. Il est très évident que la "liste" est initialisé, il est très clair que la liste est itérée, et il est très clair qui les membres de la liste sont opérés.
    InformationsquelleAutor Marc Gravell
  3. 6

    À l'aide de IReadOnlyCollection<T> ou IReadOnlyList<T> dans la signature de la méthode au lieu de IEnumerable<T>, a l'avantage de rendre plus explicite le fait que vous pourriez avoir besoin de vérifier le décompte avant l'itération, ou pour itérer plusieurs fois pour une autre raison.

    Cependant, ils ont un énorme inconvénient qui peut poser des problèmes si vous essayez de revoir votre code pour utiliser les interfaces, par exemple pour le rendre plus testable et convivial à la dynamique de l'utilisation de proxy. Le point clé est que IList<T> n'hérite pas de IReadOnlyList<T>, et de même pour les autres collections et de leur lecture seule interfaces. (En bref, c'est parce que .NET 4.5 voulais garder ABI compatibilité avec les versions antérieures. Mais ils ne prennent même pas la possibilité de changer cela dans .NET de base.)

    Cela signifie que si vous obtenez une IList<T> d'une partie du programme et que vous souhaitez passer à une autre partie qui s'attend à une IReadOnlyList<T>, vous ne pouvez pas! Cependant, vous pouvez transmettre un IList<T> comme un IEnumerable<T>.

    En fin de compte, IEnumerable<T> est la seule lecture seule interface pris en charge par tous .NET des collections y compris la collection de toutes les interfaces. Toute autre alternative va revenir à vous mordre que vous vous rendez compte que vous avez verrouillé vous-même hors de certains choix de l'architecture. Donc, je pense que c'est le bon type à utiliser dans les signatures de la fonction d'exprimer que vous voulez juste une collection en lecture seule.

    (Notez que vous pouvez toujours écrire un IReadOnlyList<T> ToReadOnly<T>(this IList<T> list) méthode d'extension simple jette si le type sous-jacent prend en charge les deux interfaces, mais vous devez l'ajouter manuellement partout lors d'un refactoring, où que IEnumerable<T> est toujours compatibles.)

    Comme toujours, ce n'est pas un absolu, si vous êtes à l'écriture de la base de données-lourds de code où les multiples énumération serait une catastrophe, vous pourriez préférer un autre compromis.

    • +1 Pour venir sur un vieux post et ajouter de la documentation sur les nouvelles façons de résoudre ce problème avec les nouvelles fonctionnalités fournies par l' .NET plate-forme (c'est à dire IReadOnlyCollection<T>)
    InformationsquelleAutor Gabriel Morin
  4. 4

    Si le but est vraiment d'éviter que plusieurs énumérations que la réponse de Marc Gravel est le seul à lire, mais en conservant la même sémantique que vous pourriez simple de supprimer la redondant Any et First appels et aller avec:

    public List<object> Foo(IEnumerable<object> objects)
{
    if (objects == null)
        throw new ArgumentNullException("objects");

    var first = objects.FirstOrDefault();

    if (first == null)
        throw new ArgumentException(
            "Empty enumerable not supported.", 
            "objects");

    var list = DoSomeThing(first);  

    var secondList = DoSomeThingElse(objects);

    list.AddRange(secondList);

    return list;
}

    Remarque, que cela suppose que vous IEnumerable n'est pas générique ou, au moins, est contraint d'être un type de référence.

    • objects est encore passé à DoSomethingElse qui est de retour d'une liste, de sorte que la possibilité que vous êtes toujours à l'énumération deux fois est toujours là. De toute façon si la collection a été un LINQ to SQL de la requête, vous a frappé le DB deux fois.
    • Lire ceci: "Si le but est vraiment d'éviter que plusieurs énumérations que la réponse de Marc Gravel est le seul à lire" =)
    • Il a été suggéré sur un autre stackoverflow postes de lancer des exceptions pour vider les listes et je vais le suggérer ici: pourquoi jeter une exception sur une liste vide? Obtenir une liste vide, donner une liste vide. Comme un paradigme, c'est assez simple. Si l'appelant ne savent pas qu'ils sont de passage la liste est vide, c'est là le problème.
    • Hoffman, l'exemple de code maintient le même comportement que le code de l'OP posté, où l'utilisation de First va lever une exception si la liste est vide. Je ne pense pas qu'il est possible de dire de ne jamais jeter d'exception sur la liste vide ou toujours jeter l'exception sur la liste est vide. Ça dépend...
    • Juste assez de Joao. Plus de la nourriture pour la pensée qu'à une critique de votre post.
    InformationsquelleAutor João Angelo
  5. 3

    J'ai l'habitude de surcharger ma méthode avec IEnumerable et IList dans cette situation. 

    public static IEnumerable<T> Method<T>( this IList<T> source ){... }

public static IEnumerable<T> Method<T>( this IEnumerable<T> source )
{
    /*input checks on source parameter here*/
    return Method( source.ToList() );
}

    Je prends soin d'expliquer dans le résumé des commentaires des méthodes que l'appel de IEnumerable effectuera une .ToList().

    Le programmeur peut choisir de .ToList() à un niveau plus élevé si plusieurs opérations sont concaténés et ensuite appeler le IList de surcharge ou de laisser mon IEnumerable surcharge de prendre soin de cela.

    • C'est horrible.
    • Ouais, c'est vraiment horrible et parfaitement propre en même temps. Malheureusement, certains gros scénarios besoin de cette approche.
    • Mais alors vous recréer le tableau à chaque fois que vous passer à la IEnumerable parameratized méthode. Je suis d'accord avec @MikeChamberlain à cet égard, c'est un terrible suggestion.
    • Si vous n'avez pas besoin de la liste à être recréé, vous effectuez une ToList quelque part ailleurs et le IList de surcharge. C'est le point de cette solution.
    InformationsquelleAutor Mauro Sampietro
  6. 0

    Si vous avez uniquement besoin de vérifier le premier élément que vous pouvez coup d'oeil sur elle sans une itération à l'ensemble de la collection:

    public List<object> Foo(IEnumerable<object> objects)
{
    object firstObject;
    if (objects == null || !TryPeek(ref objects, out firstObject))
        throw new ArgumentException();

    var list = DoSomeThing(firstObject);
    var secondList = DoSomeThingElse(objects);
    list.AddRange(secondList);

    return list;
}

public static bool TryPeek<T>(ref IEnumerable<T> source, out T first)
{
    if (source == null)
        throw new ArgumentNullException(nameof(source));

    IEnumerator<T> enumerator = source.GetEnumerator();
    if (!enumerator.MoveNext())
    {
        first = default(T);
        source = Enumerable.Empty<T>();
        return false;
    }

    first = enumerator.Current;
    T firstElement = first;
    source = Iterate();
    return true;

    IEnumerable<T> Iterate()
    {
        yield return firstElement;
        using (enumerator)
        {
            while (enumerator.MoveNext())
            {
                yield return enumerator.Current;
            }
        }
    }
}
    InformationsquelleAutor Madruel
  7. -3

    Tout d'abord, cet avertissement ne signifie pas toujours beaucoup. J'ai l'habitude de désactivé après que vous assurer que ce n'est pas une performance goulot de bouteille. Il veut simplement dire que l' IEnumerable est évalué deux fois, ce qui n'est généralement pas un problème, sauf si le evaluation lui-même prend beaucoup de temps. Même si cela prend du temps, dans ce cas, votre seulement en utilisant un élément de la première fois autour.

    Dans ce scénario, vous pourrait aussi exploiter la puissante extension linq méthodes encore plus.

    var firstObject = objects.First();
return DoSomeThing(firstObject).Concat(DoSomeThingElse(objects).ToList();

    Il est possible d'évaluer les IEnumerable une fois, dans ce cas, avec quelques soucis, mais le profil de la première et de voir si c'est vraiment un problème.

    • Je travaille beaucoup avec IQueryable et le tournage de ce genre d'avertissements est très dangereux.
    • L'évaluation de deux fois, c'est une mauvaise chose dans mes livres. Si la méthode prend IEnumerable, j'ai peut-être tentés de passer une LINQ to SQL de la requête, ce qui se traduit par de multiples DB appels. Depuis la signature de la méthode n'indique pas qu'il peut énumérer deux fois, il est nécessaire de changer la signature (accepter IList/ICollection) ou seulement itérer une fois
    • l'optimisation de début et de ruiner la lisibilité et donc la possibilité de faire des optimisations faire une diffrence plus tard est encore pire dans mon livre.
    • Lorsque vous avez une requête de base de données, assurez-vous qu'elle est seulement évaluée une fois déjà fait une différence. Ce n'est pas seulement théorique, d'avantages sociaux futurs, c'est un mesurables réel avantage maintenant. Non seulement cela, évaluer une seule fois n'est pas seulement bénéfique pour la performance, il est également nécessaire pour l'exactitude. L'exécution d'une requête de base de données deux fois peut produire des résultats différents, comme quelqu'un l'a émis une commande de mise à jour entre les deux requêtes évaluations.
    • Je ne recommande pas une telle chose. Bien sûr, vous ne devriez pas vous énumérer IEnumerables qui donne des résultats différents à chaque fois que vous la répéter ou prendre un temps très long pour itérer. Voir Marc Gravells réponse - Il également de l'état d'abord et avant tout "peut-être ne vous inquiétez pas". La chose est Beaucoup de la fois que vous voyez cela, vous n'avez rien à craindre.
    • Je n'ai lu Marc Gravel réponse déjà. 🙂 Il commence ainsi: "Si vos données est toujours va être répétable", qui est une distinction importante à faire, et que vous ne faites pas dans votre réponse. Si les données sont toujours va être reproductible, j'avais effectivement aller pour le haut-voté et accepté de répondre et simplement utiliser ICollection<T> (ou peut-être la nouvelle IReadOnlyCollection<T>), à quel point il devient plus sûr de supposer que ce n'est pas un paresseusement évalué énumérable. Si ce n'est pas la garantie d'être reproductible, j'irais pour Marc Gravel de l'approche de l'orthographe les GetEnumerator/MoveNext/Current accès.
    • Vous êtes toujours l'énumération deux fois ici.

    InformationsquelleAutor vidstige