Równoważnik LINQ foreach dla IEnumerable <T>

Chciałbym zrobić równoważne z następującymi w LINQ, ale nie wiem, jak to zrobić:

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

Jaka jest prawdziwa składnia?

Nie ma rozszerzenia ForEach dla IEnumerable; tylko dla List<T>. Więc możesz to zrobić

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

Możesz też napisać własną metodę rozszerzenia ForEach:

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

Fredrik dostarczył poprawkę, ale warto zastanowić się, dlaczego nie ma tego w ramce. Uważam, że pomysł polega na tym, aby operatory zapytań LINQ były wolne od efektów ubocznych, pasując do rozsądnie funkcjonalnego sposobu patrzenia na świat. Oczywiście ForEach jest dokładnie odwrotny - konstrukcja oparta wyłącznie na efektach ubocznych.

Nie oznacza to, że jest to zła rzecz - wystarczy pomyśleć o filozoficznych powodach tej decyzji.

Aktualizacja 17.07.2012: Wygląda na to, że od C # 5.0 zachowanie foreachopisane poniżej zostało zmienione i „ użycie foreachzmiennej iteracyjnej w zagnieżdżonym wyrażeniu lambda nie daje już nieoczekiwanych wyników ” . Ta odpowiedź nie dotyczy C # ≥ 5.0 .

@John Skeet i wszyscy, którzy preferują słowo kluczowe foreach.

Problem z „foreach” w C # przed 5.0 polega na tym, że jest to niespójne z tym, jak działa odpowiednik „do zrozumienia” w innych językach, i z tym, jak bym się spodziewał, że zadziała (osobista opinia podana tutaj tylko dlatego, że inni wspominali o ich opinia na temat czytelności). Zobacz wszystkie pytania dotyczące „ Dostępu do zmodyfikowanego zamknięcia ”, a także „ Zamknięcia w pętli zmiennej uważanej za szkodliwą ”. Jest to „szkodliwe” tylko ze względu na sposób, w jaki „foreach” jest implementowany w języku C #.

Weź następujące przykłady, używając funkcjonalnie równoważnej metody rozszerzenia do tej z odpowiedzi @Fredrik Kalseth.

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

Przepraszamy za zbyt wymyślony przykład. Używam Observable, ponieważ zrobienie czegoś takiego nie jest zbyt dalekie. Oczywiście są lepsze sposoby na stworzenie tego, co można zaobserwować, staram się tylko wykazać, o co chodzi. Zazwyczaj kod subskrybowany do obserwowalnego jest wykonywany asynchronicznie i potencjalnie w innym wątku. Jeśli użyjesz „foreach”, może to dać bardzo dziwne i potencjalnie niedeterministyczne wyniki.

Następujący test przy użyciu metody rozszerzenia „ForEach” przechodzi pomyślnie:

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

Błąd kończy się następująco:

Oczekiwany: równoważny <0, 1, 2, 3, 4, 5, 6, 7, 8, 9> Ale był: <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()));
}

Możesz użyć FirstOrDefault()rozszerzenia, które jest dostępne dla IEnumerable<T>. Po powrocie falsez predykatu zostanie on uruchomiony dla każdego elementu, ale nie będzie miało znaczenia, że ​​tak naprawdę nie znajdzie dopasowania. Pozwoli to uniknąć ToList()kosztów ogólnych.

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

Wziąłem metodę Fredrika i zmodyfikowałem typ zwrotu.

W ten sposób metoda obsługuje odroczone wykonywanie podobnie jak inne metody LINQ.

EDYCJA: Jeśli nie było to jasne, każde użycie tej metody musi kończyć się na ToList () lub w jakikolwiek inny sposób, aby zmusić metodę do działania na kompletnym wyliczeniu. W przeciwnym razie akcja nie zostanie wykonana!

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

A oto test, który pomoże to zobaczyć:

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

Jeśli na końcu usuniesz ToList () , test zakończy się niepowodzeniem, ponieważ StringBuilder zawiera pusty ciąg. Jest tak, ponieważ żadna metoda nie wymusiła wyliczenia ForEach.

Trzymaj swoje efekty uboczne poza moim IEnumerable

Chciałbym zrobić równoważne z następującymi w LINQ, ale nie wiem, jak to zrobić:

Jak zauważyli inni tutaj i za granicą, LINQ i IEnumerablemetody powinny być wolne od skutków ubocznych.

Czy naprawdę chcesz „zrobić coś” dla każdego elementu w IEnumerable? To foreachjest najlepszy wybór. Ludzie nie są zaskoczeni, gdy pojawiają się tutaj skutki uboczne.

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

Założę się, że nie chcesz efektu ubocznego

Jednak z mojego doświadczenia wynika, że ​​działania niepożądane zwykle nie są wymagane. Najczęściej jest czekające na odkrycie proste zapytanie LINQ wraz z odpowiedzią StackOverflow.com autorstwa Jona Skeeta, Erica Lipperta lub Marca Gravella wyjaśniającą, jak zrobić to, co chcesz!

Kilka przykładów

Jeśli faktycznie agregujesz (gromadzisz) jakąś wartość, powinieneś rozważyć Aggregatemetodę rozszerzenia.

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

Być może chcesz utworzyć nowy IEnumerablez istniejących wartości.

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

A może chcesz utworzyć tabelę przeglądową:

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

Lista (kalambur nie do końca zamierzona) możliwości jest długa.

Jeśli chcesz działać jak rzuty wyliczeniowe, powinieneś dać każdy przedmiot.

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

Istnieje eksperymentalna wersja Microsoft Interaktywnych rozszerzeń do LINQ (także na NuGet , zobacz profil RxTeams, aby uzyskać więcej linków). Film na kanale 9 dobrze to wyjaśnia.

Dokumenty są dostarczane tylko w formacie XML. Uruchomiłem tę dokumentację w Sandcastle , aby była w bardziej czytelnym formacie. Rozpakuj archiwum dokumentów i poszukaj pliku index.html .

Wśród wielu innych korzyści zapewnia oczekiwaną implementację ForEach. Pozwala napisać taki kod:

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

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

Zgodnie z PLINQ (dostępne od .Net 4.0), możesz zrobić

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

zrobić równoległą pętlę foreach na IEnumerable.

Celem ForEach jest wywoływanie skutków ubocznych. IEnumerable służy do leniwego wyliczania zestawu.

Ta różnica pojęciowa jest dość widoczna, gdy się ją uwzględni.

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

Nie będzie to wykonywane, dopóki nie wykonasz „count”, „ToList ()” lub czegoś w tym stylu. Wyraźnie nie jest to, co jest wyrażone.

Powinieneś używać IEnumerable rozszerzeń do konfigurowania łańcuchów iteracji, definiowania treści według ich odpowiednich źródeł i warunków. Drzewa ekspresji są potężne i wydajne, ale powinieneś nauczyć się doceniać ich naturę. I to nie tylko do programowania wokół nich, aby zapisać kilka znaków zastępujących leniwe oceny.

Wiele osób o tym wspominało, ale musiałem to zapisać. Czy to nie jest najbardziej jasne / najbardziej czytelne?

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

Krótkie i proste (st).

Teraz mamy opcję ...

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

Oczywiście otwiera to zupełnie nową puszkę owsików.

ps (Przepraszam za czcionki, tak zdecydował system)

Jak już wskazują liczne odpowiedzi, możesz z łatwością dodać taką metodę rozszerzenia samodzielnie. Jeśli jednak nie chcesz tego robić, chociaż nie znam czegoś takiego w BCL, nadal istnieje opcja w Systemprzestrzeni nazw, jeśli masz już odniesienie do Reactive Extension (a jeśli nie masz , powinieneś mieć):

using System.Reactive.Linq;

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

Chociaż nazwy metod są nieco inne, końcowy wynik jest dokładnie tym, czego szukasz.

ForEach może być również Przykuty , wystarczy umieścić z powrotem do pileline po akcji. zachowaj płynność

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

Marzą wersja realizacji.

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: Lazy wersja używa zwrotu plastyczności, jak ten .

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

Wersja Lazy POTRZEBUJE się zmaterializować, na przykład ToList (), w przeciwnym razie nic się nie stanie. patrz poniżej świetne komentarze ToolmakerSteve.

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

W mojej bibliotece przechowuję zarówno ForEach (), jak i ForEachLazy ().

Ta abstrakcja „funkcjonalnego podejścia” przecieka przez długi czas. Nic na poziomie języka nie zapobiega skutkom ubocznym. Tak długo, jak możesz wywołać swoją lambda / delegata dla każdego elementu w kontenerze - otrzymasz zachowanie „ForEach”.

Oto na przykład jeden ze sposobów połączenia srcDictionary w destDictionary (jeśli klucz już istnieje - zastępuje)

jest to hack i nie należy go używać w żadnym kodzie produkcyjnym.

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

Zainspirowany przez Jona Skeeta, rozszerzyłem jego rozwiązanie o:

Metoda rozszerzenia:

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 ma IEnumerable<T>.ForEachi mnóstwo innych przydatnych rozszerzeń. Prawdopodobnie nie warto brać pod uwagę zależności ForEach, ale jest tam wiele przydatnych rzeczy.

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

https://github.com/morelinq/MoreLINQ

Nie zgadzam się z opinią, że metody rozszerzenia linków powinny być wolne od skutków ubocznych (nie tylko dlatego, że nie są, żaden delegat może wywoływać skutki uboczne).

Rozważ następujące:

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

To, co pokazuje przykład, to tak naprawdę rodzaj późnego wiązania, które pozwala wywołać jedną z wielu możliwych akcji mających skutki uboczne na sekwencji elementów, bez konieczności pisania dużego konstruktu przełączającego w celu zdekodowania wartości definiującej akcję i tłumaczenia do odpowiedniej metody.

Aby zachować biegłość, można zastosować taką sztuczkę:

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

W przypadku VB.NET należy użyć:

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

Jeszcze inny ForEachprzykład

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