What's the difference between anonymous methods (C# 2.0) and lambda expressions (C# 3.0)? [duplicate]

What is the difference between anonymous methods of C# 2.0 and lambda expressions of C# 3.0.?


  1. Lambda expressions can be converted to delegates or expression trees (with some restrictions); anonymous methods can only be converted to delegates
  2. Lambda expressions allow type inference on parameters:
  3. Lambda expressions allow the body to be truncated to just an expression (to return a value) or single statement (in other cases) without braces.
  4. Lambda expressions allow the parameter list to be shortened to just the parameter name when the type can be inferred and when there's only a single parameter
  5. Anonymous methods allow the parameter list to be omitted entirely when it's not used within the body and it doesn't lead to ambiguity

The last point is the only benefit of anonymous methods over lambdas, I believe. It's useful to create a field-like event with a no-op subscription though:

public event EventHandler Click = delegate{};

The MSDN page on anonymous methods explains it

In versions of C# before 2.0, the only way to declare a delegate was to use named methods. C# 2.0 introduced anonymous methods and in C# 3.0 and later, lambda expressions supersede anonymous methods as the preferred way to write inline code. However, the information about anonymous methods in this topic also applies to lambda expressions. There is one case in which an anonymous method provides functionality not found in lambda expressions. Anonymous methods enable you to omit the parameter list, and this means that an anonymous method can be converted to delegates with a variety of signatures. This is not possible with lambda expressions. For more information specifically about lambda expressions, see Lambda Expressions (C# Programming Guide).

And regarding lambda expressions:

A lambda expression is an anonymous function that can contain expressions and statements, and can be used to create delegates or expression tree types. 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." This expression can be assigned to a delegate type as follows: