C# Lambda expression syntax: are brackets necessary?

Question

I'm new in C# and earlier I saw the lambda expression is like

(params) => { expression; }

but in LINQ, I saw examples like

IEnumerable<string> customerFirstNames = customers.Select(cust => cust.FirstName);

No brackets.

(I actually mean both {} and () - regardless if we call them braces, parenthesis, or brackets.)

Are they the same or is there any difference?

Thanks a lot.

Answer 1

The rules are:

A lambda expression has the form

( modifier type parameter, modifier type parameter ...) => { statements }

Let's consider the left side first.

The modifier can be ref, out or nothing at all.

If there are no ref or out modifiers then all the types can be elided. If there are any ref or out modifiers then every parameter declaration must have a declared type. If any paramter has a declared type then every parameter must have a declared type. So you can elide the types provided that (1) there are no refs or outs, and (2) you elide all of them. Otherwise, you must provide all the types.

If there is exactly one parameter and its type has been elided then the parentheses around the parameter list may optionally be elided also.

That's all the rules about parameter lists. The rules about the right side are:

if the statement list consists of a single return statement with an expression:

x => { return x + 1; }

then the braces, return keyword and semicolon may be elided:

x => x + 1

furthermore, if the statement list consists of a single statement that is a statement expression:

x => { x++; } // Not returning the value of x++; only useful for the side effects
x => { new Y(x); } // weird! executing a ctor only for its side effects! But legal!
x => { M(x); } // note, not returning the value of M(x) even if there is one.

then it is also legal to elide the braces and semicolon:

x => x++
x => new Y(x)  
x => M(x)

Note that these now potentially mean something different to the reader! Before we were clearly discarding the return values; now the lambdas will be read as returning them.

Note that this means it is legal to do this trick with void returning methods. This is actually legal:

x => Console.WriteLine(x)

Yuck. Don't do that. If you mean

x => { Console.WriteLine(x); } 

then say that instead. The former looks too much like you are trying to say

x => { return Console.WriteLine(x); }

which of course would be illegal.