闭包在幕后是如何工作的？ （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 对象一样工作；在它不再植根之前，它没有资格进行垃圾收集。这意味着只要您有对该方法的可调用引用，它就不会去任何地方。

Answer 3

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

Answer 4

Eric Lippert 的回答确实切中要害。但是，最好构建一张关于堆栈帧和捕获通常如何工作的图片。要做到这一点，看一个稍微复杂一点的例子会有所帮助。

这里是捕获代码：

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）想象成它的堆栈帧是在堆上创建的，并且引用指针存储在调用者的局部变量中，以供迭代期间使用。