Les opérateurs en tant que paramètres de méthode en C#

Question

Je ne pense pas qu'il soit possible d'utiliser les opérateurs comme paramètres pour les méthodes de C# 3.0, mais y a-t-il un moyen d'émuler le sucre syntaxique qui donne l'impression que c'est ce qui se passe?

Je demande parce que je a récemment mis en the thrush combinator in C# mais tout en traduisant Raganwald's Ruby example

(1..100).select(&:odd?).inject(&:+).into { |x| x * x } 

qui se lit « Prenez les chiffres de 1 à 100, garder les impairs, prendre la somme de ceux-ci, puis répondre à la carré de ce nombre. "

Je suis tombé court sur les choses Symbol#to_proc. C'est le &: dans le select(&:odd?) et le inject(&:+) ci-dessus.

Answer 1

Eh bien, en termes simples, vous pouvez simplement utiliser un lambda:

public void DoSomething(Func<int, int, int> op) 
{ 
    Console.WriteLine(op(5, 2)); 
} 

DoSomething((x, y) => x + y); 
DoSomething((x, y) => x * y); 
// etc 

Ce n'est pas très excitant cependant. Ce serait bien que tous ces délégués soient préparés pour nous. Bien sûr, vous pouvez le faire avec une classe statique:

public static class Operator<T> 
{ 
    public static readonly Func<T, T, T> Plus; 
    public static readonly Func<T, T, T> Minus; 
    // etc 

    static Operator() 
    { 
     // Build the delegates using expression trees, probably 
    } 
} 

En effet, Marc Gravell a done something very similar à MiscUtil, si vous voulez regarder. Vous pouvez ensuite appeler:

DoSomething(Operator<int>.Plus); 

Ce n'est pas exactement jolie, mais il est le plus proche qui est pris en charge pour le moment, je crois.

Je crains que je ne comprends vraiment pas les choses Ruby, donc je ne peux pas commenter ça ...

Answer 2

Ce qui suit est directe, littérale (autant que possible) Traduction C#:

(Func<int>)(x => x * x)(
    Enumerable.Range(1, 100) 
     .Where(x => x % 2 == 1) 
     .Aggregate((x, y) => x + y)) 

Plus précisément:

• blocs: {||} - devenir lambdas: =>
• select devient Where
• inject devient Aggregate
• into devient un appel direct sur une instance lambda