"Möglich, mehrere enumeration von IEnumerable" vs "- Parameter können deklariert werden, mit dem Basistyp"

Generell, was Sie benötigen, ist ein state-Objekt, in das Sie DRÜCKEN können die Elemente (innerhalb einer foreach-Schleife), und aus der Sie dann Ihre endgültige Ergebnis.

Den Nachteil der enumerable-LINQ-Operatoren ist, dass Sie aktiv aufzählen, die Quelle anstelle der Annahme der posten geschoben, damit Sie Ihren Anforderungen nicht gerecht werden.

Wenn Sie z.B. nur müssen die minimum-und maximum-Werte einer Sequenz von 1'000'000 integers, die Kosten $1'000 im Wert von CPU-Zeit zu Holen, Sie schreiben etwas wie dieses:

public class MinMaxAggregator
{
    private bool _any;
    private int _min;
    private int _max;

    public void OnNext(int value)
    {
        if (!_any)
        {
            _min = _max = value;
            _any = true;
        }
        else
        {
            if (value < _min) _min = value;
            if (value > _max) _max = value;
        }
    }

    public MinMax GetResult()
    {
        if (!_any) throw new InvalidOperationException("Sequence contains no elements.");
        return new MinMax(_min, _max);
    }
}

public static MinMax DoSomething(IEnumerable<int> source)
{
    var aggr = new MinMaxAggregator();
    foreach (var item in source) aggr.OnNext(item);
    return aggr.GetResult();
}

In der Tat, Sie nur re-implementiert die Logik für die Min() und Max() Operatoren. Das ist natürlich leicht, aber Sie sind nur Beispiele für beliebige komplexe Logik, die Sie sonst leicht Ausdrücken, in einem LINQish Weg.

Die Lösung kam mir auf der gestrigen Nachtwanderung: wir SCHIEBEN müssen... das ist REAKTIV! Alle die geliebten Operatoren, gibt es auch in einer reaktiven version gebaut für die push-Paradigma. Sie können miteinander verkettet werden, wie die Komplexität, die Sie brauchen, genauso wie Ihre enumerable-Pendants.

So die min - /max-Beispiel läuft darauf hinaus:

public static MinMax DoSomething(IEnumerable<int> source)
{
    //bridge over to the observable world
    var connectable = source.ToObservable(Scheduler.Immediate).Publish();
    //express the desired result there (note: connectable is observed by multiple observers)
    var combined = connectable.Min().CombineLatest(connectable.Max(), (min, max) => new MinMax(min, max));
    //subscribe
    var resultAsync = combined.GetAwaiter();
    //unload the enumerable into connectable
    connectable.Connect();
    //pick up the result
    return resultAsync.GetResult();
}

InformationsquelleAutor der Antwort tinudu

Sollten Sie wahrscheinlich eine IEnumerable<T> - und ignorieren die "mehrere Iterationen" Warnung.

Diese Meldung warnt Sie, dass, wenn Sie einen ruhigen enumerable (wie ein iterator oder eine kostspielige LINQ-Abfrage) auf Ihrer Methode, Teile der iterator ausgeführt wird, zweimal.

InformationsquelleAutor der Antwort SLaks

Gibt es eine Allgemeine Lösung, die sowohl Resharper Warnungen: die fehlende Garantie für die repeat-Fähigkeit von IEnumerable, und die Liste Basisklasse (oder potenziell teuer ToList() workaround).

Erstellen Sie eine spezialisierte Klasse, I. E "RepeatableEnumerable", Implementierung von IEnumerable, mit "GetEnumerator()" implementiert, mit der folgenden Logik Gliederung:

1. Ertrag alle Elemente, die sich bereits erhoben, so weit von der inneren Liste.

2. Wenn Sie die verpackte enumerator hat mehr Elemente,

   • Während die gewickelt enumerator bewegen kann, um das nächste Element,

     1. Holen Sie sich das aktuelle Element aus dem inneren enumerator.

     2. Fügen Sie das aktuelle Element der inneren Liste.

     3. Rendite auf das aktuelle Element

3. Markieren Sie die innere enumerator, dass Sie keine Elemente mehr.

Hinzufügen Erweiterung Methoden und entsprechende Optimierungen, wo die gewickelten parameter ist bereits wiederholbar. Resharper nicht mehr markieren Sie die angezeigten Warnungen auf den folgenden code:

public void DoSomething(IEnumerable<string> list)
{
    var repeatable = list.ToRepeatableEnumeration();
    if (repeatable.Any()) //<- no warning here anymore.
      //Further, this will read at most one item from list.  A
      //query (SQL LINQ) with a 10,000 items, returning one item per second
      //will pass this block in 1 second, unlike the ToList() solution /hack.
    {
        //...
    }

    foreach (var item in repeatable) //<- and no warning here anymore, either.
      //Further, this will read in lazy fashion.  In the 10,000 item, one 
      //per second, query scenario, this loop will process the first item immediately
      //(because it was read already for Any() above), and then proceed to
      //process one item every second.
    {
        //...
    }
}

Mit ein wenig Arbeit, können Sie auch aktivieren, RepeatableEnumerable in LazyList, eine vollständige Implementierung der IList. Das würde den Rahmen dieses spezielle problem obwohl. 🙂

UPDATE: Code-Implementierung angefordert, die in Kommentaren-nicht sicher, warum der ursprüngliche PDL war nicht genug, aber in jedem Fall, die folgenden originalgetreu implementiert den Algorithmus, den ich vorgeschlagen (Meine eigene Implementierung implementiert die vollständige IList-Schnittstelle; das ist ein bisschen über den Rahmen will ich release hier... 🙂 )

public class RepeatableEnumerable<T> : IEnumerable<T>
{
    readonly List<T> innerList;
    IEnumerator<T> innerEnumerator;

    public RepeatableEnumerable( IEnumerator<T> innerEnumerator )
    {
        this.innerList = new List<T>();
        this.innerEnumerator = innerEnumerator;
    }

    public IEnumerator<T> GetEnumerator()
    {
        //1. Yield all items already collected so far from the inner list.
        foreach( var item in innerList ) yield return item;

        //2. If the wrapped enumerator has more items
        if( innerEnumerator != null )
        {
            //2A. while the wrapped enumerator can move to the next item
            while( innerEnumerator.MoveNext() )
            {
                //1. Get the current item from the inner enumerator.
                var item = innerEnumerator.Current;
                //2. Add the current item to the inner list.
                innerList.Add( item );
                //3. Yield the current item
                yield return item;
            }

            //3. Mark the inner enumerator as having no more items.
            innerEnumerator.Dispose();
            innerEnumerator = null;
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

//Add extension methods and appropriate optimizations where the wrapped parameter is already repeatable.
public static class RepeatableEnumerableExtensions
{
    public static RepeatableEnumerable<T> ToRepeatableEnumerable<T>( this IEnumerable<T> items )
    {
        var result = ( items as RepeatableEnumerable<T> )
            ?? new RepeatableEnumerable<T>( items.GetEnumerator() );
        return result;
    }
}

InformationsquelleAutor der Antwort T.Tobler

Warum nicht:

bool any;

foreach (var item in list)
{
    any = true;
    //...
}
if(any)
{
    //...
}

Update: ich Persönlich würde nicht drastisch ändern Sie den code, um zu bekommen eine Warnung wie diese. Ich würde einfach deaktivieren Sie die Warnung und fahren auf. Die Warnung ist, dass Sie zum ändern der Allgemeinen Strömung der code um es besser zu machen; wenn Sie nicht machen den code besser (und wohl auch macht es schlimmer) Adresse die Warnung; dann den Punkt für die Warnung ausgelassen wird.

Beispiel:

//ReSharper disable PossibleMultipleEnumeration
        public void DoSomething(IEnumerable<string> list)
        {
            if (list.Any()) //<- here
            {
                //...
            }
            foreach (var item in list) //<- and here
            {
                //...
            }
        }
//ReSharper restore PossibleMultipleEnumeration

InformationsquelleAutor der Antwort Peter Ritchie

Vorsichtig sein bei der Annahme enumerables in Ihrer Methode. Die "Warnung" für den Typ ist nur ein Hinweis, die Aufzählung Warnung ist eine echte Warnung.

Jedoch in Ihrer Liste aufgezählt werden mindestens zwei mal, da Sie eine und dann eine foreach. Wenn Sie fügen Sie eine ToList() Ihren enumeration aufgezählt werden drei mal - entfernen Sie die ToList().

Ich würde vorschlagen, setzen resharpers Warnung Einstellungen für die Basis-Typ, Hinweis. So haben Sie immer noch einen Hauch (grün unterstreichen) und die Möglichkeit zu quickfix (alt+enter) und keine "Warnungen" in Ihrer Datei.

Sollten Sie darauf achten, ob die Aufzählung der IEnumerable-Schnittstelle ist eine teure Aktion, wie das laden etwas aus der Datei oder Datenbank, oder, wenn Sie eine Methode, die berechnet die Werte und nutzt Rendite. In diesem Fall tun ToList() oder ToArray() ersten laden/berechnen Sie alle Daten nur EINMAL.

InformationsquelleAutor der Antwort Zebi

Verwenden IList als Ihren parameter-Typ statt IEnumerable - Typ IEnumerable hat eine andere Semantik zur Liste in der Erwägung, dass IList hat die gleiche

IEnumerable werden könnte, basiert auf einem non-seekable stream, die ist, warum man die Warnungen

InformationsquelleAutor der Antwort Richard Blewett

Es ist etwas, das niemand gesagt hatte bevor (@Zebi). Jede() bereits wiederholt versucht, suchen Sie nach dem element. Beim Aufruf von ToList(), wird die Iteration als auch, um eine Liste zu erstellen. Die ursprüngliche Idee der Verwendung von IEnumerable wird nur Durchlaufen, alles andere provoziert eine iteration, um Sie zu führen. Sie sollten versuchen, innerhalb einer einzigen Schleife, alles tun.

Und gehören in das Ihre .Jede () - Methode.

wenn Sie übergeben eine Liste von Aktion, die in Ihrer Methode würden Sie einen Reiniger Durchlaufen einmal code

public void DoSomething(IEnumerable<string> list, params Action<string>[] actions)
{
    foreach (var item in list)
    {
        for(int i =0; i < actions.Count; i++)
        {
           actions[i](item);
        }
    }
}

InformationsquelleAutor der Antwort marcelo-ferraz