CODEWITHSUNDEEP
c#.net.net-3.5lambda
DenaliHardtail
DenaliHardtail

Reputation: 28296

What does "=>" mean?

Forgive me if this screams newbie but what does => mean in C#? I was at a presentation last week and this operator (I think) was used in the context of ORM. I wasn't really paying attention to the specifics of syntax until I went back to my notes.

Upvotes: 13

Views: 1758

Answers (7)

Richard Anthony Hein
Richard Anthony Hein

Reputation: 10650

Since nobody mentioned it yet, in VB.NET you'd use the function keyword instead of =>, like so:

dim func = function() true
'or
dim func1 = function(x, y) x + y

dim result = func() ' result is True
dim result1 = func1(5, 2) ' result is 7

Upvotes: 8

Hamish Smith
Hamish Smith

Reputation: 8181

In C# the lambda operator is written "=>" (usually pronounced "goes to" when read aloud). It means that the arguments on the left are passed into the code block (lambda function / anonymous delegate) on the right.

So if you have a Func or Action (or any of their cousins with more type parameters) then you can assign a lambda expression to them rather than needing to instantiate a delegate or have a separate method for the deferred processing:

//creates a Func that can be called later
Func<int,bool> f = i => i <= 10;
//calls the function with 12 substituted as the parameter
bool ret = f(12);

Upvotes: 13

womp
womp

Reputation: 116977

This is the "lambda operator", and you read it as "goes to". Say you had the statement:

doSomething(x => x + " hi");

You can replace the "=>" in your mind with this: 

doSomething(delegate (string x) { return x + " hi" });

As you can see, it offers a heck of a shorthand. The compiler figures out the type of the variable that you're passing, and allows you to get rid of the function signature and bracketing for the code that you're passing the signature variables into.

Upvotes: 3

mqp
mqp

Reputation: 71937

It's syntax to declare an anonymous function, known in C# as a "lambda expression."

For example, (int p) => p * 2 represents a function that takes an integer and multiplies it by two.

Upvotes: 1

t3rse
t3rse

Reputation: 10124

When said aloud the operator is the lambda (goes to) operator which helps to define the anonymous delegate that you're defining in the lambda.

A common place to see this is with an event handler. You will often have a a page load type event that is handled by a lambda with the following code: 

this.Loaded += (o, e) => { 

// code

}

You've defined a method handling the Loaded event anonymously (it doesn't have a name) by using a lambda expression. It would read as "o, e goes to ... method definition with foo."

Upvotes: 3

Rex M
Rex M

Reputation: 144112

It's shorthand for declaring a lambda.

i => i++

is (sort of) the same as writing:

delegate(int i)
{
    i++;
}

In the context of:

void DoSomething(Action<int> doSomething)
{
    doSomething(1);
}

DoSomething(delegate(int i) { i++; });
//declares an anonymous method
//and passes it to DoSomething

which is (sort of) the same as writing:

void increment(int i)
{
    i++;
}

Just without giving it a name, it allows you to declare a function in-line, known as an "anonymous" function.

Upvotes: 7

tvanfosson
tvanfosson

Reputation: 532445

It's a lambda operator, part of a lambda expression.

All lambda expressions use the lambda operator =>, which is read as "goes to". The left side of the lambda operator specifies the input parameters (if any) and the right side holds the expression or statement block. The lambda expression x => x * x is read "x goes to x times x."

Upvotes: 1

Related Questions