Comment obtenir cet exemple d'exemple de délégués pour passer la syntaxe lambda en paramètre?

Question

Je suis en train de faire mon propre exemple compréhensible de ce que la méthode RelayCommand fait dans le code suivant:

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

le constructeur est la suivante:

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

    _execute = execute; 
    _canExecute = canExecute; 
} 

Dans my last question Jon Skeet m'a pointé dans la bonne direction afin que je puisse obtenir un exemple (ci-dessous) qui fait ce que je voulais (passer un nom de méthode comme dans MessageBox.Show ci-dessus). Mais le problème est, pour le faire fonctionner, j'ai dû supprimer toute la syntaxe lambda (Action, Prédicat, etc.), ce que j'essaie de comprendre.

Existe-t-il un moyen de modifier l'exemple de travail pour qu'il remplisse la même fonction mais utilise la syntaxe lambda comme paramètre dans les lignes commentées ci-dessous?

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

Eh bien, vous pouvez faire:

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

En d'autres termes, "étant donné un tableau de nombres, AddNumbers d'appel (ou MultiplyNumbers) et passer dans le tableau, et renvoie le résultat" .

Cela ne sert à rien de faire cela quand vous pouvez simplement utiliser le groupe de méthodes.

Answer 2

Ce que Jon a dit (surprise, surprise!)

Le point entier de l'utilisation lambdas est de créer des fonctions à la volée de sorte que vous n'avez pas à les déclarer statiquement. Par exemple,

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

Aggreagte() est une méthode d'extension que (pour la surcharge je) prend une valeur de départ et une fonction.

Il commence par enregistrer la graine comme un accumulateur. Puis, pour chaque élément de la série, il appelle la fonction donnée avec l'accumulateur de courant et la valeur courante dans la série, et stocke le résultat dans l'accumulateur (à passer à l'élément suivant). La valeur renvoyée finale est renvoyée en tant que résultat global. En d'autres termes, il fait exactement la même chose que vos versions roulées à la main, sauf qu'il vous permet de transmettre à la fois la valeur initiale de 'résultat' ainsi que le code à appeler à l'intérieur de la boucle.