Operadores como parámetros de método en C#

Question

No creo que sea posible utilizar operadores como parámetros para los métodos en C# 3.0, pero ¿hay alguna manera de emular ese o algún azúcar sintáctico que parezca que eso es lo que está sucediendo?

Lo pregunto porque recientemente he implementado the thrush combinator in C# pero al traducir Raganwald's Ruby example

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

que dice "Toma los números del 1 al 100, a mantener los impares, tomar la suma de esos, y luego responder a la cuadrado de ese número ".

Me quedé corto con las cosas de Symbol#to_proc. Esa es la &: en el select(&:odd?) y el inject(&:+) anterior.

Answer 1

Bueno, en términos simples que usted puede simplemente usar una 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 

Eso no es muy interesante sin embargo. Sería bueno tener todos esos delegados preconstruidos para nosotros. Por supuesto que podría hacer esto con una clase estática:

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

De hecho, Marc Gravell tiene done something very similar en MiscUtil, si desea buscar. A continuación, puede llamar a:

DoSomething(Operator<int>.Plus); 

No es exactamente bonita, pero es el más cercano que está soportada por el momento, creo.

Me temo que realmente no entiendo las cosas Ruby, así que no puedo comentar sobre eso ...

Answer 2

El siguiente es directa, literal (lo más posible) C# Traducción:

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

Específicamente:

• bloques: {||} - convertido en lambdas: =>
• select se convierte en Where
• inject se convierte en Aggregate
• into se convierte en una llamada directa en una instancia lambda