unario - operadores de asignacion en c#

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

Question

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

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

¿Es la declaración anterior la misma que esta?

del = new SomeDelegate(this.SomeAction);

Gracias.

Answer 1

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. Usar 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!

Answer 2

El "=>" se puede leer "goes to" ( fuente: 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");

(encuentre todos los artículos donde el tipo de artículo 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 una forma rápida de expresión una función "en línea", mientras que también ofrece soporte de "cierre", es decir, también podría ser:

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

Para hacer esto, de lo contrario, se requeriría una definición de tipo para pasar 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, exactamente lo que el compilador hace por nosotros (tanto para "delegar" como para usar lambda). La mayor diferencia es que una lambda también puede expresar una Expression , por ejemplo para LINQ.

Answer 3

=> es el operador Lambda , las expresiones lambda son como una evolución de los métodos anónimos C # 2.0.

Puede usar métodos anónimos y expresiones lambda de una manera muy similar para crear instancias de delegado:

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

Usando expresiones lambda:

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

Answer 4

Hacen 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;

Dependiendo de qué tipo "del" se declara como.

Editar

El uso de lambdas o métodos anónimos o simplemente un método regular para principiantes le permite mapear métodos que no tenían la firma del delegado para el 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());
}

Entonces, como puede ver, los métodos anónimos y lambdas son básicamente solo una forma más corta / en línea de crear 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.