Warum gibt es in IEnumerable keine ForEach-Erweiterungsmethode?

Inspiriert von einer anderen Frage nach der fehlenden ZipFunktion:

Warum gibt es ForEachin der EnumerableKlasse keine Erweiterungsmethode ? Oder irgendwo? Die einzige Klasse, die eine ForEachMethode erhält , ist List<>. Gibt es einen Grund, warum es fehlt (Leistung)?

In der Sprache, die die meiste Zeit die Arbeit erledigt, ist bereits eine foreach-Anweisung enthalten.

Ich würde es hassen, Folgendes zu sehen:

list.ForEach( item =>
{
    item.DoSomething();
} );

Anstatt:

foreach(Item item in list)
{
     item.DoSomething();
}

Letzteres ist in den meisten Situationen klarer und leichter zu lesen , obwohl es möglicherweise etwas länger zu tippen ist.

Ich muss jedoch zugeben, dass ich meine Haltung zu diesem Thema geändert habe. Eine ForEach () - Erweiterungsmethode wäre in einigen Situationen tatsächlich nützlich.

Hier sind die Hauptunterschiede zwischen der Aussage und der Methode:

• Typprüfung: foreach wird zur Laufzeit ausgeführt, ForEach () befindet sich zur Kompilierungszeit (Big Plus!)
• Die Syntax zum Aufrufen eines Delegaten ist in der Tat viel einfacher: objects.ForEach (DoSomething);
• ForEach () könnte verkettet werden: obwohl die Bösartigkeit / Nützlichkeit eines solchen Features zur Diskussion steht.

Das sind alles großartige Punkte, die von vielen Leuten hier gemacht wurden, und ich kann sehen, warum den Leuten die Funktion fehlt. Es würde mir nichts ausmachen, wenn Microsoft in der nächsten Framework-Iteration eine Standard-ForEach-Methode hinzufügt.

ForEach-Methode wurde vor LINQ hinzugefügt. Wenn Sie die ForEach-Erweiterung hinzufügen, wird sie aufgrund von Einschränkungen der Erweiterungsmethoden niemals für List-Instanzen aufgerufen. Ich denke, der Grund, warum es nicht hinzugefügt wurde, ist, dass es nicht in bestehende eingreift.

Wenn Sie diese kleine nette Funktion jedoch wirklich vermissen, können Sie Ihre eigene Version herausbringen

public static void ForEach<T>(
    this IEnumerable<T> source,
    Action<T> action)
{
    foreach (T element in source) 
        action(element);
}

Sie könnten diese Erweiterungsmethode schreiben:

// Possibly call this "Do"
IEnumerable<T> Apply<T> (this IEnumerable<T> source, Action<T> action)
{
    foreach (var e in source)
    {
        action(e);
        yield return e;
    }
}

Vorteile

Ermöglicht Verkettung:

MySequence
    .Apply(...)
    .Apply(...)
    .Apply(...);

Nachteile

Es wird eigentlich nichts tun, bis Sie etwas tun, um die Iteration zu erzwingen. Aus diesem Grund sollte es nicht aufgerufen werden .ForEach(). Sie könnten .ToList()am Ende schreiben , oder Sie könnten auch diese Erweiterungsmethode schreiben:

// possibly call this "Realize"
IEnumerable<T> Done<T> (this IEnumerable<T> source)
{
    foreach (var e in source)
    {
        // do nothing
        ;
    }

    return source;
}

Dies kann eine zu bedeutende Abweichung von den Versand-C # -Bibliotheken sein. Leser, die mit Ihren Erweiterungsmethoden nicht vertraut sind, wissen nicht, was sie mit Ihrem Code anfangen sollen.

Die Diskussion hier gibt die Antwort:

Tatsächlich hing die spezifische Diskussion, die ich miterlebte, tatsächlich von der funktionalen Reinheit ab. In einem Ausdruck werden häufig Annahmen getroffen, dass keine Nebenwirkungen auftreten. ForEach zu haben, lädt gezielt zu Nebenwirkungen ein, anstatt sie nur in Kauf zu nehmen. - Keith Farmer (Partner)

Grundsätzlich wurde die Entscheidung getroffen, die Erweiterungsmethoden funktional "rein" zu halten. Ein ForEach würde bei Verwendung der Enumerable-Erweiterungsmethoden zu Nebenwirkungen führen, was nicht beabsichtigt war.

Obwohl ich der Meinung bin, dass es foreachin den meisten Fällen besser ist, das integrierte Konstrukt zu verwenden, finde ich die Verwendung dieser Variante der ForEach <> -Erweiterung etwas netter, als den Index foreachselbst regelmäßig verwalten zu müssen :

public static int ForEach<T>(this IEnumerable<T> list, Action<int, T> action)
{
    if (action == null) throw new ArgumentNullException("action");

    var index = 0;

    foreach (var elem in list)
        action(index++, elem);

    return index;
}

var people = new[] { "Moe", "Curly", "Larry" };
people.ForEach((i, p) => Console.WriteLine("Person #{0} is {1}", i, p));

Würde dir geben:

Person #0 is Moe
Person #1 is Curly
Person #2 is Larry

Eine Problemumgehung ist das Schreiben .ToList().ForEach(x => ...).

Profis

Einfach zu verstehen - der Leser muss nur wissen, was mit C # geliefert wird, keine zusätzlichen Erweiterungsmethoden.

Syntaktisches Rauschen ist sehr mild (fügt nur ein wenig extranious Code hinzu).

Kostet normalerweise keinen zusätzlichen Speicher, da ein Eingeborener .ForEach()sowieso die gesamte Sammlung realisieren müsste.

Nachteile

Die Reihenfolge der Operationen ist nicht ideal. Ich würde lieber ein Element erkennen, dann darauf reagieren und es dann wiederholen. Dieser Code realisiert zuerst alle Elemente und wirkt dann nacheinander auf sie ein.

Wenn das Realisieren der Liste eine Ausnahme auslöst, können Sie niemals auf ein einzelnes Element einwirken.

Wenn die Aufzählung unendlich ist (wie die natürlichen Zahlen), haben Sie kein Glück.

Ich habe mich immer gefragt, warum ich das immer bei mir habe:

public static void ForEach<T>(this IEnumerable<T> col, Action<T> action)
{
    if (action == null)
    {
        throw new ArgumentNullException("action");
    }
    foreach (var item in col)
    {
        action(item);
    }
}

Schöne kleine Verlängerungsmethode.

Daher gab es viele Kommentare dazu, dass eine ForEach-Erweiterungsmethode nicht geeignet ist, da sie keinen Wert wie die LINQ-Erweiterungsmethoden zurückgibt. Dies ist zwar eine sachliche Aussage, aber nicht ganz richtig.

Die LINQ-Erweiterungsmethoden geben alle einen Wert zurück, damit sie miteinander verkettet werden können:

collection.Where(i => i.Name = "hello").Select(i => i.FullName);

Nur weil LINQ mithilfe von Erweiterungsmethoden implementiert wird, bedeutet dies nicht, dass Erweiterungsmethoden erforderlich sind in gleicher Weise und liefern einen Wert verwendet werden. Das Schreiben einer Erweiterungsmethode zum Offenlegen allgemeiner Funktionen, die keinen Wert zurückgeben, ist eine absolut gültige Verwendung.

Das spezifische Argument für ForEach ist, dass es basierend auf den Einschränkungen für Erweiterungsmethoden (nämlich dass eine Erweiterungsmethode niemals eine geerbte Methode mit derselben Signatur überschreibt ) eine Situation geben kann, in der die benutzerdefinierte Erweiterungsmethode für alle Klassen verfügbar ist, die impelement verwenden IEnumerable <T> außer List <T>. Dies kann zu Verwirrung führen, wenn sich die Methoden unterschiedlich verhalten, je nachdem, ob die Erweiterungsmethode oder die Vererbungsmethode aufgerufen wird.

Sie können das (verkettbar, aber träge ausgewertet) verwenden Select, indem Sie zuerst Ihre Operation ausführen und dann die Identität zurückgeben (oder etwas anderes, wenn Sie es vorziehen).

IEnumerable<string> people = new List<string>(){"alica", "bob", "john", "pete"};
people.Select(p => { Console.WriteLine(p); return p; });

Sie müssen sicherstellen, dass es immer noch ausgewertet wird, entweder mit Count()(der billigsten Operation zum Aufzählen von afaik) oder einer anderen Operation, die Sie sowieso benötigen.

Ich würde es gerne in der Standardbibliothek sehen:

static IEnumerable<T> WithLazySideEffect(this IEnumerable<T> src, Action<T> action) {
  return src.Select(i => { action(i); return i; } );
}

Der obige Code wird dann people.WithLazySideEffect(p => Console.WriteLine(p))effektiv zu foreach, aber faul und verkettbar.

Beachten Sie, dass MoreLINQ NuGet die gesuchteForEach Erweiterungsmethode bereitstellt (sowie eine PipeMethode, die den Delegaten ausführt und dessen Ergebnis liefert). Sehen:

• https://www.nuget.org/packages/morelinq
• https://code.google.com/p/morelinq/wiki/OperatorsOverview

@Coincoin

Die wahre Stärke der foreach-Erweiterungsmethode besteht in der Wiederverwendbarkeit der, Action<>ohne unnötige Methoden zu Ihrem Code hinzuzufügen. Angenommen, Sie haben 10 Listen und möchten dieselbe Logik für sie ausführen, und eine entsprechende Funktion passt nicht in Ihre Klasse und wird nicht wiederverwendet. Anstatt zehn for-Schleifen oder eine generische Funktion zu haben, die offensichtlich ein Helfer ist, der nicht dazu gehört, können Sie Ihre gesamte Logik an einem Ort aufbewahren ( Action<>also werden Dutzende von Zeilen durch ersetzt

Action<blah,blah> f = { foo };

List1.ForEach(p => f(p))
List2.ForEach(p => f(p))

usw...

Die Logik befindet sich an einem Ort und Sie haben Ihre Klasse nicht verschmutzt.

Die meisten LINQ-Erweiterungsmethoden geben Ergebnisse zurück. ForEach passt nicht in dieses Muster, da es nichts zurückgibt.

Wenn Sie F # haben (das in der nächsten Version von .NET enthalten sein wird), können Sie verwenden

Seq.iter doSomething myIEnumerable

Teilweise liegt es daran, dass die Sprachdesigner aus philosophischer Sicht nicht damit einverstanden sind.

• Keine Funktion zu haben (und zu testen ...) ist weniger Arbeit als eine Funktion zu haben.
• Es ist nicht wirklich kürzer (es gibt einige Fälle, in denen es vorübergehende Funktionen gibt, aber das wäre nicht die primäre Verwendung).
• Es ist das Ziel, Nebenwirkungen zu haben, worum es bei linq nicht geht.
• Warum haben wir eine andere Möglichkeit, dasselbe zu tun wie eine Funktion, die wir bereits haben? (foreach Schlüsselwort)

https://blogs.msdn.microsoft.com/ericlippert/2009/05/18/foreach-vs-foreach/

Sie können select verwenden, wenn Sie etwas zurückgeben möchten. Wenn Sie dies nicht tun, können Sie zuerst ToList verwenden, da Sie wahrscheinlich nichts in der Sammlung ändern möchten.

Ich habe einen Blog-Beitrag darüber geschrieben: http://blogs.msdn.com/kirillosenkov/archive/2009/01/31/foreach.aspx

Sie können hier abstimmen, wenn Sie diese Methode in .NET 4.0 sehen möchten : http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=279093

In 3.5 sind alle zu IEnumerable hinzugefügten Erweiterungsmethoden für die LINQ-Unterstützung vorhanden (beachten Sie, dass sie in der System.Linq.Enumerable-Klasse definiert sind). In diesem Beitrag erkläre ich, warum foreach nicht zu LINQ gehört: Vorhandene LINQ-Erweiterungsmethode ähnlich wie Parallel.For?

Bin ich es oder ist die Liste <T> .Foreach wurde von Linq so ziemlich obsolet gemacht. Ursprünglich gab es

foreach(X x in Y) 

Dabei musste Y einfach IEnumerable (Pre 2.0) sein und einen GetEnumerator () implementieren. Wenn Sie sich die generierte MSIL ansehen, sehen Sie, dass sie genau dieselbe ist wie

IEnumerator<int> enumerator = list.GetEnumerator();
while (enumerator.MoveNext())
{
    int i = enumerator.Current;

    Console.WriteLine(i);
}

(Siehe http://alski.net/post/0a-for-foreach-forFirst-forLast0a-0a-.aspx für die MSIL)

Dann kamen in DotNet2.0 Generics und die Liste. Foreach war für mich immer eine Implementierung des Vistor-Musters (siehe Design Patterns von Gamma, Helm, Johnson, Vlissides).

Jetzt können wir in 3.5 natürlich stattdessen ein Lambda mit dem gleichen Effekt verwenden. Beispiel: http://dotnet-developments.blogs.techtarget.com/2008/09/02/iterators-lambda-and-linq-oh- meine/

Ich möchte Akus Antwort erweitern .

Wenn Sie eine Methode nur zum Zweck ihrer Nebenwirkung aufrufen möchten, ohne zuerst die gesamte Aufzählung zu iterieren, können Sie Folgendes verwenden:

private static IEnumerable<T> ForEach<T>(IEnumerable<T> xs, Action<T> f) {
    foreach (var x in xs) {
        f(x); yield return x;
    }
}

Bisher hat noch niemand darauf hingewiesen, dass ForEach <T> zu einer Überprüfung des Typs der Kompilierungszeit führt, bei der das Schlüsselwort foreach zur Laufzeit überprüft wird.

Nachdem ich einige Umgestaltungen vorgenommen habe, bei denen beide Methoden im Code verwendet wurden, bevorzuge ich .ForEach, da ich Testfehler / Laufzeitfehler suchen musste, um die foreach-Probleme zu finden.