Wie erhalten Sie dieses Beispiel, in dem Delegaten die Lambda-Syntax als Parameter übergeben?

Question

Ich versuche, mein eigenes verständlich Beispiel dafür, was das Verfahren RelayCommand tut im folgenden Code zu machen:

return new RelayCommand(p => MessageBox.Show("It worked.")); 

der Konstruktor ist dies:

public RelayCommand(Action<object> execute, Predicate<object> canExecute) 
{ 
    if (execute == null) 
     throw new ArgumentNullException("execute"); 

    _execute = execute; 
    _canExecute = canExecute; 
} 

In my last question Jon Skeet mich darauf in die richtige Richtung, damit ich ein Beispiel (unten) bekommen konnte, das das tut, was ich wollte (übertrage einen Methodennamen wie in MessageBox.Show oben). Aber das Problem ist, um es zur Arbeit zu bringen, musste ich die ganze Lambda-Syntax (Action, Prädikat usw.) herausnehmen, was ich versuche zu verstehen.

Gibt es eine Möglichkeit, das Arbeitsbeispiel zu ändern, so dass es dieselbe Funktion ausführt, aber die Lambda-Syntax als Parameter verwendet, wie in den auskommentierten Zeilen unten?

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace TestLambda24 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      int[] numbers = { 6, 3, 7, 4, 8 }; 

      //Console.WriteLine("The addition result is {0}.", Tools.ProcessNumbers(p => Tools.AddNumbers, numbers)); 
      Console.WriteLine("The addition result is {0}.", Tools.ProcessNumbers(Tools.AddNumbers, numbers)); 

      //Console.WriteLine("The multiplication result is {0}.", Tools.ProcessNumbers(p => Tools.MultiplyNumbers, numbers)); 
      Console.WriteLine("The multiplication result is {0}.", Tools.ProcessNumbers(Tools.MultiplyNumbers, numbers)); 

      Console.ReadLine(); 
     } 
    } 

    class Tools 
    { 
     public static int ProcessNumbers(Func<int[], int> theMethod, int[] integers) 
     { 
      return theMethod(integers); 
     } 

     public static int AddNumbers(int[] numbers) 
     { 
      int result = 0; 
      foreach (int i in numbers) 
      { 
       result += i; 
      } 
      return result; 
     } 

     public static int MultiplyNumbers(int[] numbers) 
     { 
      int result = 1; 
      foreach (int i in numbers) 
      { 
       result *= i; 
      } 
      return result; 
     } 
    } 

} 

Answer 1

Nun, Sie könnte tun:

static void Main(string[] args) 
{ 
    int[] numbers = { 6, 3, 7, 4, 8 }; 

    Console.WriteLine("The addition result is {0}.", 
     Tools.ProcessNumbers(p => Tools.AddNumbers(p), numbers)); 

    Console.WriteLine("The multiplication result is {0}.", 
     Tools.ProcessNumbers(p => Tools.MultiplyNumbers(p), numbers)); 

    Console.ReadLine(); 
} 

Mit anderen Worten: "gegeben eine Reihe von Zahlen, Call AddNumbers (oder MultiplyNumbers) und im Array übergeben, und gibt das Ergebnis" .

Es ist ziemlich sinnlos, das zu tun, wenn Sie nur die Methodengruppe verwenden können.

Answer 2

Was Jon sagte (Überraschung, Überraschung!)

Der gesamte Punkt lambdas der Verwendung ist Funktionen on the fly erstellen, damit Sie sie statisch nicht erklären müssen. Zum Beispiel

Console.WriteLine("Mult value is {0}", Tools.ProcessNumbers(num => num.Aggregate(1, (i, j) => i*j), numbers));

Aggreagte() ist eine Erweiterung Methode, die (für die Überlast I verwendet wird) nimmt einen Wert an Samen und eine Funktion.

Es fängt an, das Saatgut als Akkumulator zu speichern. Dann ruft es für jedes Element in der Reihe die gegebene Funktion mit dem aktuellen Akkumulator und dem aktuellen Wert in der Reihe auf und speichert das Ergebnis im Akkumulator (um es an das nächste Element zu übergeben). Der endgültige zurückgegebene Wert wird als Gesamtergebnis zurückgegeben.

Mit anderen Worten, es tut genau die gleiche Sache wie Ihre handgerollten Versionen, außer es erlaubt Ihnen, sowohl den Anfangswert für "Ergebnis" sowie den Code innerhalb der Schleife aufgerufen werden.