LINQ-Entsprechung von foreach für IEnumerable<T>

Question

Ich möchte das Äquivalent der folgenden in LINQ zu tun, aber ich kann nicht herausfinden, wie:

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

Was ist die richtige Syntax?

Answer 1

Angeregt durch Jon Skeet habe ich seine Lösung um die folgende erweitert:

Erweiterungsmethode:

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

Kunde:

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

Answer 2

Diese Abstraktion des "funktionalen Ansatzes" hat große Lücken. Nichts auf der Sprachebene verhindert Seiteneffekte. Solange Sie es schaffen, Ihr Lambda/Delegat für jedes Element im Container aufzurufen, erhalten Sie das "ForEach"-Verhalten.

Hier zum Beispiel eine Möglichkeit, srcDictionary in destDictionary zusammenzuführen (wenn der Schlüssel bereits existiert - ü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();

Answer 3

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

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

https://github.com/morelinq/MoreLINQ

Answer 4

Ich bin nicht einverstanden mit der Vorstellung, dass Link-Erweiterungsmethoden frei von Seiteneffekten sein sollten (nicht nur, weil sie es nicht sind, jeder Delegat kann Seiteneffekte ausführen).

Bedenken Sie Folgendes:

   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 der späten Bindung, die es erlaubt, eine von vielen möglichen Aktionen mit Seiteneffekten auf eine Folge von Elementen aufzurufen, ohne ein großes Switch-Konstrukt schreiben zu müssen, um den Wert zu dekodieren, der die Aktion definiert, und ihn in die entsprechende Methode zu übersetzen.

Answer 5

Um flüssig zu bleiben, kann man einen solchen Trick anwenden:

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