Dostęp do zmodyfikowanego zamknięcia (2)

To jest rozszerzenie pytania z Access to Modified Closure . Chcę tylko sprawdzić, czy poniższe elementy są wystarczająco bezpieczne do użytku produkcyjnego.

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

Wykonuję powyższe tylko raz dla każdego uruchomienia. Na razie wydaje się, że działa dobrze. Jak Jon wspomniał o sprzecznych z intuicją wynikach w niektórych przypadkach. Więc na co muszę tutaj uważać? Czy będzie dobrze, jeśli lista zostanie sprawdzona więcej niż raz?

Przed C # 5 musisz ponownie zadeklarować zmienną wewnątrz foreach - w przeciwnym razie jest ona współdzielona, ​​a wszystkie twoje programy obsługi będą używać ostatniego ciągu:

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

Co ważne, zwróć uwagę, że od C # 5 to się zmieniło, a konkretnie w przypadkuforeach , nie musisz już tego robić: kod w pytaniu działałby zgodnie z oczekiwaniami.

Aby pokazać, że to nie działa bez tej zmiany, rozważ następujące kwestie:

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

Uruchom powyższe przed C # 5 i chociaż każdy przycisk wyświetla inną nazwę, kliknięcie przycisku powoduje wyświetlenie „Wilma” cztery razy.

Dzieje się tak, ponieważ specyfikacja języka (ECMA 334 v4, 15.8.4) (przed C # 5) definiuje:

foreach (V v in x) embedded-statement jest następnie rozszerzany do:

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

Zauważ, że zmienna v(twoja list) jest zadeklarowana poza pętlą. Zatem zgodnie z regułami przechwyconych zmiennych, wszystkie iteracje listy będą miały wspólny uchwyt przechwyconej zmiennej.

Począwszy od C # 5, zostało to zmienione: zmienna iteracji ( v) jest objęta zakresem wewnątrz pętli. Nie mam odniesienia do specyfikacji, ale w zasadzie wygląda to następująco:

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

Re anulowanie subskrypcji; jeśli chcesz aktywnie anulować subskrypcję anonimowego programu obsługi, sztuczka polega na przechwyceniu samego modułu obsługi:

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

Podobnie, jeśli potrzebujesz jednorazowej obsługi zdarzeń (na przykład Load itp.):

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

To jest teraz samodzielna rezygnacja z subskrypcji ;-p