Why do parentheses around lambda statement cause syntax error?

Question

I'm looking for a good explanation why one piece of code fails to compile and the other compiles just fine.

Fails:

richTextBox1.Invoke(new MethodInvoker((() => { richTextBox1.AppendText("test"); })));

Gives the error

Method name expected

on the opening parenthesis right after MethodInvoker(. Apparently, I can't wrap my lambda statements in parentheses.

Compiles:

richTextBox1.Invoke(new MethodInvoker(() => { richTextBox1.AppendText("test"); }));

The questions is - why?

I always took it for granted that I could wrap any method param in parentheses if I wanted but apparently that's not the case with lambda expressions. I understand that they are somewhat special, but I still can't see a good reason for this. Maybe I don't understand something about the syntax. I would really like to get it.

By the way, this presents in VS2008, .NET 3.5 SP1, I haven't tested it in VS2010 and .NET 4 yet.

Answer 1

It's not a lambda expression, it's a parenthesized expression that contains a lambda expression. Therefore, the node for this parameter in the abstract syntax tree for this method invocation would be a parenthesized expression, and not a lambda expression as required by the specification. This is why.

There are other places where the Microsoft C# compiler does violate the specification and accept such an expression even though it shouldn't (per the specification) but this is not one of them.

The relevant section of the specification is §6.5.

Answer 2

You are mistaken in the premise that you have written a “method param”. The construct you have created is not a method call, you have written a delegate creation expression (see the C# specification, section 7.6.10.5), which is supposed to have a single argument, which must be either

• a method group,
• an anonymous function or
• a value of either the compile time type dynamic or a delegate-type.

In your case, it is not a method group (the error message is hinting that a method name is expected there), nor an anonymous function (since it is an expression which “somewhere inside” contains an anonymous function), nor a value of the said types.

If you wrote a method invokation, you could, indeed, wrap the parameter in parentheses, even if it contains a lambda expression:

void Method(Action action)
{
}
...
Method((() => { Console.WriteLine("OK"); }));