delegate 关键字与 lambda 表示法

Question

编译后，:

delegate { x = 0; }

和

() => { x = 0 }

之间有区别吗？

Answer 1

简短的回答：不。

更长的答案可能不相关：

• 如果将 lambda 分配给委托类型（例如 Func 或 Action），您将获得一个匿名委托。
• 如果将 lambda 分配给表达式类型，您将获得表达式树而不是匿名委托。 然后可以将表达式树编译为匿名委托。

编辑：
这是表达式的一些链接。

• System.Linq.Expression.Expression(TDelegate)（从此处开始）。
• 具有委托（例如 System.Func）的 Linq 内存使用 System .Linq.Enumerable。 带有表达式的 Linq to SQL（以及其他任何内容）使用 System.Linq。可查询。 检查这些方法的参数。
• ScottGu 的解释< /a>. 简而言之，Linq 内存中将生成一些匿名方法来解析您的查询。 Linq to SQL 将生成表示查询的表达式树，然后将该树转换为 T-SQL。 Linq to Entities 将生成表示查询的表达式树，然后将该树转换为适合平台的 SQL。

Answer 2

我喜欢艾米的回答，但我认为我会很迂腐。 问题说，“一旦编译” - 这表明两个表达式都已编译。 它们如何都能编译，但一个转换为委托，一个转换为表达式树？ 这是一个棘手的问题 - 您必须使用匿名方法的另一个功能； 唯一不被 lambda 表达式共享的一个。 如果您指定匿名方法而没有指定参数列表，则它与返回 void 且没有任何 out 参数的任何委托类型兼容。 有了这些知识，我们应该能够构造两个重载，使表达式完全明确但又截然不同。

但灾难降临了！ 至少在 C# 3.0 中，您无法将带有块主体的 lambda 表达式转换为表达式 - 也无法将带有主体中赋值的 lambda 表达式转换为（即使它用作返回值）。 这可能会随着 C# 4.0 和 .NET 4.0 的改变而改变，它们允许在表达式树中表达更多内容。 换句话说，根据 MojoFilter 恰好给出的示例，两者几乎总是会转换为相同的东西。 （稍后会详细介绍。）

如果我们稍微改变一下主体，我们就可以使用委托参数技巧：

using System;
using System.Linq.Expressions;

public class Test
{
    static void Main()
    {
        int x = 0;
        Foo( () => x );
        Foo( delegate { return x; } );
    }

    static void Foo(Func<int, int> action)
    {
        Console.WriteLine("I suspect the anonymous method...");
    }

    static void Foo(Expression<Func<int>> func)
    {
        Console.WriteLine("I suspect the lambda expression...");
    }
}

但是等等！ 如果我们足够狡猾，即使不使用表达式树，我们也可以区分两者。 下面的示例使用重载解析规则（以及匿名委托匹配技巧）...

using System;
using System.Linq.Expressions;

public class Base
{
    public void Foo(Action action)
    {
        Console.WriteLine("I suspect the lambda expression...");
    }
}

public class Derived : Base
{
    public void Foo(Action<int> action)
    {
        Console.WriteLine("I suspect the anonymous method...");
    }
}

class Test
{
    static void Main()
    {
        Derived d = new Derived();
        int x = 0;
        d.Foo( () => { x = 0; } );
        d.Foo( delegate { x = 0; } );
    }
}

哎呀。 孩子们，请记住，每次重载从基类继承的方法时，就会有一只小猫开始哭泣。

Answer 3

在上面的两个例子中，没有区别，为零。

表达式：

() => { x = 0 }

是一个带有语句体的Lambda表达式，所以它不能被编译为表达式树。 事实上它甚至无法编译，因为它需要在 0 后面加一个分号：

() => { x = 0; } // Lambda statement body
() => x = 0      // Lambda expression body, could be an expression tree. 

Answer 4

艾米 B 是对的。 请注意，使用表达式树可能有一些优点。 LINQ to SQL 将检查表达式树并将其转换为 SQL。

您还可以使用 lamda 和表达式树来以重构安全的方式有效地将类成员的名称传递到框架。 Moq 就是一个示例。

Answer 5

有区别

示例：

var mytask = Task.Factory.StartNew(() =>
{
    Thread.Sleep(5000);
    return 2712;
});
mytask.ContinueWith(delegate
{
    _backgroundTask.ContinueTask(() =>lblPercent.Content = mytask.Result.ToString(CultureInfo.InvariantCulture));
});   

我用 lambda 替换：（错误）

var mytask = Task.Factory.StartNew(() =>
{
    Thread.Sleep(5000);
    return 2712;
});
mytask.ContinueWith(()=>
{
    _backgroundTask.ContinueTask(() =>lblPercent.Content = mytask.Result.ToString(CultureInfo.InvariantCulture));
});

Answer 6

这里有一些基础知识。

这是一个匿名方法

(string testString) => { Console.WriteLine(testString); };

由于匿名方法没有名称，我们需要一个委托，可以在其中分配这两个方法或表达式。 例如

delegate void PrintTestString(string testString); // declare a delegate

PrintTestString print = (string testString) => { Console.WriteLine(testString); }; 
print();

---

与 lambda 表达式相同。 通常我们需要一个委托来使用它们

s => s.Age > someValue && s.Age < someValue    // will return true/false

我们可以使用一个 func 委托来使用这个表达式。

Func< Student,bool> checkStudentAge = s => s.Age > someValue && s.Age < someValue ;

bool result = checkStudentAge ( Student Object);