Question: Can anyone provide a concise distinction between anonymous method and lambda expressions?  

Usage of anonymous method:

```
private void DoSomeWork()
{
    if (textBox1.InvokeRequired)
    {
        //textBox1.Invoke((Action)(() => textBox1.Text = "test"));
        textBox1.Invoke((Action)delegate { textBox1.Text = "test"; });
    }
}

```

Is it only a normal lambda expression being cast to a strongly typed delegate or there is more of it undercover.  

I'm well aware that a strongly typed delegate like follow

```
UpdateTextDelegate mydelegate = new UpdateTextDelegate(MethodName)

```

suffice as a parameter of type `System.Delegate`, but the idea of anonymous method is rather new to me.

Answer: 
There is one subtle difference you should be aware of. Consider the following queries (using the proverbial NorthWind).

```
Customers.Where(delegate(Customers c) { return c.City == "London";});
Customers.Where(c => c.City == "London");

```

The first one uses an anonymous delegate and the second one uses a lambda expression. If you evaluate the results of both you will see the same thing. However, looking at the generated SQL, we'll see quite a different tale. The first generates 

```
SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]
FROM [Customers] AS [t0]

```

Whereas the second generates 

```
SELECT [t0].[CustomerID], [t0].[CompanyName], [t0].[ContactName], [t0].[ContactTitle], [t0].[Address], [t0].[City], [t0].[Region], [t0].[PostalCode], [t0].[Country], [t0].[Phone], [t0].[Fax]
FROM [Customers] AS [t0]
WHERE [t0].[City] = @p0

```

Notice in the first case, the where clause is not passed to the database. Why is this? The compiler is able to determine that the lambda expression is a simple single-line expression which can be retained as an expression tree, whereas the anonymous delegate is not a lambda expression and thus not wrappable as an `Expression<Func<T>>`. As a result in the first case, the best match for the Where extension method is the one that extends IEnumerable rather than the IQueryable version which requires an `Expression<Func<T, bool>>`.

At this point, there's little use to the anonymous delegate. It's more verbose and less flexible. In general, I would recommend always using the lambda syntax over the anonymous delegate syntax and pick up parsability and syntactic terseness as well.
To be precise, what you name 'anonymous delegate' is actually an anonymous method.

Well, both lambdas and anonymous methods are just syntax sugar. The compiler will generate at least a 'normal' method for you, although sometimes (in the case of a closure) it will generate a nested class with the no-longer-anonymous method in it.