foreach标识符和闭包

在接下来的两个摘要中，第一个是安全的还是第二个必须做？

安全地说，每个线程是否保证从创建线程的同一循环迭代中调用Foo上的方法？

还是必须将引用复制到新变量“ local”到循环的每次迭代中？

var threads = new List<Thread>();
foreach (Foo f in ListOfFoo)
{      
    Thread thread = new Thread(() => f.DoSomething());
    threads.Add(thread);
    thread.Start();
}

--

var threads = new List<Thread>();
foreach (Foo f in ListOfFoo)
{      
    Foo f2 = f;
    Thread thread = new Thread(() => f2.DoSomething());
    threads.Add(thread);
    thread.Start();
}

更新：正如Jon Skeet的答案中指出的那样，这与线程无关。

编辑：在C＃5中，所有这些都发生了变化，更改了定义变量的位置（在编译器看来）。从C＃5开始，它们是相同的。

在C＃5之前

第二个是安全的；第一个不是。

使用foreach，变量在循环外部声明-即

Foo f;
while(iterator.MoveNext())
{
     f = iterator.Current;
    // do something with f
}

这意味着f就闭包范围而言只有1 ，并且线程很可能会感到困惑-在某些实例上多次调用该方法，而在其他实例上根本不调用该方法。你可以用第二个变量声明，解决这个问题的内部循环：

foreach(Foo f in ...) {
    Foo tmp = f;
    // do something with tmp
}

然后，tmp在每个关闭范围中都有一个单独的位置，因此没有发生此问题的风险。

这是问题的简单证明：

    static void Main()
    {
        int[] data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        foreach (int i in data)
        {
            new Thread(() => Console.WriteLine(i)).Start();
        }
        Console.ReadLine();
    }

输出（随机）：

1
3
4
4
5
7
7
8
9
9

添加一个临时变量，它可以工作：

        foreach (int i in data)
        {
            int j = i;
            new Thread(() => Console.WriteLine(j)).Start();
        }

（每个号码一次，但是当然不能保证顺序）

Pop Catalin和Marc Gravell的答案是正确的。我要添加的只是指向我有关闭包的文章的链接（该文章讨论了Java和C＃）。只是认为这可能会增加一些价值。

编辑：我认为值得举一个例子，它没有线程的不可预测性。这是一个简短但完整的程序，显示了两种方法。“不良行为”列表将打印出10十次；“好的操作”列表从0到9。

using System;
using System.Collections.Generic;

class Test
{
    static void Main() 
    {
        List<Action> badActions = new List<Action>();
        List<Action> goodActions = new List<Action>();
        for (int i=0; i < 10; i++)
        {
            int copy = i;
            badActions.Add(() => Console.WriteLine(i));
            goodActions.Add(() => Console.WriteLine(copy));
        }
        Console.WriteLine("Bad actions:");
        foreach (Action action in badActions)
        {
            action();
        }
        Console.WriteLine("Good actions:");
        foreach (Action action in goodActions)
        {
            action();
        }
    }
}

您需要使用选项2，在更改变量周围创建闭包，将在使用变量时而不是在闭包创建时使用变量的值。

C＃中匿名方法的实现及其后果（第1部分）

C＃中匿名方法的实现及其后果（第2部分）

C＃中匿名方法的实现及其后果（第3部分）

编辑：明确地说，在C＃中，闭包是“词法闭包”，这意味着它们不捕获变量的值，而是变量本身。这意味着在为更改的变量创建闭包时，闭包实际上是对变量的引用，而不是其值的副本。

Edit2：如果有人有兴趣阅读有关编译器内部的信息，请添加指向所有博客文章的链接。

这是一个有趣的问题，似乎我们已经看到人们以各种方式回答。我的印象是第二种方法是唯一安全的方法。我打了一个真实的快速证明：

class Foo
{
    private int _id;
    public Foo(int id)
    {
        _id = id;
    }
    public void DoSomething()
    {
        Console.WriteLine(string.Format("Thread: {0} Id: {1}", Thread.CurrentThread.ManagedThreadId, this._id));
    }
}
class Program
{
    static void Main(string[] args)
    {
        var ListOfFoo = new List<Foo>();
        ListOfFoo.Add(new Foo(1));
        ListOfFoo.Add(new Foo(2));
        ListOfFoo.Add(new Foo(3));
        ListOfFoo.Add(new Foo(4));


        var threads = new List<Thread>();
        foreach (Foo f in ListOfFoo)
        {
            Thread thread = new Thread(() => f.DoSomething());
            threads.Add(thread);
            thread.Start();
        }
    }
}

如果运行此选项，将会看到选项1绝对不安全。

在您的情况下，可以通过将您ListOfFoo的线程映射到一系列线程来避免问题，而无需使用复制技巧：

var threads = ListOfFoo.Select(foo => new Thread(() => foo.DoSomething()));
foreach (var t in threads)
{
    t.Start();
}

从C＃版本5（.NET Framework 4.5）开始，两者都是安全的。有关详细信息，请参见此问题：C＃5中的foreach变量用法是否已更改？

Foo f2 = f;

指向与

f 

因此，什么也没有损失，也没有收获...