Question

我的印象是C＃中的lambda表达式上下文包含对其中使用的父函数作用域的变量的引用。考虑：

public class Test
{
    private static System.Action<int> del;

    public static void test(){
        int i = 100500;
        del = a => System.Console.WriteLine("param = {0}, i = {1}", a, i);
        del(1);

        i = 10;
        del(1);

    }

    public static void Main()
    {
        test();
    }
}

输出

param = 1, i = 100500
param = 1, i = 10

但是，如果这是真的，则以下内容将是非法的，因为lambda上下文将引用超出范围的局部变量：

public class Test
{
    private static System.Action<int> del;

    public static void test(){
        int i = 100500;
        del = a => System.Console.WriteLine("param = {0}, i = {1}", a, i);
    }

    public static void Main()
    {
        test();
        del(1);
    }
}

但是，这会编译，运行和输出

param = 1, i = 100500

这意味着要么发生奇怪的事情，要么上下文保留局部变量的值，而不是对它们的引用。但如果这是真的，就必须在每次lambda invokation上更新它们，而且我不知道当原始变量超出范围时它会如何工作。此外，在处理大值类型时，这似乎会产生开销。

我知道，例如，在C ++中，这是UB（在回答this question时确认）。

问题是，这是C＃中明确定义的行为吗？（我认为C＃确实有一些UB，或者至少有一些IB，对吗？）

如果定义明确，这实际上是如何以及为何有效？（实现逻辑会很有趣）

Answer 1

与C＃中的lambda语法相关的闭包概念是一个非常大的主题，对我来说太大了，只能在这个答案中涵盖所有内容，但我们至少尝试回答这个问题。实际答案位于底部，其余部分是理解答案所需的背景。

当编译器尝试使用匿名方法编译方法时会发生什么情况，它会在某种程度上重写该方法。

基本上，会生成一个新类，并将匿名方法提升到此类中。它给出了一个名称，虽然是一个内部名称，因此对于编译器来说，它有点从匿名方法转换为命名方法。但是，您不必知道或处理该名称。

此方法所需的任何变量，除了匿名方法之外声明的变量，但在使用/声明匿名方法的同一方法中，也将被取消，然后所有用法那些变量被重写。

这里涉及到几种方法，所以很难阅读上面的文字，所以让我们做一个例子：

public Func<int, int> Test1()
{
    int a = 42;
    return value => a + value;
}

此方法被重写为以下内容：

public Func<int, int> Test1()
{
    var dummy = new <>c__DisplayClass1();
    dummy.a = 42;
    return dummy.<Test1>b__0;
}

internal class <>c__DisplayClass1
{
    public int a;
    public int <Test1>b__0(int value)
    {
        return a + value;
    }
}

编译器可以处理所有这些时髦的名称（是的，它们确实以所有括号命名）因为它引用具有id和对象引用的东西，名称不再是编译器的问题。但是，您永远不能声明具有这些名称的类或方法，因此编译器不会产生恰好已经存在的类的风险。

这是一个LINQPad示例，显示我声明的类，虽然名称中的括号较少，但看起来与编译器生成的类相同：

void Main()
{
    var f1 = Test1();
    f1(10).Dump();
    f1.Dump();

    var f2 = Test2();
    f2(10).Dump();
    f2.Dump();
}

public Func<int, int> Test1()
{
    int a = 42;
    return value => a + value;
}

public Func<int, int> Test2()
{
    var dummy = new __c__DisplayClass1();
    dummy.a = 42;
    return dummy._Test2_b__0;
}

public class __c__DisplayClass1
{
    public int a;
    public int _Test2_b__0(int value)
    {
        return a + value;
    }
}

输出：

LINQPad output

如果您查看上面的屏幕截图，您会发现每个委托变量有两件事，一个Method属性和一个Target属性。

调用方法时，会使用引用this对象的Target引用来调用它。因此，委托捕获两件事：调用哪种方法，以及调用它的对象。

基本上，该生成类的对象作为委托的一部分而存在，因为它是该方法的目标。

考虑到所有这些，让我们来看看你的问题：

为什么lambda表达式在方法终止后保留封闭范围变量值？

答：如果lambda存活下来，所有捕获的变量都会存活，因为它们不再是中声明的方法的局部变量。相反，它们被提升到一个也具有lambda方法的新对象上，因此它随处“跟随”lambda。

为什么lambda表达式在方法终止后保留封闭范围变量值？

1 个答案: