¿Qué significa el operador '=>' en C#?


6

¿Qué significa '=>' en esta declaración?

del = new SomeDelegate(() => SomeAction()); 

¿La declaración anterior es la misma que esta?

del = new SomeDelegate(this.SomeAction); 

Gracias.

  0

Debe usar un título más descriptivo para su pregunta, como "¿Qué significa el operador '=>' en C#?" en lugar de "C# delegate question" 22 feb. 092009-02-22 03:52:53

  0

Gracias, intentaré ser más descriptivo. 22 feb. 092009-02-22 03:53:41

7

Básicamente se trata de especificar una función anónima, que no toma parámetros que se llaman SomeAction. Entonces sí, son funcionalmente equivalentes. Aunque no es igual. Utilizando el lambda es más equivalente a:

del = new SomeDelegate(this.CallSomeAction); 

donde CallSomeAction se define como:

public void CallSomeAction() 
{ 
    this.SomeAction(); 
} 

Espero que ayude!

  0

Entonces, ¿'=>' significa lambda? ¿Cuál sería la ventaja de uno sobre el otro? 22 feb. 092009-02-22 03:52:53

+1

La ventaja es principalmente una de concisión y legibilidad :) 22 feb. 092009-02-22 04:19:06


4

do lo mismo pero la sintaxis "() => ..." es lo que se llama una expresión lambda y, como tal, es lo mismo que una función anónima. Probablemente podría dejar de lado la parte de delegado y dejar que el compilador deduzca el tipo de delegado por usted.

del = this.SomeAction; 

Según el tipo "del" se declara como.

Editar

Uso de lambdas o métodos anónimos o simplemente un método regular para empezar permite asignar métodos que no tienen la firma del delegado al delegado.

Por ejemplo, supongamos que tiene un delegado con la firma bool myDelegate (int, int) pero quería tener un método con la firma bool myMethod (string, string) que maneja el delegado. A continuación, puede utilizar la expresión lambda para que pueda hacer esto en línea con una sintaxis corta como esa.

delegate bool myDelegate(int x, int y); 

// With lambdas... 
myDelegate del = (int a, int b) => myMethod(a.ToString(), b.ToString()); 

// With anonymous methods... 
myDelegate del2 = delegate(int a, int b) { return myMethod(a.ToString(), b.ToString()); }; 

// The good ol' way without lambdas or anonymous methods... 
myDelegate del3 = SomeDelegateHandler; 

... then write a method somewhere else ... 

// Handler method 
private bool SomeDelegateHandler(int a, int b) 
{ 
    return myMethod(a.ToString(), b.ToString()); 
} 

Así como se puede ver lambdas y métodos anónimos, básicamente, son sólo una forma más corta/línea de hacer un método para manejar el delegado. En su caso, es posible que no necesite hacer un método adicional. Solo depende de si la firma del delegado es igual a la firma de su método, y para mí, parece que sí lo es.


2

=> es el Lambda Operator, las expresiones lambda son como una evolución del C# 2.0 anonymous methods.

Puede utilizar los métodos anónimos y expresiones lambda de una manera muy similar a crear instancias de delegado:

Func<string,int> wordCount; 
wordCount = delegate (string text) { return text.Split().Length; }; 
Console.WriteLine (wordCount("Hello World")); 

el uso de expresiones lambda:

Func<string,int> wordCount; 
wordCount = (string text) => { text.Split().Length; }; 
Console.WriteLine (wordCount("Hello World")); 

4

El "=>" se puede leer "va a "(source: Eric Lippert), y simplemente separa el argumento (s) de la operación en una expresión lambda. En este caso, un lambda es excesivo.Mejores ejemplos serían:

var subList = list.FindAll(item => item.Type == "Foo"); 

(encontrar todos los artículos donde el tipo del elemento es Foo)

etc. En C# 2.0, esto también se puede escribir:

var subList = list.FindAll(delegate(SomeType item) { 
    return item.Type == "Foo";}); 

Y es un rápido forma de expresión de una función "en línea", mientras que también ofrece el "cierre" de apoyo - es decir, que también podría ser:

string itemType = ... 
var subList = list.FindAll(item => item.Type == itemType); 

Para hacerlo de otro modo requerirían un tipo-definiton acontecerá en el tipo de elemento:

class Searcher { 
    public string itemType; 
    public bool Find(SomeType item) {return item.Type == itemType;} 
} 
... 
Searcher searcher = new Searcher(); 
searcher.itemType = ... 
var subList = list.FindAll(searcher.Find); 

De hecho, esto es bastante-mucho exactamente lo que hace el compilador para nosotros (tanto para "delegado" y el uso de lambda). La mayor diferencia es que una lambda puede también expresar un Expression, por ejemplo para LINQ.