C # 'ın bir foreach içinde değişkeni yeniden kullanmasının bir nedeni var mı?

C # 'da lambda ifadeleri veya anonim yöntemler kullanırken , değiştirilmiş kapatma tuzağına erişim konusunda dikkatli olmalıyız . Örneğin:

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

Değiştirilen kapatma nedeniyle, yukarıdaki kod Where, sorgudaki tüm yan tümcelerin son değerine dayanmasına neden olur s.

As açıkladı buradan çünkü bu durumda, sdeğişken beyan foreachyukarıdaki derleyici böyle çevrilmiştir döngü:

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

bunun yerine:

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

Belirttiği gibi burada , döngü dışında bir değişkeni bildirmek için herhangi bir performans avantajları vardır ve döngü kapsamı dışında değişkeni kullanmayı planlıyorsanız normal şartlar altında tek nedeni budur yapmak için düşünebilirsiniz:

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

Ancak bir foreachdöngüde tanımlanan değişkenler döngü dışında kullanılamaz:

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

Böylece derleyici, değişkeni, algılanabilir fayda üretmezken, genellikle bulunması ve hata ayıklaması zor olan bir hataya son derece eğilimli olacak şekilde bildirir.

foreachBu şekilde döngülerle yapabileceğiniz bir şey var mı, iç kapsamlı bir değişkenle derlenmişlerse yapamazsınız mı, yoksa bu sadece anonim yöntemler ve lambda ifadeleri kullanılabilir veya yaygın olandan önce yapılan keyfi bir seçim mi? O zamandan beri revize edilmedi mi?

Derleyici, değişkeni, algılanabilecek hiçbir fayda üretmezken, genellikle bulunması ve hata ayıklaması zor olan bir hataya oldukça eğilimli olacak şekilde bildirir.

Eleştiriniz tamamen haklı.

Bu sorunu burada ayrıntılı olarak tartışıyorum:

Zararlı sayılan döngü değişkeninin kapatılması

Her şekilde foreach döngüleri ile yapabileceğiniz bir şey var mı? ya da bu sadece anonim yöntemler ve lambda ifadeleri kullanıma sunulmadan ya da yaygınlaştırılmadan yapılan ve o zamandan beri revize edilmemiş keyfi bir seçim mi?

İkincisi. C # 1.0 spesifikasyonu aslında loop değişkeninin loop gövdesinin içinde mi yoksa dışında mı olduğunu söylemedi, çünkü gözlemlenebilir bir fark yaratmadı. Kapatma semantiği C # 2.0'da tanıtıldığında, döngü değişkenini "for" döngüsüyle tutarlı olarak döngü dışına koymak için seçim yapıldı.

Herkesin bu karardan pişman olduğunu söylemenin adil olduğunu düşünüyorum. Bu C # en kötü "gotchas" biridir ve biz bunu düzeltmek için kırılma değişikliği alacak. C 5. yılında foreach döngüsü değişken mantıksal olacak iç döngü gövdesinde ve bu nedenle kapanışları taze kopyaya her zaman alacak.

forDöngü değiştirilmeyecek ve değişiklik olmayacak C # önceki sürümleri "geri taşıdık". Bu nedenle, bu deyimi kullanırken dikkatli olmaya devam etmelisiniz.

Ne soruyorsun iyice onun blog yazısı Eric Lippert kapsamındadır döngü değişkeni üzerinde Kapanış zararlı kabul ve devam filmi.

Benim için en ikna edici argüman, her yinelemede yeni değişkene sahip olmanın for(;;)stil döngüsüyle tutarsız olacağıdır. int iHer bir yinelemesinde yeni olmasını bekler misiniz for (int i = 0; i < 10; i++)?

Bu davranışla ilgili en yaygın sorun yineleme değişkeni üzerinde bir kapatma yapmaktır ve kolay bir geçici çözümü vardır:

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

Bu sorunla ilgili blog yazım: C # 'da foreach değişkeni üzerinden kapanış .

Bu şekilde ısırıldıktan sonra, herhangi bir kapatmaya aktarmak için kullandığım en iç kapsamda yerel olarak tanımlanmış değişkenleri dahil etme alışkanlığım var. Örneğinizde:

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

Yaparım:

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

Bu alışkanlığınız olduğunda, aslında dış kapsamlara bağlamayı amaçladığınız çok nadir durumda bunu önleyebilirsiniz . Dürüst olmak gerekirse, şimdiye kadar yaptığımı sanmıyorum.

C # 5.0, bu sorun giderilmiştir ve döngü değişkenlerini kapatabilir ve beklediğiniz sonuçları alabilirsiniz.

Dil belirtimi şunları söylüyor:

8.8.4 Öngörme Beyanı

(...)

Formun foreach ifadesi

foreach (V v in x) embedded-statement

daha sonra şu değere genişletilir:

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

(...)

vWhile döngüsünün içine yerleştirme , gömülü deyimde meydana gelen anonim işlevler tarafından nasıl yakalandığı için önemlidir. Örneğin:

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

Eğer vwhile döngüsünün dışında ilan edildi, tüm tekrarlamalar arasında paylaşılan olacağını ve döngü için son değer olacağını geçtikçe değerini, 13ait çağırma budur fbasacaktır. Bunun yerine, her yinelemenin kendi değişkeni volduğu için f, ilk yinelemede yakalanan değer 7yazdırılacak olan değeri tutmaya devam edecektir. ( Not: vwhile döngüsünün dışında bildirilen C # 'ın önceki sürümleri . )