Was bedeutet der Operator => in C#?


6

Was bedeutet das '=>' in dieser Aussage?

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

Ist die obige Erklärung die gleiche wie diese?

del = new SomeDelegate(this.SomeAction); 

Danke.

  0

Sie sollten einen aussagekräftigeren Titel für Ihre Frage verwenden, z. B. "Was bedeutet der Operator = = in C#?" anstatt "C# delegieren Sie Frage" 22 feb. 092009-02-22 03:52:53

  0

Danke, ich werde versuchen, beschreibender zu sein. 22 feb. 092009-02-22 03:53:41

7

Im Grunde ist es eine anonyme Funktion, die keine Parameter annimmt, die SomeAction aufruft. Also ja, sie sind funktional gleichwertig. Obwohl nicht gleich. das Lambda Mit mehr entspricht:

del = new SomeDelegate(this.CallSomeAction); 

wo CallSomeAction ist wie folgt definiert:

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

Hoffnung, das hilft!

  0

Also bedeutet das = = Lambda? Was wäre der Vorteil eines über dem anderen? 22 feb. 092009-02-22 03:52:53

+1

Der Vorteil ist in erster Linie Prägnanz und Lesbarkeit :) 22 feb. 092009-02-22 04:19:06


4

Sie tun die gleiche Sache, aber die "() => ..." -Syntax ist was ein Lambda-Ausdruck genannt wird und als solche ist das gleiche wie eine anonyme Funktion. Sie könnten den Delegatteil wahrscheinlich ganz weglassen und den Compiler einfach den Delegattyp für Sie ableiten lassen.

del = this.SomeAction; 

Je nachdem, welche Art "del" wird seclared wie.

bearbeiten

Mit lambdas oder anonyme Methoden oder nur eine ganz normale Methode für den Anfang können Sie Methoden zur Karte, die nicht die Delegierten Unterschrift an die Delegierten hatte.

Angenommen, Sie haben einen Delegaten mit der Signatur bool myDelegate (int, int), aber Sie wollten eine Methode mit der Signatur bool myMethod (string, string) den Delegaten behandeln. Sie könnten dann den Lambda-Ausdruck verwenden, damit Sie dies inline mit einer kurzen Syntax tun können.

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

So wie Sie können lambdas und anonyme Methoden zu sehen sind im Grunde nur eine kürzere/Inline-Weg, ein Verfahren zur Herstellung der Delegierten zu behandeln. In diesem Fall müssen Sie möglicherweise keine zusätzliche Methode erstellen. Es hängt nur davon ab, ob die Signatur des Delegierten mit Ihrer Methodensignatur übereinstimmt, und mir scheint es so zu sein.


2

=> ist die Lambda Operator, Lambda-Ausdrücke sind wie eine Evolution der C# 2.0 anonymous methods.

Sie anonyme Methoden und Lambda-Ausdrücke in einer sehr ähnlichen Weise delegieren Instanzen erstellen können:

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

Mit Lambda-Ausdrücke:

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

4

Die "=>" kann „zu lesen geht to "(source: Eric Lippert), und trennt einfach das Argument (die Argumente) von der Operation in einem Lambda-Ausdruck. In diesem Fall ist ein Lambda Overkill.Bessere Beispiele wären:

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

(alle Artikel finden, wo der Typ des Artikel ist Foo)

usw. In C# 2.0, kann dies auch geschrieben werden:

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

und ist eine schnelle Ausdrucksweise eine Funktion „inline“, aber auch „closure“ Unterstützung anbieten - dh, es auch sein könnte:

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

zu tun dies sonst wäre eine Art-Definiton erfordern in der Artikeltyp weitergeben müssen:

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 der Tat ist dies ziemlich viel ist genau das, was der Compiler für uns tut (beide für „delegieren“ und Lambda-Nutzung). Der größte Unterschied ist, dass ein Lambda auch einen Expression ausdrücken kann, zum Beispiel für LINQ.