What's the difference between anonymous methods (C# 2.0) and lambda expressions (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:

1. Anonymous methods are basically functions without a name, with the ability to create closures.
2. Lambda expressions are constructs that are convertible to both anonymous methods and expression trees, and follow more complex rules of type inference than anonymous methods.

The range of more or less subtle differences are explained by Eric Lippert (C# language designer) in his blog:

• Lambda Expressions vs. Anonymous Methods, Part One
• Lambda Expressions vs. Anonymous Methods, Part Two
• Lambda Expressions vs. Anonymous Methods, Part Three
• Lambda Expressions vs. Anonymous Methods, Part Four
• Lambda Expressions vs. Anonymous Methods, Part Five

First, convenience: lambdas are easier to read and write.

Second, expressions: lambdas can be compiled to either a delegate, or an expression tree (Expression<T> for some delegate-type T, such as Func<int,bool>). Expression trees are the more exciting, as it is the key to LINQ to out-of-process data stores.

Func<int,bool> isEven = i => i % 2 == 0;
Expression<Func<int,bool>> isEven = i => i % 2 == 0;

Note that lambda expressions with statement bodies can only be compiled to delegates, not Expressions:

Action a = () => { Console.WriteLine(obj.ToString()); };