有人能简明地区分匿名方法和Lambda表达式吗？
匿名方法的用法：
private void DoSomeWork()
{
if (textBox1.InvokeRequired)
{
//textBox1.Invoke((Action)(() => textBox1.Text = "test"));
textBox1.Invoke((Action)delegate { textBox1.Text = "test"; });
}
}
这只是将普通的 Lambda 表达式转换为强类型委托，还是有更多潜在的内容。
我很清楚像下面这样强类型的委托：
UpdateTextDelegate mydelegate = new UpdateTextDelegate(MethodName)
对我来说，作为类型为System.Delegate的参数已经足够了，但是匿名方法的概念对我来说还比较新。
什么是匿名方法？它真的是匿名的吗？它有名称吗？这些都是很好的问题，让我们从这些问题开始，并随着进展逐步了解lambda表达式。
当你这样做时：
public void TestSomething()
{
Test(delegate { Debug.WriteLine("Test"); });
}
实际发生了什么？
编译器首先决定采取方法的“body”，即：
Debug.WriteLine("Test");
将其分离成一个方法。
编译器现在需要回答两个问题：
第二个问题很容易回答。 delegate { 部分就是答案。该方法不带参数（在 delegate 和 { 之间没有任何内容），并且由于我们不关心它的名称（因此是“匿名”的一部分），因此我们可以这样声明该方法：
public void SomeOddMethod()
{
Debug.WriteLine("Test");
}
但是为什么它要这样做呢？
让我们看看委托，例如 Action 到底是什么。
委托是一个指向两个东西的引用（指针），如果我们暂时忽略 .NET 中委托实际上是多个单一“委托”链接列表的事实：
因此，有了这个知识，第一段代码实际上可以重写为：
public void TestSomething()
{
Test(new Action(this.SomeOddMethod));
}
private void SomeOddMethod()
{
Debug.WriteLine("Test");
}
public void TestSomething()
{
var temp = new SomeClass;
Test(new Action(temp.SomeOddMethod));
}
private class SomeClass
{
private void SomeOddMethod()
{
Debug.WriteLine("Test");
}
}
public void Test()
{
int x = 10;
Test(delegate { Debug.WriteLine("x=" + x); });
}
public void TestSomething()
{
var temp = new SomeClass;
temp.x = 10;
Test(new Action(temp.SomeOddMethod));
}
private class SomeClass
{
public int x;
private void SomeOddMethod()
{
Debug.WriteLine("x=" + x);
}
}
void Main()
{
int x = 10;
Test(delegate { Debug.WriteLine("x=" + x); });
}
public void Test(Action action)
{
action();
}
// var temp = new UserQuery+<>c__DisplayClass1();
IL_0000: newobj UserQuery+<>c__DisplayClass1..ctor
IL_0005: stloc.0 // CS$<>8__locals2
IL_0006: ldloc.0 // CS$<>8__locals2
// temp.x = 10;
IL_0007: ldc.i4.s 0A
IL_0009: stfld UserQuery+<>c__DisplayClass1.x
// var action = new Action(temp.<Main>b__0);
IL_000E: ldarg.0
IL_000F: ldloc.0 // CS$<>8__locals2
IL_0010: ldftn UserQuery+<>c__DisplayClass1.<Main>b__0
IL_0016: newobj System.Action..ctor
// Test(action);
IL_001B: call UserQuery.Test
Test:
IL_0000: ldarg.1
IL_0001: callvirt System.Action.Invoke
IL_0006: ret
<>c__DisplayClass1.<Main>b__0:
IL_0000: ldstr "x="
IL_0005: ldarg.0
IL_0006: ldfld UserQuery+<>c__DisplayClass1.x
IL_000B: box System.Int32
IL_0010: call System.String.Concat
IL_0015: call System.Diagnostics.Debug.WriteLine
IL_001A: ret
<>c__DisplayClass1..ctor:
IL_0000: ldarg.0
IL_0001: call System.Object..ctor
IL_0006: ret
UserQuery+<>c__DisplayClass1，方法的名称为<Main>b__0。我在生成此代码的C#代码中进行了编辑，在上面的示例中，LINQPad除了IL之外什么也没有生成。Test(() => Debug.WriteLine("Test"));
在这种情况下，它是相同的，它是生产匿名方法的快捷方式。
您可以用两种方式编写此代码：
() => { ... code here ... }
() => ... single expression here ...
() => ...
delegate { ... }
() => 语法是到达它的快捷方式。var customers = from customer in db.Customers
where customer.Name == "ACME"
select customer.Address;
这段代码被重写为如下形式：
var customers =
db.Customers
.Where(customer => customer.Name == "ACME")
.Select(customer => customer.Address");
delegate { ... } 语法，你将不得不重写表达式并添加 return ... 等代码，这看起来会更加奇怪。因此，Lambda 语法被添加，使我们编写上述代码时更加轻松。
那么什么是表达式呢？
到目前为止，我还没有展示过如何定义 Test，但让我们为上面的代码定义 Test：
public void Test(Action action)
public void Test(Expression<Func<....>> expr)
....部分，请回到1处继续阅读。Test(() => x + 10);
实际上不会传递委托或可立即调用的任何内容。相反，编译器将重写此代码为类似于以下代码的东西（但并不完全相同）：
var operand1 = new VariableReferenceOperand("x");
var operand2 = new ConstantOperand(10);
var expression = new AdditionOperator(operand1, operand2);
Test(expression);
Expression<Func<...>>对象，其中包含对变量、字面值、使用的运算符等的引用，并将该对象树传递给方法。db.Customers.Where(...)部分。Expression<Func<...>> 中适用于 lambda 表达式的语法受限（无语句等）。因此，让我们总结一下：
脚注：
The .... part for such a simple expression is meant for the type of return value you get from the expression. The () => ... simple expression ... only allows expressions, that is, something that returns a value, and it cannot be multiple statements. As such, a valid expression type is this: Expression<Func<int>>, basically, the expression is a function (method) returning an integer value.
Note that the "expression that returns a value" is a limit for Expression<...> parameters or types, but not of delegates. This is entirely legal code if the parameter type of Test is an Action:
Test(() => Debug.WriteLine("Test"));
Obviously, Debug.WriteLine("Test") doesn't return anything, but this is legal. If the method Test required an expression however, it would not be, as an expression must return a value.
Expression<Func<T>> 的方法，会发生什么？ - Jim Wooleypublic void Test(Expression<Func<int>> expr)时，使用Test(delegate { return 10; });时发生的。请注意，我并不是说没有我没有涉及到的问题，如果你能找到一些问题，我很乐意扩展它们，但是将委托传递给需要表达式的方法是行不通的。 - Lasse V. Karlsen有一个微妙的差别需要您注意。考虑以下查询（使用惯用的NorthWind数据库）。
Customers.Where(delegate(Customers c) { return c.City == "London";});
Customers.Where(c => c.City == "London");
第一个使用匿名委托，第二个使用Lambda表达式。如果您评估两者的结果，您将看到相同的结果。但是，查看生成的SQL，我们将看到完全不同的故事。第一个生成
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]
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
Expression<Func<T>>进行包装。因此，在第一个案例中，Where扩展方法的最佳匹配是扩展IEnumerable的版本，而不是IQueryable版本，后者需要一个Expression<Func<T, bool>>。准确地说，你所称的“匿名委托”实际上是一个匿名方法。
嗯，无论是lambda表达式还是匿名方法都只是语法糖。编译器将为您生成至少一个“常规”方法，尽管有时（在闭包的情况下）它会生成一个嵌套类，其中包含不再是匿名的方法。