que - Operadores como parámetros del método en C#

documentar codigo c#

Question

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

Lo pregunto porque recientemente implementé el combinador de tordo en C # pero al traducir el ejemplo de Ruby de Raganwald

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

Que dice "Toma los números del 1 al 100, conserva los impares, toma la suma de esos, y luego responde el cuadrado de ese número".

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

Answer 1

Bueno, en términos simples, puedes 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

Aunque eso no es muy emocionante. Sería bueno tener todos esos delegados preconstruidos para nosotros. Por supuesto, podrías 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 ha hecho algo muy similar en MiscUtil , si quieres mirar. A continuación, puede llamar:

DoSomething(Operator<int>.Plus);

No es exactamente bonito, pero creo que es lo más cercano que se admite en este momento.

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

Answer 2

La siguiente es traducción directa, literal (tanto como sea posible) C #:

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

Específicamente:

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