闭包在幕后是如何工作的？ (C#)

Question

我觉得我对闭包、如何使用它们以及它们何时有用有相当不错的理解。但我不明白的是它们实际上是如何在内存中幕后工作的。一些示例代码：

public Action Counter()
{
    int count = 0;
    Action counter = () =>
    {
        count++;
    };

    return counter;
}

通常，如果闭包未捕获 {count}，则其生命周期将限定在 Counter() 方法内，并且在完成后，它将与 Counter() 的其余堆栈分配一起消失。当它关闭时会发生什么？这次 Counter() 调用的整个堆栈分配是否保留？它是否将 {count} 复制到堆中？它是否实际上从未在堆栈上分配，但被编译器识别为已关闭，因此始终存在于堆上？

对于这个特定问题，我主要感兴趣的是它在 C# 中的工作原理，但不反对与支持闭包的其他语言进行比较。

Answer 1

你的第三个猜测是正确的。编译器会生成这样的代码：

private class Locals
{
  public int count;
  public void Anonymous()
  {
    this.count++;
  }
}

public Action Counter()
{
  Locals locals = new Locals();
  locals.count = 0;
  Action counter = new Action(locals.Anonymous);
  return counter;
}

有意义吗？

另外，您还要求进行比较。 VB 和 JScript 都以几乎相同的方式创建闭包。

Answer 2

编译器（与运行时相对）创建另一个类/类型。带有闭包的函数以及您关闭/提升/捕获的任何变量都将在整个代码中重写为该类的成员。 .Net 中的闭包是作为该隐藏类的一个实例来实现的。

这意味着您的 count 变量完全是不同类的成员，并且该类的生命周期与任何其他 clr 对象一样；在不再具有 root 权限之前，它不符合垃圾回收的条件。这意味着只要您有对该方法的可调用引用，它就不会去任何地方。

Answer 3

谢谢@HenkHolterman。由于 Eric 已经解释过，我添加链接只是为了显示编译器为闭包生成的实际类。我想补充一点，C# 编译器创建显示类可能会导致内存泄漏。例如，在函数内部，有一个由 lambda 表达式捕获的 int 变量，还有另一个局部变量，它仅保存对大字节数组的引用。编译器将创建一个显示类实例，该实例将保存对变量（即 int 和字节数组）的引用。但在引用 lambda 之前，字节数组不会被垃圾回收。

Answer 4

埃里克·利珀特的回答确实击中了要点。然而，最好能构建一幅关于堆栈帧和捕获一般如何工作的图片。为此，查看一个稍微复杂的示例会有所帮助。

这是捕获代码：

public class Scorekeeper { 
   int swish = 7; 

   public Action Counter(int start)
   {
      int count = 0;
      Action counter = () => { count += start + swish; }
      return counter;
   }
}

这是我认为等效的内容（如果我们幸运的话，Eric Lippert 会评论这是否实际上正确）：

private class Locals
{
  public Locals( Scorekeeper sk, int st)
  { 
      this.scorekeeper = sk;
      this.start = st;
  } 

  private Scorekeeper scorekeeper;
  private int start;

  public int count;

  public void Anonymous()
  {
    this.count += start + scorekeeper.swish;
  }
}

public class Scorekeeper {
    int swish = 7;

    public Action Counter(int start)
    {
      Locals locals = new Locals(this, start);
      locals.count = 0;
      Action counter = new Action(locals.Anonymous);
      return counter;
    }
}

要点是本地类替代了整个堆栈帧，并且是每次调用 Counter 方法时都会进行相应的初始化。通常，堆栈帧包括对“this”的引用、方法参数以及局部变量。 （当进入控制块时，堆栈帧实际上也会扩展。）

因此，我们不仅仅有一个与捕获的上下文相对应的对象，相反，我们实际上每个捕获的堆栈帧都有一个对象。

基于此，我们可以使用以下心理模型：堆栈帧保存在堆上（而不是堆栈上），而堆栈本身只包含指向堆上堆栈帧的指针。 Lambda 方法包含指向堆栈帧的指针。这是使用托管内存完成的，因此帧会保留在堆上，直到不再需要为止。

显然，当需要堆对象支持 lambda 闭包时，编译器可以仅使用堆来实现这一点。

我喜欢这个模型的地方在于它提供了“收益回报”的综合图景。我们可以认为迭代器方法（使用yield return）就好像它的堆栈帧是在堆上创建的，并且引用指针存储在调用者的局部变量中，以供在迭代期间使用。