El identificador de foreach y cierres

Question

En los dos fragmentos siguientes, ¿es seguro el primero o debe hacer el segundo?

Con seguridad quiero decir que cada hilo garantiza llamar al método en el Foo desde la misma iteración de bucle en la que se creó el subproceso?

¿O debe copiar la referencia a una nueva variable "local" en cada iteración del ciclo?

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

Actualización: Como se señaló en la respuesta de Jon Skeet, esto no tiene nada que ver específicamente con rosca.

Answer 1

Editar: todo esto cambia en C# 5, con un cambio en donde se define la variable (a los ojos del compilador). Desde C# 5 en adelante, son lo mismo.

---

El segundo es seguro; el primero no es.

Con foreach, la variable se declara fuera el bucle - es decir

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

Esto significa que sólo hay 1 f en términos del alcance de cierre, y los hilos podría muy probable que se confunda - pidiendo el método varias veces en algunas instancias y nada en otras. Puedes solucionar este problema con una segunda declaración de variables dentro del bucle:

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

Esto entonces tiene una separada tmp en cada ámbito de cierre, así que no hay riesgo de este problema.

Aquí es una prueba sencilla del problema:

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

salidas (al azar):

1 
3 
4 
4 
5 
7 
7 
8 
9 
9 

agregar una variable temporal y funciona:

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

(cada número una vez, pero por supuesto la orden no está garantizada)

Answer 2

Foo f2 = f; 

apunta a la misma referencia que

f 

Así que nada pierde y no gana ...

Answer 3

Su necesidad opción 2 para usar, creando un cierre alrededor de una variable cambiante utilizará el valor de la variable cuando se usa la variable y no en el momento de creación del cierre.

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)

Editar: para que quede claro, en C# cierres son "cierres léxicas", que significa que no captan el valor de una variable, pero la propia variable. Eso significa que al crear un cierre a una variable cambiante, el cierre es realmente una referencia a la variable, no una copia de su valor.

Edit2: agregó enlaces a todas las publicaciones del blog si alguien está interesado en leer sobre el compilador interno.

Answer 4

Las respuestas de Pop Catalin y Marc Gravell son correctas. Todo lo que quiero agregar es un enlace al my article about closures (que habla sobre Java y C#). Solo pensé que podría agregar un poco de valor.

EDIT: Creo que vale la pena dar un ejemplo que no tiene la imprevisibilidad de enhebrar. Aquí hay un programa corto pero completo que muestra ambos enfoques. La lista de "acción incorrecta" imprime 10 veces; la lista "buena acción" cuenta de 0 a 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

Ésta es una cuestión interesante y parece que hemos visto la gente responde en todas las diversas maneras. Tenía la impresión de que la segunda forma sería la única manera segura. He batido una prueba muy rápida:

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

Si ejecuta esto, verá que la opción 1 definitivamente no es segura.

Answer 6

En su caso, puede evitar el problema sin necesidad de utilizar el truco de copia mediante la asignación de su ListOfFoo a una secuencia de hilos:

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

Answer 7

Ambos son seguros como de C# versión 5 (NET Framework 4.5). Ver esta pregunta para más detalles: Has foreach's use of variables been changed in C# 5?