c# - Acceso al cierre modificado(2)

.net resharper

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 reviso el 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, necesita volver a declarar una variable dentro de foreach; de lo contrario, se comparte y todos sus manejadores usarán 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 desde C # 5 en adelante, esto ha cambiado, y específicamente en el caso de foreach , ya no necesita hacer esto: el código en la pregunta funcionaría como se esperaba.

Para mostrar que esto no funciona sin este cambio, considere 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);
}

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

Esto se debe a que la especificación de idioma (ECMA 334 v4, 15.8.4) (anterior a C # 5) define:

foreach (V v in x) embedded-statement luego 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 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.

Desde C # 5 en adelante, esto se cambia: la variable de iteración ( v ) tiene un alcance dentro del bucle. 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
    }
}

Reinscribirse; si desea cancelar activamente la suscripción de un controlador anónimo, el truco consiste en capturar el controlador mismo:

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

Del mismo modo, si desea un controlador de eventos de una sola vez (como Cargar, etc.):

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

Esto ahora es autodesubscribirse ;-p