<p>Once it is compiled, is there a difference between:</p>

<pre><code>delegate { x = 0; }
</code></pre>

<p>and</p>

<pre><code>() =&gt; { x = 0 }
</code></pre>

<p>?</p>

Short answer : no.
Longer answer that may not be relevant:
If you assign the lambda to a delegate type (such as
```
Func
```
or
```
Action
```
) you'll get an anonymous delegate.
If you assign the lambda to an Expression type, you'll get an expression tree instead of a anonymous delegate.  The expression tree can then be compiled to an anonymous delegate.
Edit:
Here's some links for Expressions.
System.Linq.Expression.Expression(TDelegate)
(start here).
Linq in-memory with delegates (such as System.Func) uses
System.Linq.Enumerable
.  Linq to SQL (and anything else) with expressions uses
System.Linq.Queryable
.  Check out the parameters on those methods.
An
Explanation from ScottGu
.  In a nutshell, Linq in-memory will produce some anonymous methods to resolve your query.  Linq to SQL will produce an expression tree that represents the query and then translate that tree into T-SQL.  Linq to Entities will produce an expression tree that represents the query and then translate that tree into platform appropriate SQL.