为什么 lambda 表达式不是“实习的”？

Question

字符串是引用类型，但它们是不可变的。这允许它们被编译器实习；任何地方出现相同的字符串文字，都可能引用相同的对象。

委托也是不可变的引用类型。 （使用+= 运算符向多播委托添加方法构成赋值；这不是可变性。）和字符串一样，有一种“字面”方式在代码中表示委托，使用一个 lambda 表达式，例如：

Func<int> func = () => 5;

该语句的右侧是一个类型为Func<int> 的表达式；但我没有在任何地方显式调用 Func<int> 构造函数（也没有发生隐式转换）。所以我认为这本质上是一个文字。我在这里对“字面”的定义有误吗？

无论如何，这是我的问题。如果我有两个变量，例如 Func<int> 类型，并且我为这两个变量分配了相同的 lambda 表达式：

Func<int> x = () => 5;
Func<int> y = () => 5;

...是什么阻止编译器将它们视为相同的 Func<int> 对象？

我问是因为C# 4.0 language specification 的第 6.5.1 节明确指出：

语义相同的转换 具有相同功能的匿名函数 （可能为空）一组捕获的外部 变量实例相同 委托类型是允许的（但不是 必需）返回相同的委托 实例。语义上的术语 这里使用相同的意思是 匿名函数的执行 在所有情况下，都会产生相同的 给定相同论点的效果。

当我读到它时，这让我很惊讶；如果这种行为被明确允许，我会期望它被实现。但它似乎不是。这实际上给很多开发人员带来了麻烦，尤其是。当 lambda 表达式已用于成功附加事件处理程序而无法删除它们时。例如：

class EventSender
{
    public event EventHandler Event;
    public void Send()
    {
        EventHandler handler = this.Event;
        if (handler != null) { handler(this, EventArgs.Empty); }
    }
}

class Program
{
    static string _message = "Hello, world!";

    static void Main()
    {
        var sender = new EventSender();
        sender.Event += (obj, args) => Console.WriteLine(_message);
        sender.Send();

        // Unless I'm mistaken, this lambda expression is semantically identical
        // to the one above. However, the handler is not removed, indicating
        // that a different delegate instance is constructed.
        sender.Event -= (obj, args) => Console.WriteLine(_message);

        // This prints "Hello, world!" again.
        sender.Send();
    }
}

这种行为——语义相同的匿名方法的委托实例——没有实现有什么原因吗？

Answer 1

你错误地称它为文字，IMO。它只是一个可转换为委托类型的表达式。

现在至于“实习”部分 - 一些 lambda 表达式 被缓存 ，因为对于单个 lambda 表达式，有时可以创建和重用单个实例，但经常遇到该行代码.有些不是这样处理的：它通常取决于 lambda 表达式是否捕获任何非静态变量（无论是通过“this”还是方法的本地变量）。

这是一个缓存的例子：

using System;

class Program
{
    static void Main()
    {
        Action first = GetFirstAction();
        first -= GetFirstAction();
        Console.WriteLine(first == null); // Prints True

        Action second = GetSecondAction();
        second -= GetSecondAction();
        Console.WriteLine(second == null); // Prints False
    }

    static Action GetFirstAction()
    {
        return () => Console.WriteLine("First");
    }

    static Action GetSecondAction()
    {
        int i = 0;
        return () => Console.WriteLine("Second " + i);
    }
}

在这种情况下，我们可以看到第一个动作被缓存了（或者至少，产生了两个相等的委托，实际上Reflector表明它确实被缓存了在静态字段中）。第二个操作为对GetSecondAction 的两次调用创建了两个不相等的Action 实例，这就是为什么“second”最后不为空的原因。

出现在代码中不同位置但具有相同源代码的实习 lambda 是另一回事。我怀疑正确地执行此操作会非常复杂（毕竟，相同的源代码在不同的地方可能意味着不同的东西），我当然不想依赖它发生。如果它不值得依赖，而且编译器团队需要做很多工作才能正确，我认为这不是他们花费时间的最佳方式。

Answer 2

这种行为——语义相同的匿名方法的一个委托实例——没有实现有什么原因吗？

是的。因为将时间花在几乎没有人受益的棘手优化上会占用设计、实施、测试和维护确实有益于人们的功能的时间。

Answer 3

其他答案提出了很好的观点。我的确实与任​​何技术无关 - Every feature starts out with -100 points。

Answer 4

一般来说，引用相同字符串实例的字符串变量与引用恰好包含相同字符序列的不同字符串的两个变量之间没有区别。代表则不然。

假设我有两个委托，分配给两个不同的 lambda 表达式。然后我将两个代表订阅到一个事件处理程序，并取消订阅一个。结果应该是什么？

如果在 vb 或 C# 中有一种方法可以指定不引用 Me/this 的匿名方法或 lambda 应该被视为静态方法，生成一个可以在整个过程中重用的单个委托，那将很有用应用程序的生命周期。但是，没有语法可以表明这一点，并且对于编译器来说，决定让不同的 lambda 表达式返回相同的实例将是一个潜在的重大变化。

编辑我猜规范允许这样做，即使如果任何代码依赖于不同的实例，这可能是一个潜在的破坏性变化。

Answer 5

这是允许的，因为 C# 团队无法控制它。它们严重依赖委托的实现细节（CLR + BCL）和 JIT 编译器的优化器。现在已经有大量的 CLR 和抖动实现，没有理由假设这会结束。 CLI 规范对委托的规则非常简单，不足以确保所有这些不同的团队最终都会得到一个保证委托对象相等性一致的实现。至少不会，因为这会阻碍未来的创新。这里有很多需要优化的地方。

Answer 6

Lambda 不能被实习，因为它们使用一个对象来包含捕获的局部变量。而且每次构造委托时，这个实例都是不同的。