Apakah ada alasan untuk penggunaan ulang C # dari variabel dalam foreach?

Saat menggunakan ekspresi lambda atau metode anonim di C #, kita harus waspada terhadap akses ke perangkap penutupan yang dimodifikasi . Sebagai contoh:

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

Karena penutupan yang dimodifikasi, kode di atas akan menyebabkan semua Whereklausa pada kueri didasarkan pada nilai akhir dari s.

Seperti yang dijelaskan di sini , ini terjadi karena svariabel yang dideklarasikan dalam foreachloop di atas diterjemahkan seperti ini di kompiler:

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

bukannya seperti ini:

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

Seperti yang ditunjukkan di sini , tidak ada keuntungan kinerja untuk mendeklarasikan variabel di luar loop, dan dalam keadaan normal satu-satunya alasan yang dapat saya pikirkan untuk melakukan ini adalah jika Anda berencana untuk menggunakan variabel di luar lingkup loop:

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

Namun variabel yang didefinisikan dalam satu foreachloop tidak dapat digunakan di luar loop:

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

Jadi kompilator mendeklarasikan variabel dengan cara yang membuatnya sangat rentan terhadap kesalahan yang seringkali sulit ditemukan dan didebug, sementara tidak menghasilkan manfaat yang dapat dilihat.

Apakah ada sesuatu yang dapat Anda lakukan dengan foreachloop dengan cara ini yang Anda tidak bisa jika mereka dikompilasi dengan variabel cakupan dalam, atau apakah ini hanya pilihan sewenang-wenang yang dibuat sebelum metode anonim dan ekspresi lambda tersedia atau umum, dan yang tidak memiliki sudah direvisi sejak saat itu?

Compiler mendeklarasikan variabel dengan cara yang membuatnya sangat rentan terhadap kesalahan yang seringkali sulit ditemukan dan didebug, sementara tidak menghasilkan manfaat yang dapat dilihat.

Kritik Anda sepenuhnya dibenarkan.

Saya membahas masalah ini secara rinci di sini:

Menutup variabel loop dianggap berbahaya

Apakah ada sesuatu yang dapat Anda lakukan dengan loop foreach dengan cara ini bahwa Anda tidak bisa jika mereka dikompilasi dengan variabel cakupan-dalam? atau apakah ini hanya pilihan sewenang-wenang yang dibuat sebelum metode anonim dan ekspresi lambda tersedia atau umum, dan yang belum direvisi sejak saat itu?

Yang terakhir. Spesifikasi C # 1.0 sebenarnya tidak mengatakan apakah variabel loop berada di dalam atau di luar tubuh loop, karena tidak membuat perbedaan yang dapat diamati. Ketika semantik penutupan diperkenalkan di C # 2.0, pilihan dibuat untuk meletakkan variabel loop di luar loop, konsisten dengan loop "for".

Saya pikir itu adil untuk mengatakan bahwa semua menyesali keputusan itu. Ini adalah salah satu "gotcha" terburuk di C #, dan kami akan mengambil perubahan untuk memperbaikinya. Dalam C # 5 variabel loop foreach akan secara logis di dalam tubuh loop, dan karena itu penutupan akan mendapatkan salinan baru setiap kali.

The forLoop tidak akan berubah, dan perubahan tidak akan "kembali porting" dengan versi sebelumnya dari C #. Karena itu Anda harus terus berhati-hati saat menggunakan idiom ini.

Apa yang Anda tanyakan sepenuhnya dibahas oleh Eric Lippert dalam posting blognya. Menutup variabel loop yang dianggap berbahaya dan sekuelnya.

Bagi saya, argumen yang paling meyakinkan adalah bahwa memiliki variabel baru di setiap iterasi tidak akan konsisten dengan for(;;)loop gaya. Apakah Anda berharap memiliki yang baru int idi setiap iterasi for (int i = 0; i < 10; i++)?

Masalah yang paling umum dengan perilaku ini adalah membuat penutupan atas variabel iterasi dan memiliki solusi yang mudah:

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

Posting blog saya tentang masalah ini: Penutupan atas variabel foreach dalam C # .

Setelah digigit oleh ini, saya memiliki kebiasaan memasukkan variabel yang didefinisikan secara lokal dalam lingkup terdalam yang saya gunakan untuk mentransfer ke penutupan apa pun. Dalam contoh Anda:

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

Saya lakukan:

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

Setelah Anda memiliki kebiasaan itu, Anda dapat menghindarinya dalam kasus yang sangat jarang Anda maksudkan untuk mengikat ke luar lingkup. Sejujurnya, saya tidak berpikir saya pernah melakukannya.

Di C # 5.0, masalah ini diperbaiki dan Anda bisa menutup variabel loop dan mendapatkan hasil yang Anda harapkan.

Spesifikasi bahasa mengatakan:

8.8.4 Pernyataan foreach

(...)

Pernyataan formulir di muka

foreach (V v in x) embedded-statement

kemudian diperluas ke:

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

(...)

Penempatan vdi dalam loop sementara penting untuk bagaimana itu ditangkap oleh fungsi anonim yang terjadi dalam pernyataan-tertanam. Sebagai contoh:

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

Jika vdideklarasikan di luar loop sementara, itu akan dibagikan di antara semua iterasi, dan nilainya setelah loop untuk akan menjadi nilai akhir 13,, yang merupakan doa yang fakan dicetak. Alih-alih, karena setiap iterasi memiliki variabelnya sendiri v, variabel yang ditangkap oleh fiterasi pertama akan terus memiliki nilai 7, yang akan dicetak. ( Catatan: versi C # sebelumnya dinyatakan di vluar loop sementara. )