มีเหตุผลสำหรับการใช้ตัวแปร C # ซ้ำใน foreach หรือไม่?

เมื่อใช้แลมบ์ดานิพจน์หรือวิธีที่ไม่ระบุตัวตนใน C # เราต้องระวังการเข้าถึงหลุมพรางปิดที่มีการแก้ไข ตัวอย่างเช่น:

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

เนื่องจากการปิดการปรับเปลี่ยนรหัสดังกล่าวข้างต้นจะทำให้ทั้งหมดของคำสั่งในการค้นหาให้เป็นไปตามค่าสุดท้ายของWheres

ดังที่อธิบายไว้ที่นี่สิ่งนี้เกิดขึ้นเพราะsตัวแปรที่ประกาศในforeachลูปด้านบนถูกแปลเช่นนี้ในคอมไพเลอร์:

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

แทนที่จะเป็นเช่นนี้:

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

ดังที่กล่าวไว้ที่นี่ไม่มีข้อได้เปรียบด้านประสิทธิภาพในการประกาศตัวแปรภายนอกลูปและภายใต้สถานการณ์ปกติเหตุผลเดียวที่ฉันคิดได้สำหรับการทำเช่นนี้คือถ้าคุณวางแผนที่จะใช้ตัวแปรนอกขอบเขตของลูป:

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

อย่างไรก็ตามตัวแปรที่กำหนดในforeachลูปไม่สามารถใช้ภายนอกลูปได้:

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

ดังนั้นคอมไพเลอร์จึงประกาศตัวแปรในลักษณะที่ทำให้เกิดข้อผิดพลาดสูงซึ่งมักจะยากที่จะค้นหาและตรวจแก้จุดบกพร่องในขณะที่ไม่มีประโยชน์ที่รับรู้ได้

มีบางสิ่งที่คุณสามารถทำกับforeachลูปได้ด้วยวิธีนี้ถ้าคุณไม่ได้คอมไพล์ด้วยตัวแปรภายในหรือนี่เป็นเพียงตัวเลือกโดยพลการที่ทำขึ้นก่อนวิธีที่ไม่ระบุชื่อและการแสดงออกแลมบ์ดานั้นมีอยู่หรือทั่วไป ไม่ได้รับการแก้ไขตั้งแต่นั้นมา?

คอมไพเลอร์ประกาศตัวแปรในลักษณะที่ทำให้มีแนวโน้มสูงที่จะเกิดข้อผิดพลาดซึ่งมักจะยากที่จะค้นหาและตรวจแก้จุดบกพร่องในขณะที่ไม่มีประโยชน์ที่รับรู้ได้

การวิจารณ์ของคุณนั้นสมเหตุสมผล

ฉันพูดถึงปัญหานี้โดยละเอียดที่นี่:

การปิดตัวแปรลูปถือว่าเป็นอันตราย

มีบางสิ่งที่คุณสามารถทำกับลูป foreach ในแบบที่คุณทำไม่ได้ถ้าพวกมันถูกคอมไพล์ด้วยตัวแปรภายใน หรือนี่เป็นเพียงตัวเลือกโดยพลการที่ทำขึ้นก่อนวิธีการแบบไม่ระบุชื่อและการแสดงออกแลมบ์ดามีให้บริการหรือพบเห็นทั่วไปและสิ่งใดที่ไม่ได้รับการแก้ไขตั้งแต่นั้นมา?

หลัง. ข้อกำหนด C # 1.0 ไม่ได้บอกว่าตัวแปรลูปอยู่ภายในหรือภายนอกตัวลูปเนื่องจากมันไม่มีความแตกต่างที่สังเกตได้ เมื่อซีแมนทิกส์ปิดถูกแนะนำใน C # 2.0 ทางเลือกถูกสร้างขึ้นเพื่อใส่ตัวแปรลูปนอกลูป

ฉันคิดว่ามันยุติธรรมที่จะพูดว่าการตัดสินใจทั้งหมดนั้นเสียใจ นี่เป็นหนึ่งใน "gotchas" ที่เลวร้ายที่สุดใน C # และเราจะทำการเปลี่ยนแปลงครั้งใหญ่เพื่อแก้ไข ใน C # 5 ตัวแปรลูป foreach จะมีเหตุผลอยู่ภายในเนื้อความของลูปดังนั้นการปิดจะได้รับสำเนาใหม่ทุกครั้ง

การforวนซ้ำจะไม่ถูกเปลี่ยนแปลงและการเปลี่ยนแปลงจะไม่ "ย้อนกลับพอร์ต" เป็น C # รุ่นก่อนหน้า คุณควรใช้ความระมัดระวังต่อไปเมื่อใช้สำนวนนี้

สิ่งที่คุณถามนั้นครอบคลุมโดย Eric Lippert ในบล็อกโพสต์ของเขาการปิดตัวแปรลูปถือว่าเป็นอันตรายและผลสืบเนื่อง

สำหรับฉันข้อโต้แย้งที่น่าเชื่อที่สุดคือการมีตัวแปรใหม่ในการทำซ้ำแต่ละครั้งจะไม่สอดคล้องกับfor(;;)ลักษณะวนรอบ คุณคาดหวังว่าจะมีสิ่งใหม่int iในการทำซ้ำแต่ละครั้งfor (int i = 0; i < 10; i++)หรือไม่

ปัญหาที่พบบ่อยที่สุดกับพฤติกรรมนี้คือการปิดตัวแปรการทำซ้ำและมีวิธีแก้ไขปัญหาง่าย ๆ :

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

โพสต์ของฉันบล็อกเกี่ยวกับปัญหานี้: ปิดมากกว่าตัวแปร foreach ใน C #

เมื่อถูกกัดโดยสิ่งนี้ฉันมีนิสัยรวมถึงตัวแปรที่กำหนดไว้ในเครื่องในขอบเขตด้านในสุดที่ฉันใช้เพื่อถ่ายโอนไปยังการปิดใด ๆ ในตัวอย่างของคุณ:

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

ฉันทำ:

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

เมื่อคุณมีนิสัยที่คุณสามารถหลีกเลี่ยงได้ในกรณีที่หายากมากที่คุณตั้งใจจะผูกไว้กับขอบเขตด้านนอก พูดตามตรงฉันไม่คิดว่าฉันเคยทำมาก่อน

ใน C # 5.0 ปัญหานี้ได้รับการแก้ไขและคุณสามารถปิดตัวแปรลูปและรับผลลัพธ์ที่คุณคาดหวัง

ข้อกำหนดภาษาพูดว่า:

8.8.4 คำสั่ง foreach

( ... )

คำสั่ง foreach ของแบบฟอร์ม

foreach (V v in x) embedded-statement

จะถูกขยายเป็น:

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

( ... )

การจัดวางvด้านในของ while while มีความสำคัญสำหรับวิธีการจับโดยฟังก์ชันที่ไม่ระบุชื่อใด ๆ ที่เกิดขึ้นในคำสั่งฝังตัว ตัวอย่างเช่น:

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

หากvมีการประกาศนอกวงขณะที่มันจะถูกใช้ร่วมกันในการทำซ้ำทั้งหมดและค่าของมันหลังจากห่วงสำหรับจะเป็นค่าสุดท้าย13ซึ่งเป็นสิ่งที่ภาวนาของfจะพิมพ์ แต่เนื่องจากการวนซ้ำแต่ละครั้งมีตัวแปรของตัวเองvการจับfซ้ำโดยในการทำซ้ำครั้งแรกจะยังคงเก็บค่า 7ซึ่งเป็นสิ่งที่จะพิมพ์ ( หมายเหตุ: รุ่นก่อนหน้าของ C # ประกาศvนอกห่วงขณะที่ )