Zugang zu modifizierter Schließung (2)

Dies ist eine Erweiterung der Frage von Access to Modified Closure . Ich möchte nur überprüfen, ob das Folgende tatsächlich sicher genug für die Verwendung in der Produktion ist.

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

Ich laufe die oben genannten nur einmal pro Start durch. Im Moment scheint es in Ordnung zu funktionieren. Wie Jon über kontraintuitives Ergebnis in einigen Fällen erwähnt hat. Was muss ich hier beachten? Wird es in Ordnung sein, wenn die Liste mehr als einmal durchlaufen wird?

Vor C # 5 müssen Sie eine Variable in foreach erneut deklarieren. Andernfalls wird sie gemeinsam genutzt, und alle Ihre Handler verwenden die letzte Zeichenfolge:

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

Beachten Sie, dass sich dies ab C # 5 geändert hat und Sie dies insbesondere im Fall vonforeach nicht mehr tun müssen: Der Code in der Frage würde wie erwartet funktionieren.

Beachten Sie Folgendes, um zu zeigen, dass dies ohne diese Änderung nicht funktioniert:

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

Führen Sie die obigen Schritte vor C # 5 aus . Obwohl jede Schaltfläche einen anderen Namen aufweist, wird beim Klicken auf die Schaltflächen viermal "Wilma" angezeigt.

Dies liegt daran, dass die Sprachspezifikation (ECMA 334 v4, 15.8.4) (vor C # 5) definiert:

foreach (V v in x) embedded-statement wird dann erweitert auf:

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

Beachten Sie, dass die Variable v(die Ihre ist list) außerhalb der Schleife deklariert ist . Nach den Regeln der erfassten Variablen teilen sich alle Iterationen der Liste den Inhaber der erfassten Variablen.

Ab C # 5 wird dies geändert: Die Iterationsvariable ( v) befindet sich innerhalb der Schleife. Ich habe keine Spezifikationsreferenz, aber es wird im Grunde:

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

Abmelden; Wenn Sie einen anonymen Handler aktiv abbestellen möchten, besteht der Trick darin, den Handler selbst zu erfassen:

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

Ebenso, wenn Sie einen einmaligen Ereignishandler (wie z. B. Laden usw.) möchten:

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

Dies ist jetzt selbst abbestellend ;-p