Acceso al cierre modificado (2)

Question

Esta es una extensión de la pregunta de Access to Modified Closure. Solo quiero verificar si lo siguiente es lo suficientemente seguro para el uso en producción.

List<string> lists = new List<string>(); 
//Code to retrieve lists from DB  
foreach (string list in lists) 
{ 
    Button btn = new Button(); 
    btn.Click += new EventHandler(delegate { MessageBox.Show(list); }); 
} 

Solo ejecuto lo anterior una vez por inicio. Por ahora parece funcionar bien. Como Jon ha mencionado sobre el resultado contrario a la intuición en algún caso. Entonces, ¿qué tengo que tener cuidado aquí? ¿Estará bien si la lista se ejecuta más de una vez?

Answer 1

Antes de C# 5, es necesario volver a declarar una variable dentro el foreach - de lo contrario, se comparte, y todos sus manipuladores usará la última cadena:

foreach (string list in lists) 
{ 
    string tmp = list; 
    Button btn = new Button(); 
    btn.Click += new EventHandler(delegate { MessageBox.Show(tmp); }); 
} 

Significativamente, tenga en cuenta que a partir de C# 5 en adelante, esto ha cambiado, y específicamente en el caso de foreach, no necesita hacer esto más: el código en la pregunta funcionaría como se esperaba.

Para mostrar esto no funciona sin este cambio, tenga en cuenta lo siguiente:

string[] names = { "Fred", "Barney", "Betty", "Wilma" }; 
using (Form form = new Form()) 
{ 
    foreach (string name in names) 
    { 
     Button btn = new Button(); 
     btn.Text = name; 
     btn.Click += delegate 
     { 
      MessageBox.Show(form, name); 
     }; 
     btn.Dock = DockStyle.Top; 
     form.Controls.Add(btn); 
    } 
    Application.Run(form); 
} 

Ejecutar lo anterior antes de C# 5, y aunque cada botón muestra un nombre diferente, haciendo clic en los botones de muestra "Wilma" cuatro veces.

Esto es porque la especificación de lenguaje (ECMA 334 v4, 15.8.4) (antes C# 5) define:

foreach (V v in x)embedded-statement continuación se expande a:

{ 
    E e = ((C)(x)).GetEnumerator(); 
    try { 
     V v; 
     while (e.MoveNext()) { 
      v = (V)(T)e.Current; 
      embedded-statement 
     } 
    } 
    finally { 
     … // Dispose e 
    } 
} 

Tenga en cuenta que la variable v (que es su list) se declara fuera de del bucle. Entonces, según las reglas de las variables capturadas, todas las iteraciones de la lista compartirán el titular de la variable capturada.

De C# 5 en adelante, esto se cambia: la variable de iteración (v) tiene un ámbito dentro de el bucle. Yo no tengo una referencia de especificación, pero básicamente se convierte en:

{ 
    E e = ((C)(x)).GetEnumerator(); 
    try { 
     while (e.MoveNext()) { 
      V v = (V)(T)e.Current; 
      embedded-statement 
     } 
    } 
    finally { 
     … // Dispose e 
    } 
} 

---

Re darse de baja; si quieres activamente para darse de baja un controlador en el anonimato, el truco consiste en capturar el manejador en sí:

EventHandler foo = delegate {...code...}; 
obj.SomeEvent += foo; 
... 
obj.SomeEvent -= foo; 

Del mismo modo, si usted quiere una sola vez controlador de eventos (por ejemplo, carga, etc):

EventHandler bar = null; // necessary for "definite assignment" 
bar = delegate { 
    // ... code 
    obj.SomeEvent -= bar; 
}; 
obj.SomeEvent += bar; 

Esto ahora es autodesubscribing ;-p