Идентификатор и замыкания foreach

Question

В двух следующих фрагментах, является первым безопасным или вы должны сделать второй?

Я уверен, что каждый поток гарантированно вызывает метод на 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(); 
} 

Update: Как указано в ответе Джона Скита, это не имеет ничего специально делать с резьбой.

Answer 1

Редактировать: все это изменяется в C# 5 с изменением на то, где переменная определена (в глазах компилятора). Начиная с C# 5, они одинаковы.

---

Второй безопасен; первое - нет.

С foreach, переменная объявлена ​​атмосферного цикл - т.е.

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

Это означает, что есть только 1 f с точки зрения объема закрытия, и потоки могли бы весьма вероятно, запутаться - вызов метод несколько раз в некоторых случаях и вовсе не на других. Вы можете исправить это с помощью второго объявления переменной внутри цикла:

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(); 
     } 

(каждый номер один раз, но, разумеется, заказ не гарантируется)

Answer 2

Foo f2 = f; 

указывает на то же ссылке как

f 

Так что ничего потеряно, и ничего не получил ...

Answer 3

Ваша потребность использовать вариант 2, создавая замыкание вокруг изменяющейся переменной будет использовать значение переменной, когда используется переменная, а не время создания закрытия.

The implementation of anonymous methods in C# and its consequences (part 1)

The implementation of anonymous methods in C# and its consequences (part 2)

The implementation of anonymous methods in C# and its consequences (part 3)

Edit: чтобы было понятно, в C# закрытия являются "лексические замыкания" означает, что они не учитывают значение переменной, но саму переменную. Это означает, что при создании замыкания на изменяющуюся переменную замыкание на самом деле является ссылкой на переменную, а не на копию ее значения.

Edit2: ссылки на все сообщения в блоге, если кто-то заинтересован в чтении о внутренних компонентах компилятора.

Answer 4

Ответы поп-Каталина и Марка Гравелла верны. Все, что я хочу добавить, это ссылка на my article about closures (в которой говорится о Java и C#). Просто подумал, что это может добавить немного ценности.

EDIT: Я думаю, что стоит привести пример, который не имеет непредсказуемости резьбы. Вот короткая, но полная программа, показывающая оба подхода. Список «плохого действия» распечатывается 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(); 
     } 
    } 
} 

Answer 5

Это интересный вопрос, и это, кажется, как мы видели, как люди отвечают на всех по-разному. У меня создалось впечатление, что второй путь будет единственным безопасным способом. Я взломал реальное быстрое доказательство:

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 определенно небезопасен.

Answer 6

В вашем случае, вы можете избежать проблем без использования копировальной трюк отображения вашего ListOfFoo последовательности нитей:

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

Answer 7

Оба являются безопасными от C# версии 5 (.NET Framework 4.5). См. Этот вопрос для деталей: Has foreach's use of variables been changed in C# 5?