Czy istnieje powód ponownego użycia zmiennej przez C # w foreach?

Korzystając z wyrażeń lambda lub anonimowych metod w języku C #, musimy uważać na dostęp do zmodyfikowanej pułapki zamknięcia . Na przykład:

foreach (var s in strings)
{
   query = query.Where(i => i.Prop == s); // access to modified closure
   ...
}

Ze względu na zmodyfikowane zamknięcie powyższy kod spowoduje, że wszystkie Whereklauzule w zapytaniu będą oparte na końcowej wartości s.

Jak wyjaśniono tutaj , dzieje się tak, ponieważ szmienna zadeklarowana w foreachpowyższej pętli jest tłumaczona w kompilatorze w następujący sposób:

string s;
while (enumerator.MoveNext())
{
   s = enumerator.Current;
   ...
}

zamiast tego:

while (enumerator.MoveNext())
{
   string s;
   s = enumerator.Current;
   ...
}

Jak wskazano tutaj , zadeklarowanie zmiennej poza pętlą nie ma żadnych korzyści w zakresie wydajności, aw normalnych okolicznościach jedynym powodem, dla którego mogę to zrobić, jest zaplanowanie użycia zmiennej poza zakresem pętli:

string s;
while (enumerator.MoveNext())
{
   s = enumerator.Current;
   ...
}
var finalString = s;

Jednak zmiennych zdefiniowanych w foreachpętli nie można używać poza pętlą:

foreach(string s in strings)
{
}
var finalString = s; // won't work: you're outside the scope.

Tak więc kompilator deklaruje zmienną w sposób, który czyni ją wysoce podatną na błąd, który często jest trudny do znalezienia i debugowania, a jednocześnie nie daje widocznych korzyści.

Czy istnieje coś, co można zrobić z foreachpętlami w ten sposób, czego nie można było zrobić, gdyby były one skompilowane ze zmienną o zasięgu wewnętrznym, czy jest to tylko arbitralny wybór, który został dokonany, zanim anonimowe metody i wyrażenia lambda były dostępne lub powszechne, a które nie nie został zmieniony od tego czasu?

Kompilator deklaruje zmienną w sposób, który czyni ją wysoce podatną na błąd, który często jest trudny do znalezienia i debugowania, a jednocześnie nie daje widocznych korzyści.

Twoja krytyka jest całkowicie uzasadniona.

Szczegółowo omawiam ten problem tutaj:

Zamykanie przez zmienną pętli uważane jest za szkodliwe

Czy jest coś, co można zrobić z pętlami foreach w ten sposób, czego nie można było zrobić, gdyby były one skompilowane ze zmienną o zasięgu wewnętrznym? czy jest to tylko arbitralny wybór dokonany, zanim anonimowe metody i wyrażenia lambda były dostępne lub powszechne, i które od tego czasu nie zostały zmienione?

Ten ostatni. Specyfikacja C # 1.0 w rzeczywistości nie mówiła, czy zmienna pętli znajduje się wewnątrz czy poza ciałem pętli, ponieważ nie robiło to zauważalnej różnicy. Kiedy semantyka zamykania została wprowadzona w C # 2.0, wybrano opcję umieszczenia zmiennej pętli poza pętlą, zgodnie z pętlą „for”.

Myślę, że uczciwie jest powiedzieć, że wszyscy żałują tej decyzji. Jest to jeden z najgorszych „gotchas” w języku C # i zamierzamy wprowadzić przełomową zmianę, aby to naprawić. W C # 5 zmienna foreach loop będzie logicznie wewnątrz korpusu pętli, a zatem zamknięcia będą za każdym razem otrzymywały nową kopię.

forPętla nie zostanie zmieniony, a zmiana nie będzie „z powrotem przeniesiony” do poprzednich wersjach C #. Dlatego powinieneś nadal zachować ostrożność, używając tego idiomu.

To, o co pytasz, zostało dokładnie omówione przez Erica Lipperta w jego blogu Zamykanie pętli przez zmienną uważaną za szkodliwą i jej następstwo.

Dla mnie najbardziej przekonującym argumentem jest to, że posiadanie nowej zmiennej w każdej iteracji byłoby niespójne z for(;;)pętlą stylu. Czy spodziewałbyś się nowego int iw każdej iteracji for (int i = 0; i < 10; i++)?

Najczęstszym problemem związanym z tym zachowaniem jest zamknięcie zmiennej iteracyjnej i ma ona łatwe obejście:

foreach (var s in strings)
{
    var s_for_closure = s;
    query = query.Where(i => i.Prop == s_for_closure); // access to modified closure

Mój post na blogu na ten temat: Zamknięcie nad zmienną foreach w języku C # .

Ugryziony przez to mam zwyczaj włączać zmienne zdefiniowane lokalnie w najbardziej wewnętrzny zakres, którego używam do przeniesienia do dowolnego zamknięcia. W twoim przykładzie:

foreach (var s in strings)
    query = query.Where(i => i.Prop == s); // access to modified closure

Ja robię:

foreach (var s in strings)
{
    string search = s;
    query = query.Where(i => i.Prop == search); // New definition ensures unique per iteration.
}        

Kiedy już będziesz miał ten nawyk, możesz go uniknąć w bardzo rzadkim przypadku, w którym zamierzałeś związać się z zewnętrznymi celami. Szczerze mówiąc, nie sądzę, żebym kiedykolwiek to zrobił.

W C # 5.0 problem został rozwiązany i można zamknąć zmienne pętli i uzyskać oczekiwane wyniki.

Specyfikacja języka mówi:

8.8.4 Oświadczenie foreach

(...)

Foreach oświadczenie formularza

foreach (V v in x) embedded-statement

jest następnie rozwijany do:

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

(...)

Umieszczenie vwewnątrz pętli while jest ważne dla tego, jak jest przechwytywana przez dowolną anonimową funkcję występującą w instrukcji osadzonej. Na przykład:

int[] values = { 7, 9, 13 };
Action f = null;
foreach (var value in values)
{
    if (f == null) f = () => Console.WriteLine("First value: " + value);
}
f();

Gdyby vzostał zadeklarowany poza pętlą while, byłby współużytkowany przez wszystkie iteracje, a jego wartość po pętli for byłaby wartością końcową 13, czyli to, co fwydrukowałoby wywołanie . Zamiast tego, ponieważ każda iteracja ma swoją zmienną v, ta przechwycona przez fpierwszą iterację będzie nadal przechowywać wartość 7, która zostanie wydrukowana. ( Uwaga: wcześniejsze wersje C # zadeklarowane vpoza pętlą while ).