在C＃中的循环中捕获的变量

Question

我遇到了一个关于C＃的有趣问题。我的代码如下。

List<Func<int>> actions = new List<Func<int>>();

int variable = 0;
while (variable < 5)
{
    actions.Add(() => variable * 2);
    ++ variable;
}

foreach (var act in actions)
{
    Console.WriteLine(act.Invoke());
}

我希望它输出0、2、4、6、8。但是，它实际上输出了五个10。

看来这是由于所有涉及一个捕获变量的动作所致。结果，当他们被调用时，它们都具有相同的输出。

有没有办法在此限制中工作以使每个动作实例都有自己的捕获变量？

Answer 1

是的 - 播放循环内部变量的副本：

while (variable < 5)
{
    int copy = variable;
    actions.Add(() => copy * 2);
    ++ variable;
}

您可以将其视为C＃编译器每次击中变量声明时都会创建“新”本地变量一样。实际上，它将创建适当的新闭合对象，如果您参考多个范围中的变量，它会变得复杂（在实现方面），但它有效:)

请注意，此问题更常见的发生是使用 for 或 foreach ：

for (int i=0; i < 10; i++) // Just one variable
foreach (string x in foo) // And again, despite how it reads out loud

有关此信息的更多详细信息，请参见C＃3.0规格的7.14.4.4节，以及我的有关关闭的文章也有更多示例。

请注意，从C＃5编译器及以后（即使指定较早版本的C＃）， foreach 的行为也更改了，因此您不再需要进行本地副本。请参阅答案有关更多详细信息。

Answer 2

我相信您所经历的是闭合的东西。您的lamba有一个引用一个变量，该变量在函数本身之外范围内进行了范围。在调用它之前，您的lamba不会被解释，并且一旦它将获得变量在执行时的值。

Answer 3

在幕后，编译器正在生成一个代表您方法呼叫的关闭的类。它使用循环的每个迭代使用闭合类的单个实例。该代码看起来像这样，这使您更容易查看为什么发生错误的原因：

void Main()
{
    List<Func<int>> actions = new List<Func<int>>();

    int variable = 0;

    var closure = new CompilerGeneratedClosure();

    Func<int> anonymousMethodAction = null;

    while (closure.variable < 5)
    {
        if(anonymousMethodAction == null)
            anonymousMethodAction = new Func<int>(closure.YourAnonymousMethod);

        //we're re-adding the same function 
        actions.Add(anonymousMethodAction);

        ++closure.variable;
    }

    foreach (var act in actions)
    {
        Console.WriteLine(act.Invoke());
    }
}

class CompilerGeneratedClosure
{
    public int variable;

    public int YourAnonymousMethod()
    {
        return this.variable * 2;
    }
}

这实际上不是您的示例中编译的代码，但是我已经检查了自己的代码，这看起来很像编译器实际生成的代码。

Answer 4

这与循环无关。

触发此行为是因为您使用lambda表达式（）=＆gt;变量 * 2 其中外部范围变量实际上未在lambda的内部范围中定义。

Lambda表达式（在C＃3+中以及C＃2中的匿名方法）仍然创建实际方法。将变量传递给这些方法涉及一些困境（按值传递？逐个引用？c＃通过参考将带来 - 但这打开了另一个问题，参考可以超过实际变量）。 C＃要解决所有这些困境的工作是创建一个新的助手类（“闭合”），其字段与lambda表达式中使用的局部变量相对应，以及与实际lambda方法相对应的方法。代码中对变量的任何更改实际上都会翻译为更改该 clocreclass.variable ，

因此您的wier loop不断更新 collecleclass.variable.variable 直到它到达10，然后您进行循环执行操作，所有操作都在相同的 colleclaclass.variable 上进行操作。

为了获得预期的结果，您需要在循环变量与正在关闭的变量之间创建一个分离。您可以通过引入另一个变量，即：

List<Func<int>> actions = new List<Func<int>>();
int variable = 0;
while (variable < 5)
{
    var t = variable; // now t will be closured (i.e. replaced by a field in the new class)
    actions.Add(() => t * 2);
    ++variable; // changing variable won't affect the closured variable t
}
foreach (var act in actions)
{
    Console.WriteLine(act.Invoke());
}

您也可以将闭合移动到创建此分隔的方法：

List<Func<int>> actions = new List<Func<int>>();

int variable = 0;
while (variable < 5)
{
    actions.Add(Mult(variable));
    ++variable;
}

foreach (var act in actions)
{
    Console.WriteLine(act.Invoke());
}

您可以将元用作lambda表达式（隐式闭合）

static Func<int> Mult(int i)
{
    return () => i * 2;
}

或实际助手类别实现：

public class Helper
{
    public int _i;
    public Helper(int i)
    {
        _i = i;
    }
    public int Method()
    {
        return _i * 2;
    }
}

static Func<int> Mult(int i)
{
    Helper help = new Helper(i);
    return help.Method;
}

无论如何：在任何情况下：“封闭”不是与环路< / strong>有关的概念，而是与匿名方法 / lambda表达式使用本地范围示波器变量的概念 - 尽管对环的某些不典型的使用表明了闭合陷阱。

Answer 5

这样做的方法是将所需的值存储在代理变量中，并捕获该变量。

IE

while( variable < 5 )
{
    int copy = variable;
    actions.Add( () => copy * 2 );
    ++variable;
}

Answer 6

是的，您需要在循环中范围变量将其传递给lambda：

List<Func<int>> actions = new List<Func<int>>();

int variable = 0;
while (variable < 5)
{
    int variable1 = variable;
    actions.Add(() => variable1 * 2);
    ++variable;
}

foreach (var act in actions)
{
    Console.WriteLine(act.Invoke());
}

Console.ReadLine();

Answer 7

多线程（c＃，。net 4.0

] ：

是打印1,2,3,4,5的顺序。

for (int counter = 1; counter <= 5; counter++)
{
    new Thread (() => Console.Write (counter)).Start();
}

目的

代码

for (int counter = 1; counter <= 5; counter++)
{
    int localVar= counter;
    new Thread (() => Console.Write (localVar)).Start();
}

Answer 8

正如其他人所说的那样，这与循环无关。这是c＃中匿名功能正文中变量捕获机制的效果。
当您将lambda定义为示例时；

actions.Add(() => variable * 2);

编译器生成一个容器类，例如＆lt;＆gt; c__displayClass0_0 for lambda函数
（）=＆gt; （）=＆gt;变量 * 2 。

在生成的类（容器）的内部，它生成一个名为 变量的字段 ，具有具有相同名称的捕获变量，而方法b__0（）包含lambda的主体。

[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
public int variable;

internal int <Main>b__0()
{
    return variable * 2;
}
}

而不是命名变量的局部变量，它成为容器类（＆lt;＆gt;＆gt; c__displayClass0_0）的字段，

<>c__DisplayClass0_.variable = 0;
while (<>c__DisplayClass0_.variable < 5)
{
    list.Add(new Func<int>(<>c__DisplayClass0_.<Main>b__0));
    <>c__DisplayClass0_.variable++;
}

因此递增变量结果转向集装箱类别的字段，并且因为我们获得了一个容器类的实例，用于While循环的所有迭代，我们将获得相同的输出

。 i.sstatic.net/1ds8x.png“ alt =“在此处输入图像说明”>

您可以通过将循环体内的捕获变量重新分配到新的本地变量中，以防新的局部变量

while (variable < 5)
{
    var index = variable; // <= this line
    actions.Add(() => index * 2);
    ++ variable;
}

，此行为仍然有效使用.NET 8预览，我发现这种行为非常越来越大。

Answer 9

for (int n=0; n < 10; n++) //forloop syntax
foreach (string item in foo) foreach syntax

Answer 10

它称为封闭问题，
只需使用复制变量即可完成。

List<Func<int>> actions = new List<Func<int>>();

int variable = 0;
while (variable < 5)
{
    int i = variable;
    actions.Add(() => i * 2);
    ++ variable;
}

foreach (var act in actions)
{
    Console.WriteLine(act.Invoke());
}

Answer 11

由于这里没有人直接引用 ecma-334 ：

语句的10.4.4.10

确定的分配检查以下表格：

for (for-initializer; for-condition; for-iterator) embedded-statement

就像写了语句一样：

{
    for-initializer;
    while (for-condition) {
        embedded-statement;
    LLoop: for-iterator;
    }
}

在规格中进一步，

12.16.6.3局部变量的实例化

当执行进入变量范围时，局部变量被认为是实例化的。

[示例：例如，当调用以下方法时，本地变量 x 是实例化并初始化了三次 - 每次迭代循环。

static void F() {
  for (int i = 0; i < 3; i++) {
    int x = i * 2 + 1;
    ...
  }
}

但是，将 x 的声明移动在循环外部导致 x 的单个实例化：

static void F() {
  int x;
  for (int i = 0; i < 3; i++) {
    x = i * 2 + 1;
    ...
  }
}

结束示例]

未被捕获时，无法确切观察到局部变量被实例化的频率 - 因为实例的寿命是不相交的，每个实例都可以简单地使用相同的存储位置。但是，当匿名函数捕获局部变量时，实例化的效果变得显而易见。

[示例：示例

using System;

delegate void D();

class Test{
  static D[] F() {
    D[] result = new D[3];
    for (int i = 0; i < 3; i++) {
      int x = i * 2 + 1;
      result[i] = () => { Console.WriteLine(x); };
    }
  return result;
  }
  static void Main() {
    foreach (D d in F()) d();
  }
}

产生输出：

1
3
5

但是，当 x 的声明在循环外移动时：

static D[] F() {
  D[] result = new D[3];
  int x;
  for (int i = 0; i < 3; i++) {
    x = i * 2 + 1;
    result[i] = () => { Console.WriteLine(x); };
  }
  return result;
}

输出为：

5
5
5

请注意，允许编译器（但不需要）将三个实例化到单个代表实例（§11.7.2）。

。

如果循环声明迭代变量，则该变量本身被认为是在循环之外声明的。
[示例：因此，如果更改了示例以捕获迭代变量本身：

static D[] F() {
  D[] result = new D[3];
  for (int i = 0; i < 3; i++) {
    result[i] = () => { Console.WriteLine(i); };
  }
  return result;
}

仅捕获迭代变量的一个实例，该实例产生输出：

3
3
3

结束示例]

，是的，我想应该提到的是，在C ++中没有发生此问题，因为您可以选择该变量是通过值或参考捕获的（请参阅： lambda捕获）。