What does the operator '=>' mean in C#?

Question

What does the '=>' in this statement signify?

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

Is the above declaration the same as this one?

del = new SomeDelegate(this.SomeAction);

Thanks.

Answer 1

The "=>" can be read "goes to" (source: Eric Lippert), and simply separates the argument(s) from the operation in a lambda expression. In this case, a lambda is overkill. Better examples would be:

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

(find all items where the item's type is Foo)

etc. In C# 2.0, this can also be written:

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

And is a quick way of expression a function "inline", while also offering "closure" support - i.e. it could also be:

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

To do this otherwise would require a type-definiton to pass in the item-type:

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 fact, this is pretty-much exactly what the compiler does for us (both for "delegate" and lambda usage). The biggest difference is that a lambda can also express an Expression, for example for LINQ.

Answer 2

They do the same thing but the "() => ..." syntax is what is called a lambda expression and as such is the same as an anonymous function. You could probably leave out the delegate part altogether and just let the compiler infer the delegate type for you.

del = this.SomeAction;

Depending on what type "del" is seclared as.

Edit

Using lambdas or anonymous methods or just a regular method for starters enables you to map methods that didn't have the delegate's signature to the delegate.

For example, say you have a delegate with the signature bool myDelegate(int, int) but you wanted to have a method with the signature bool myMethod(string, string) handle the delegate. You could then use the lambda expression to let you do this inline with a short syntax like so.

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 as you can see lambdas and anonymous methods are basically just a shorter/inline way of making a method to handle the delegate. In you case you might not need to make an extra method. It just depends on if the delegate signature is the same as your method signature, and to me, it seems like it is.

Answer 3

Basically it's specifying an anonymous function, that takes no parameters that calls SomeAction. So yes, they are functionally equivalent. Though not equal. Using the lambda is more equivalent to:

del = new SomeDelegate(this.CallSomeAction);

where CallSomeAction is defined as:

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

Hope that helps!

Answer 4

=> is the Lambda Operator, lambda expressions are like an evolution of the C# 2.0 anonymous methods.

You can use anonymous methods and lambda expressions in a very similar way to create delegate instances:

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

Using lambda expressions:

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