Che cosa significa '=>' l'operatore in C#?


6

Cosa significa "=>" in questa istruzione?

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

La dichiarazione di cui sopra è la stessa di questa?

del = new SomeDelegate(this.SomeAction); 

Grazie.

  0

È necessario utilizzare un titolo più descrittivo per la domanda, ad esempio "Che cosa significa l'operatore '=>' in C#?" piuttosto che "C# delegate question" 22 feb. 092009-02-22 03:52:53

  0

Grazie, cercherò di essere più descrittivo. 22 feb. 092009-02-22 03:53:41

7

Fondamentalmente sta specificando una funzione anonima, che non accetta parametri che chiama SomeAction. Quindi sì, sono funzionalmente equivalenti. Sebbene non uguale. Utilizzando il lambda è più equivalente a:

del = new SomeDelegate(this.CallSomeAction); 

dove CallSomeAction è definito come:

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

Speranza che aiuta!

  0

Quindi il '=>' indica lambda? Quale sarebbe il vantaggio di uno rispetto all'altro? 22 feb. 092009-02-22 03:52:53

+1

Il vantaggio è principalmente uno di concisione e leggibilità :) 22 feb. 092009-02-22 04:19:06


4

Essi do la stessa cosa ma la sintassi "() => ..." è quella che viene chiamata espressione lambda e come tale è la stessa di una funzione anonima. Probabilmente si potrebbe tralasciare del tutto la parte del delegato e lasciare solo che il compilatore deduca il tipo di delegato per te.

del = this.SomeAction; 

A seconda del tipo "del" è dichiarato come.

Modifica

Uso lambda o metodi anonimi o semplicemente un metodo normale per cominciare consente di mappare i metodi che non hanno la firma del delegato al delegato.

Ad esempio, supponiamo di avere un delegato con la firma bool myDelegate (int, int) ma si desidera avere un metodo con la firma bool myMethod (stringa, stringa) gestisce il delegato. Potresti quindi usare l'espressione lambda per farti fare questo in linea con una sintassi breve come questa.

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()); 
} 

Quindi, come si può vedere lambda e metodi anonimi sono fondamentalmente solo un/via più breve linea di fare un metodo per gestire il delegato. Nel tuo caso potresti non aver bisogno di fare un altro metodo. Dipende solo se la firma del delegato è la stessa della firma del metodo, e per me sembra che lo sia.


2

=> è il Lambda Operator, le espressioni lambda sono come un'evoluzione del C# 2.0 anonymous methods.

È possibile utilizzare i metodi anonimi ed espressioni lambda in un modo molto simile a creare istanze delegato:

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

utilizzando le espressioni lambda:

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

4

Il "=>" si può leggere "si a "(source: Eric Lippert) e separa semplicemente l'argomento o gli argomenti dall'operazione in un'espressione lambda. In questo caso, una lambda è eccessiva.esempi meglio sarebbe:

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

(trovare tutti gli elementi in cui il tipo di oggetto è Foo)

ecc In C# 2.0, questo può anche essere scritta:

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

E un breve modo di espressione una funzione "in linea", offrendo anche supporto "di chiusura" - cioè potrebbe anche essere:

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

A fare questo altrimenti richiederebbero un tipo-definiton a passare nella voce-tipo:

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

In realtà, questo è abbastanza-più o meno esattamente quello che il compilatore fa per noi (entrambi per "delegato" e l'uso di lambda). La più grande differenza è che un lambda può esprimere un Expression, ad esempio per LINQ.