我遇到了一个有趣的 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。
看起来是由于所有的动作都引用了一个捕获变量。因此，当它们被调用时，它们都具有相同的输出。
有没有一种方法可以解决这个限制，让每个动作实例都有自己的捕获变量？
是的 - 在循环内部取变量的副本：
while (variable < 5)
{
int copy = variable;
actions.Add(() => copy * 2);
++ variable;
}
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.2节，以及我的有关闭包的文章也有更多示例。
需要注意的是，在C# 5编译器及以上版本（即使在指定早期版本的C#时），foreach的行为已经改变，因此您不再需要创建局部副本。有关详细信息，请参见这个答案。
我认为你所经历的是一种称为闭包的东西 http://en.wikipedia.org/wiki/Closure_(computer_science)。你的lambda函数引用了一个在函数外部作用域的变量。只有在调用lambda函数时才会对其进行解释，此时它将获得变量在执行时的值。
在幕后，编译器正在生成一个表示您方法调用的闭包的类。它为循环的每次迭代使用该闭包类的单个实例。以下代码大致如此，可以更容易地看出为什么会出现 bug：
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;
}
}
这实际上不是您示例中的编译代码，但我已经检查了自己的代码，这看起来非常像编译器实际生成的内容。
此行为是由于在 lambda 表达式 () => variable * 2 中使用了外部作用域中未在 lambda 的内部作用域中定义的变量 variable 所触发的。
Lambda 表达式（在 C#3+ 中，以及在 C#2 中的匿名方法）仍然会创建实际的方法。将变量传递给这些方法涉及一些困境（按值传递？按引用传递？C# 使用按引用传递 - 但这会打开另一个问题，即引用可能会超出实际变量的生命周期）。C# 解决所有这些困境的方法是创建一个新的帮助类（“闭包”），其字段对应于在 lambda 表达式中使用的局部变量，并且方法对应于实际的 lambda 方法。您代码中对 variable 的任何更改实际上都被翻译为对那个 ClosureClass.variable 的更改。
因此，您的 while 循环将不断更新 ClosureClass.variable，直到达到 10，然后您的 for 循环执行操作，所有操作都操作相同的 ClosureClass.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());
}
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;
}
解决方法是将需要的值存储在代理变量中，并使该变量被捕获。
例如：
while( variable < 5 )
{
int copy = variable;
actions.Add( () => copy * 2 );
++variable;
}
是的，你需要在循环内部限定变量并将其传递给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();
在多线程（C＃，.NET 4.0）中出现了相同的情况。
请参见以下代码：
目的是按顺序打印1,2,3,4,5。
for (int counter = 1; counter <= 5; counter++)
{
new Thread (() => Console.Write (counter)).Start();
}
输出结果很有趣！（可能像21334...）
唯一的解决方案是使用本地变量。
for (int counter = 1; counter <= 5; counter++)
{
int localVar= counter;
new Thread (() => Console.Write (localVar)).Start();
}
actions.Add(() => variable * 2);
[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
public int variable;
internal int <Main>b__0()
{
return variable * 2;
}
}
<>c__DisplayClass0_.variable = 0;
while (<>c__DisplayClass0_.variable < 5)
{
list.Add(new Func<int>(<>c__DisplayClass0_.<Main>b__0));
<>c__DisplayClass0_.variable++;
}
while (variable < 5)
{
var index = variable; // <= this line
actions.Add(() => index * 2);
++ variable;
}
for (int n=0; n < 10; n++) //forloop syntax
foreach (string item in foo) foreach syntax
这被称为闭包问题，只需使用一个复制变量，问题就解决了。
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());
}