LINQ-Äquivalent von foreach für IEnumerable <T>

Ich möchte in LINQ das Gleiche tun, aber ich kann nicht herausfinden, wie:

IEnumerable<Item> items = GetItems();
items.ForEach(i => i.DoStuff());

Was ist die wahre Syntax?

Es gibt keine ForEach-Erweiterung für IEnumerable; nur für List<T>. Also könntest du es tun

items.ToList().ForEach(i => i.DoStuff());

Alternativ können Sie auch Ihre eigene ForEach-Erweiterungsmethode schreiben:

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

Fredrik hat das Update bereitgestellt, aber es kann sich lohnen, darüber nachzudenken, warum dies zunächst nicht im Framework enthalten ist. Ich glaube, die Idee ist, dass die LINQ-Abfrageoperatoren nebenwirkungsfrei sein und zu einer einigermaßen funktionalen Sichtweise auf die Welt passen sollten. ForEach ist eindeutig genau das Gegenteil - ein Konstrukt, das ausschließlich auf Nebenwirkungen basiert.

Das heißt nicht, dass dies eine schlechte Sache ist - nur über die philosophischen Gründe für die Entscheidung nachzudenken.

Update 17.07.2012: Anscheinend wurde ab C # 5.0 das foreachunten beschriebene Verhalten geändert und " die Verwendung einer foreachIterationsvariablen in einem verschachtelten Lambda-Ausdruck führt nicht mehr zu unerwarteten Ergebnissen. " Diese Antwort gilt nicht für C # ≥ 5.0 .

@ John Skeet und alle, die das Schlüsselwort foreach bevorzugen.

Das Problem mit "foreach" in C # vor 5.0 ist, dass es nicht mit der Funktionsweise des Äquivalents "für das Verständnis" in anderen Sprachen übereinstimmt und mit der Art und Weise, wie ich es erwarten würde (persönliche Meinung hier nur, weil andere ihre erwähnt haben Meinung zur Lesbarkeit). Siehe alle Fragen zu " Zugriff auf modifizierten Abschluss " sowie " Schließen über die als schädlich geltende Schleifenvariable ". Dies ist nur "schädlich", da "foreach" in C # implementiert ist.

Nehmen Sie die folgenden Beispiele mit der funktional äquivalenten Erweiterungsmethode, die der Antwort von @Fredrik Kalseth entspricht.

public static class Enumerables
{
    public static void ForEach<T>(this IEnumerable<T> @this, Action<T> action)
    {
        foreach (T item in @this)
        {
            action(item);
        }
    }
}

Entschuldigung für das übermäßig erfundene Beispiel. Ich benutze Observable nur, weil es nicht weit hergeholt ist, so etwas zu tun. Offensichtlich gibt es bessere Möglichkeiten, dieses Beobachtbare zu schaffen. Ich versuche nur, einen Punkt zu demonstrieren. Normalerweise wird der Code, der das Observable abonniert hat, asynchron und möglicherweise in einem anderen Thread ausgeführt. Bei Verwendung von "foreach" kann dies zu sehr seltsamen und möglicherweise nicht deterministischen Ergebnissen führen.

Der folgende Test mit der Erweiterungsmethode "ForEach" besteht:

[Test]
public void ForEachExtensionWin()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                values.ForEach(value => 
                                    source.OnNext(() => value));

                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Win
    Assert.That(evaluatedObservable, 
        Is.EquivalentTo(values.ToList()));
}

Folgendes schlägt mit dem Fehler fehl:

Erwartet: entspricht <0, 1, 2, 3, 4, 5, 6, 7, 8, 9>, war aber: <9, 9, 9, 9, 9, 9, 9, 9, 9, 9>

[Test]
public void ForEachKeywordFail()
{
    //Yes, I know there is an Observable.Range.
    var values = Enumerable.Range(0, 10);

    var observable = Observable.Create<Func<int>>(source =>
                            {
                                foreach (var value in values)
                                {
                                    //If you have resharper, notice the warning
                                    source.OnNext(() => value);
                                }
                                source.OnCompleted();
                                return () => { };
                            });

    //Simulate subscribing and evaluating Funcs
    var evaluatedObservable = observable.ToEnumerable().Select(func => func()).ToList();

    //Fail
    Assert.That(evaluatedObservable, 
        Is.EquivalentTo(values.ToList()));
}

Sie können die FirstOrDefault()Erweiterung verwenden, für die verfügbar ist IEnumerable<T>. Wenn Sie falsevom Prädikat zurückkehren, wird es für jedes Element ausgeführt, es ist jedoch egal, ob es tatsächlich eine Übereinstimmung findet. Dadurch wird der ToList()Overhead vermieden.

IEnumerable<Item> items = GetItems();
items.FirstOrDefault(i => { i.DoStuff(); return false; });

Ich nahm Fredriks Methode und änderte den Rückgabetyp.

Auf diese Weise unterstützt die Methode wie andere LINQ-Methoden die verzögerte Ausführung .

BEARBEITEN: Wenn dies nicht klar war, muss jede Verwendung dieser Methode mit ToList () oder einer anderen Methode enden , um die Methode zu zwingen, an der vollständigen Aufzählung zu arbeiten. Andernfalls würde die Aktion nicht ausgeführt!

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
{
    foreach (T item in enumeration)
    {
        action(item);
        yield return item;
    }
}

Und hier ist der Test, um es zu sehen:

[Test]
public void TestDefferedExecutionOfIEnumerableForEach()
{
    IEnumerable<char> enumerable = new[] {'a', 'b', 'c'};

    var sb = new StringBuilder();

    enumerable
        .ForEach(c => sb.Append("1"))
        .ForEach(c => sb.Append("2"))
        .ToList();

    Assert.That(sb.ToString(), Is.EqualTo("121212"));
}

Wenn Sie am Ende die ToList () entfernen, schlägt der Test fehl , da der StringBuilder eine leere Zeichenfolge enthält. Dies liegt daran, dass keine Methode ForEach zur Aufzählung gezwungen hat.

Halten Sie Ihre Nebenwirkungen von meiner IEnumerable fern

Ich möchte in LINQ das Gleiche tun, aber ich kann nicht herausfinden, wie:

Wie andere hier und im Ausland darauf hingewiesen haben, LINQ undIEnumerable , wird erwartet, dass Methoden sind.

Möchten Sie wirklich mit jedem Element in der IEnumerable "etwas tun"? Dann foreachist die beste Wahl. Die Leute sind nicht überrascht, wenn hier Nebenwirkungen auftreten.

foreach (var i in items) i.DoStuff();

Ich wette, Sie wollen keine Nebenwirkung

Nach meiner Erfahrung sind Nebenwirkungen jedoch normalerweise nicht erforderlich. Meistens wartet eine einfache LINQ-Abfrage darauf, entdeckt zu werden, zusammen mit einer Antwort von Jon Skeet, Eric Lippert oder Marc Gravell auf StackOverflow.com, in der erklärt wird, wie Sie das tun, was Sie wollen!

Einige Beispiele

Wenn Sie tatsächlich nur einen Wert aggregieren (akkumulieren), sollten Sie die AggregateErweiterungsmethode in Betracht ziehen .

items.Aggregate(initial, (acc, x) => ComputeAccumulatedValue(acc, x));

Vielleicht möchten Sie IEnumerableaus den vorhandenen Werten eine neue erstellen .

items.Select(x => Transform(x));

Oder möchten Sie eine Nachschlagetabelle erstellen:

items.ToLookup(x, x => GetTheKey(x))

Die Liste (Wortspiel nicht ganz beabsichtigt) der Möglichkeiten geht weiter und weiter.

Wenn Sie wie die Aufzählung handeln wollen Rollen sollten Sie liefern jedes Element.

public static class EnumerableExtensions
{
    public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enumeration, Action<T> action)
    {
        foreach (var item in enumeration)
        {
            action(item);
            yield return item;
        }
    }
}

Es gibt eine experimentelle Version von Microsoft für interaktive Erweiterungen von LINQ (weitere Informationen zu NuGet finden Sie im Profil von RxTeams für weitere Links). Das Channel 9-Video erklärt es gut.

Die Dokumente werden nur im XML-Format bereitgestellt. Ich habe diese Dokumentation in Sandcastle ausgeführt , damit sie in einem besser lesbaren Format vorliegt. Entpacken Sie das Dokumentarchiv und suchen Sie nach index.html .

Neben vielen anderen Extras bietet es die erwartete ForEach-Implementierung. Sie können Code wie folgt schreiben:

int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8 };

numbers.ForEach(x => Console.WriteLine(x*x));

Laut PLINQ (verfügbar seit .Net 4.0) können Sie eine

IEnumerable<T>.AsParallel().ForAll() 

um eine parallele foreach-Schleife auf einem IEnumerable durchzuführen.

Der Zweck von ForEach ist es, Nebenwirkungen zu verursachen. IEnumerable dient zur verzögerten Aufzählung einer Menge.

Dieser konzeptionelle Unterschied ist deutlich sichtbar, wenn man ihn betrachtet.

SomeEnumerable.ForEach(item=>DataStore.Synchronize(item));

Dies wird erst ausgeführt, wenn Sie eine "Zählung" oder eine "ToList ()" oder etwas darauf ausführen. Es ist eindeutig nicht das, was ausgedrückt wird.

Sie sollten die IEnumerable-Erweiterungen zum Einrichten von Iterationsketten verwenden und den Inhalt anhand der jeweiligen Quellen und Bedingungen definieren. Ausdrucksbäume sind leistungsstark und effizient, aber Sie sollten lernen, ihre Natur zu schätzen. Und das nicht nur, um sie zu programmieren, um ein paar Zeichen zu speichern, die die träge Bewertung überschreiben.

Viele Leute haben es erwähnt, aber ich musste es aufschreiben. Ist das nicht am klarsten / am besten lesbar?

IEnumerable<Item> items = GetItems();
foreach (var item in items) item.DoStuff();

Kurz und einfach (st).

Jetzt haben wir die Möglichkeit ...

        ParallelOptions parallelOptions = new ParallelOptions();
        parallelOptions.MaxDegreeOfParallelism = 4;
#if DEBUG
        parallelOptions.MaxDegreeOfParallelism = 1;
#endif
        Parallel.ForEach(bookIdList, parallelOptions, bookID => UpdateStockCount(bookID));

Dies eröffnet natürlich eine ganz neue Dose Fadenwürmer.

ps (Entschuldigung für die Schriftarten, das hat das System entschieden)

Wie bereits zahlreiche Antworten zeigen, können Sie eine solche Erweiterungsmethode ganz einfach selbst hinzufügen. Wenn Sie dies jedoch nicht möchten, obwohl mir in der BCL so etwas nicht bekannt ist, gibt es im SystemNamespace immer noch eine Option , wenn Sie bereits einen Verweis auf Reactive Extension haben (und wenn Sie dies nicht tun) , du solltest haben):

using System.Reactive.Linq;

items.ToObservable().Subscribe(i => i.DoStuff());

Obwohl die Methodennamen etwas unterschiedlich sind, ist das Endergebnis genau das, wonach Sie suchen.

ForEach kann auch Chained , kurz nach der Aktion auf die pileline zurückstellen . fließend bleiben

Employees.ForEach(e=>e.Act_A)
         .ForEach(e=>e.Act_B)
         .ForEach(e=>e.Act_C);

Orders  //just for demo
    .ForEach(o=> o.EmailBuyer() )
    .ForEach(o=> o.ProcessBilling() )
    .ForEach(o=> o.ProcessShipping());


//conditional
Employees
    .ForEach(e=> {  if(e.Salary<1000) e.Raise(0.10);})
    .ForEach(e=> {  if(e.Age   >70  ) e.Retire();});

Eine eifrige Version der Implementierung.

public static IEnumerable<T> ForEach<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (T item in enu) action(item);
    return enu; // make action Chainable/Fluent
}

Edit: eine faule Version verwendet yield return, wie diese .

public static IEnumerable<T> ForEachLazy<T>(this IEnumerable<T> enu, Action<T> action)
{
    foreach (var item in enu)
    {
        action(item);
        yield return item;
    }
}

Die Lazy-Version MUSS materialisiert werden, zum Beispiel ToList (), sonst passiert nichts. siehe unten tolle Kommentare von ToolmakerSteve.

IQueryable<Product> query = Products.Where(...);
query.ForEachLazy(t => t.Price = t.Price + 1.00)
    .ToList(); //without this line, below SubmitChanges() does nothing.
SubmitChanges();

Ich behalte sowohl ForEach () als auch ForEachLazy () in meiner Bibliothek.

Diese "funktionale Herangehensweise" Abstraktion leckt große Zeit. Nichts auf der Sprachebene verhindert Nebenwirkungen. Solange Sie Ihr Lambda / Delegat für jedes Element im Container aufrufen können, erhalten Sie das Verhalten "ForEach".

Hier zum Beispiel eine Möglichkeit, srcDictionary mit destDictionary zusammenzuführen (falls der Schlüssel bereits vorhanden ist - überschreibt)

Dies ist ein Hack und sollte in keinem Produktionscode verwendet werden.

var b = srcDictionary.Select(
                             x=>
                                {
                                  destDictionary[x.Key] = x.Value;
                                  return true;
                                }
                             ).Count();

Inspiriert von Jon Skeet habe ich seine Lösung um Folgendes erweitert:

Verlängerungsmethode:

public static void Execute<TSource, TKey>(this IEnumerable<TSource> source, Action<TKey> applyBehavior, Func<TSource, TKey> keySelector)
{
    foreach (var item in source)
    {
        var target = keySelector(item);
        applyBehavior(target);
    }
}

Klient:

var jobs = new List<Job>() 
    { 
        new Job { Id = "XAML Developer" }, 
        new Job { Id = "Assassin" }, 
        new Job { Id = "Narco Trafficker" }
    };

jobs.Execute(ApplyFilter, j => j.Id);

. . .

    public void ApplyFilter(string filterId)
    {
        Debug.WriteLine(filterId);
    }

MoreLinq hat IEnumerable<T>.ForEachund eine Menge anderer nützlicher Erweiterungen. Es lohnt sich wahrscheinlich nicht, die Abhängigkeit nur für zu nehmenForEach , aber es gibt eine Menge nützlicher Dinge.

https://www.nuget.org/packages/morelinq/

https://github.com/morelinq/MoreLINQ

Ich bin mit der Vorstellung nicht einverstanden, dass Linkerweiterungsmethoden nebenwirkungsfrei sein sollten (nicht nur, weil dies nicht der Fall ist, sondern jeder Delegierte Nebenwirkungen erzielen kann).

Folgendes berücksichtigen:

   public class Element {}

   public Enum ProcessType
   {
      This = 0, That = 1, SomethingElse = 2
   }

   public class Class1
   {
      private Dictionary<ProcessType, Action<Element>> actions = 
         new Dictionary<ProcessType,Action<Element>>();

      public Class1()
      {
         actions.Add( ProcessType.This, DoThis );
         actions.Add( ProcessType.That, DoThat );
         actions.Add( ProcessType.SomethingElse, DoSomethingElse );
      }

      // Element actions:

      // This example defines 3 distict actions
      // that can be applied to individual elements,
      // But for the sake of the argument, make
      // no assumption about how many distict
      // actions there may, and that there could
      // possibly be many more.

      public void DoThis( Element element )
      {
         // Do something to element
      }

      public void DoThat( Element element )
      {
         // Do something to element
      }

      public void DoSomethingElse( Element element )
      {
         // Do something to element
      }

      public void Apply( ProcessType processType, IEnumerable<Element> elements )
      {
         Action<Element> action = null;
         if( ! actions.TryGetValue( processType, out action ) )
            throw new ArgumentException("processType");
         foreach( element in elements ) 
            action(element);
      }
   }

Was das Beispiel zeigt, ist eigentlich nur eine Art Spätbindung, mit der man eine von vielen möglichen Aktionen aufrufen kann, die Nebenwirkungen auf eine Folge von Elementen haben, ohne ein großes Schalterkonstrukt schreiben zu müssen, um den Wert zu dekodieren, der die Aktion definiert und übersetzt es in seine entsprechende Methode.

Um fließend zu bleiben, kann man einen solchen Trick anwenden:

GetItems()
    .Select(i => new Action(i.DoStuf)))
    .Aggregate((a, b) => a + b)
    .Invoke();

Für VB.NET sollten Sie Folgendes verwenden:

listVariable.ForEach(Sub(i) i.Property = "Value")

Noch ein ForEachBeispiel

public static IList<AddressEntry> MapToDomain(IList<AddressModel> addresses)
{
    var workingAddresses = new List<AddressEntry>();

    addresses.Select(a => a).ToList().ForEach(a => workingAddresses.Add(AddressModelMapper.MapToDomain(a)));

    return workingAddresses;
}