แยกออกจากวงซ้อนกัน

หากฉันมีการวนซ้ำแบบวนซ้ำซึ่งซ้อนกันภายในอีกครั้งฉันจะออกมาได้อย่างมีประสิทธิภาพทั้งจากลูป (ภายในและภายนอก) ในวิธีที่เร็วที่สุดที่เป็นไปได้อย่างไร

ฉันไม่ต้องการใช้บูลีนและต้องบอกว่าไปยังวิธีอื่น แต่เพียงเพื่อรันโค้ดบรรทัดแรกหลังจากวนรอบด้านนอก

อะไรคือวิธีที่รวดเร็วและดีที่จะทำเรื่องนี้?

ฉันคิดว่าการยกเว้นจะไม่ถูก / ควรถูกโยนในสภาพที่ยอดเยี่ยมจริงๆเท่านั้นดังนั้นฉันไม่คิดว่าวิธีนี้จะดีในแง่ของประสิทธิภาพ

ฉันไม่รู้สึกว่ามันถูกต้องที่จะใช้ประโยชน์จากฟีเจอร์ใหม่ใน. NET (วิธี anon) เพื่อทำสิ่งที่ค่อนข้างพื้นฐาน

ดีgotoแต่ที่น่าเกลียดและไม่ได้เสมอ นอกจากนี้คุณยังสามารถวางลูปเป็นวิธีการ (หรือ anon-method) และใช้returnเพื่อออกกลับไปที่รหัสหลัก

    // goto
    for (int i = 0; i < 100; i++)
    {
        for (int j = 0; j < 100; j++)
        {
            goto Foo; // yeuck!
        }
    }
Foo:
    Console.WriteLine("Hi");

VS:

// anon-method
Action work = delegate
{
    for (int x = 0; x < 100; x++)
    {
        for (int y = 0; y < 100; y++)
        {
            return; // exits anon-method
        }
    }
};
work(); // execute anon-method
Console.WriteLine("Hi");

โปรดทราบว่าใน C # 7 เราควรได้รับ "ฟังก์ชั่นท้องถิ่น" ซึ่ง (ไวยากรณ์ tbd ฯลฯ ) หมายความว่ามันควรจะทำงานเช่น:

// local function (declared **inside** another method)
void Work()
{
    for (int x = 0; x < 100; x++)
    {
        for (int y = 0; y < 100; y++)
        {
            return; // exits local function
        }
    }
};
Work(); // execute local function
Console.WriteLine("Hi");

การปรับ C # ของวิธีการที่ใช้บ่อยใน C - set value ของตัวแปร loop ภายนอกของเงื่อนไข loop (เช่นสำหรับ loop โดยใช้ตัวแปร int INT_MAX -1มักเป็นตัวเลือกที่ดี):

for (int i = 0; i < 100; i++)
{
    for (int j = 0; j < 100; j++)
    {
        if (exit_condition)
        {
            // cause the outer loop to break:
            // use i = INT_MAX - 1; otherwise i++ == INT_MIN < 100 and loop will continue 
            i = int.MaxValue - 1;
            Console.WriteLine("Hi");
            // break the inner loop
            break;
        }
    }
    // if you have code in outer loop it will execute after break from inner loop    
}

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

วิธีการนี้จะทำงานร่วมกับforและwhileลูป foreachแต่ไม่ทำงานสำหรับ ในกรณีที่foreachคุณจะไม่สามารถเข้าถึงโค้ดของตัวแจงนับที่ซ่อนอยู่ดังนั้นคุณจึงไม่สามารถเปลี่ยนแปลงได้ (และแม้ว่าคุณจะIEnumeratorไม่มีวิธี "MoveToEnd")

_{กิตติกรรมประกาศสำหรับผู้เขียนความเห็นที่ถูกขีดเส้น ใต้ :
i = INT_MAX - 1คำแนะนำโดยMeta
for / foreachความคิดเห็นโดยygoe
เหมาะสมIntMaxโดยjmbpiano
พูดถึงโค้ดหลังลูปภายในโดยblizpasta}

วิธีนี้ใช้ไม่ได้กับ C #

สำหรับผู้ที่พบคำถามนี้ผ่านทางภาษาอื่น ๆJavascript, Java, และ D อนุญาตให้มีการแบ่งป้ายกำกับและดำเนินการต่อ :

outer: while(fn1())
{
   while(fn2())
   {
     if(fn3()) continue outer;
     if(fn4()) break outer;
   }
}

ใช้ตัวป้องกันที่เหมาะสมในลูปด้านนอก ตั้งยามในวงในก่อนที่จะทำลาย

bool exitedInner = false;

for (int i = 0; i < N && !exitedInner; ++i) {

    .... some outer loop stuff

    for (int j = 0; j < M; ++j) {

        if (sometest) {
            exitedInner = true;
            break;
        }
    }
    if (!exitedInner) {
       ... more outer loop stuff
    }
}

หรือดีกว่าให้นามธรรมวงในเป็นวิธีการและออกจากวงนอกเมื่อมันกลับเท็จ

for (int i = 0; i < N; ++i) {

    .... some outer loop stuff

    if (!doInner(i, N, M)) {
       break;
    }

    ... more outer loop stuff
}

อย่าพูดถึงสิ่งนี้ แต่คุณสามารถใช้goto ได้ตามที่แนะนำใน MSDN มีวิธีแก้ไขปัญหาอื่น ๆ รวมถึงการตั้งค่าสถานะที่มีการตรวจสอบในแต่ละรอบซ้ำของลูปทั้งสอง ในที่สุดคุณสามารถใช้ข้อยกเว้นเป็นวิธีการแก้ปัญหารุ่นหนามากสำหรับปัญหาของคุณ

ไปที่:

for ( int i = 0; i < 10; ++i ) {
   for ( int j = 0; j < 10; ++j ) {
      // code
      if ( break_condition ) goto End;
      // more code
   }
}
End: ;

เงื่อนไข:

bool exit = false;
for ( int i = 0; i < 10 && !exit; ++i ) {
   for ( int j = 0; j < 10 && !exit; ++j ) {
      // code
      if ( break_condition ) {
         exit = true;
         break; // or continue
      }
      // more code
   }
}

ข้อยกเว้น:

try {
    for ( int i = 0; i < 10 && !exit; ++i ) {
       for ( int j = 0; j < 10 && !exit; ++j ) {
          // code
          if ( break_condition ) {
             throw new Exception()
          }
          // more code
       }
    }
catch ( Exception e ) {}

มันเป็นไปได้ที่จะ refactor ซ้อนกันสำหรับวนเป็นวิธีส่วนตัวหรือไม่ ด้วยวิธีนี้คุณสามารถ 'คืน' ออกจากวิธีการเพื่อออกจากลูป

ดูเหมือนว่าฉันจะชอบผู้คนที่ไม่ชอบgotoคำแถลงมากดังนั้นฉันจึงรู้สึกว่าจำเป็นที่จะต้องทำให้เรื่องนี้ตรงออกไปเล็กน้อย

ฉันเชื่อว่าคนที่ 'อารมณ์' มีเกี่ยวกับgotoในที่สุดก็ถึงความเข้าใจในโค้ดและ (ความเข้าใจผิด) เกี่ยวกับความเป็นไปได้ในการใช้งาน ก่อนที่จะตอบคำถามฉันจะเข้าไปดูรายละเอียดเกี่ยวกับวิธีการรวบรวม

อย่างที่เราทราบกันดีว่า C # นั้นถูกคอมไพล์ไปที่ IL ซึ่งจะถูกคอมไพล์ให้กับแอสเซมเบลอร์ด้วย SSA ฉันจะให้ข้อมูลเชิงลึกเกี่ยวกับวิธีการทำงานทั้งหมดนี้แล้วลองตอบคำถามเอง

จาก C # ถึง IL

ก่อนอื่นเราต้องใช้รหัส C # เริ่มง่าย ๆ :

foreach (var item in array)
{
    // ... 
    break;
    // ...
}

ฉันจะทำตามขั้นตอนนี้เพื่อให้คุณมีความคิดที่ดีว่าเกิดอะไรขึ้นภายใต้ประทุน

การแปลครั้งแรก: จากforeachเป็นforลูปที่เทียบเท่า(หมายเหตุ: ฉันกำลังใช้อาร์เรย์ที่นี่เพราะฉันไม่ต้องการทราบรายละเอียดของ IDisposable - ในกรณีนี้ฉันต้องใช้ IEnumerable ด้วย):

for (int i=0; i<array.Length; ++i)
{
    var item = array[i];
    // ...
    break;
    // ...
}

การแปลครั้งที่สอง: forและbreakถูกแปลเป็นภาษาที่เทียบเท่าได้ง่ายขึ้น:

int i=0;
while (i < array.Length)
{
    var item = array[i];
    // ...
    break;
    // ...
    ++i;
}

และการแปลที่สาม (นี้เป็นเทียบเท่าของรหัส IL): เราเปลี่ยนbreakและwhileเข้าไปในสาขา:

    int i=0; // for initialization

startLoop:
    if (i >= array.Length) // for condition
    {
        goto exitLoop;
    }
    var item = array[i];
    // ...
    goto exitLoop; // break
    // ...
    ++i;           // for post-expression
    goto startLoop; 

ในขณะที่คอมไพเลอร์ทำสิ่งเหล่านี้ในขั้นตอนเดียวมันช่วยให้คุณเข้าใจกระบวนการ รหัส IL ที่วิวัฒนาการมาจากโปรแกรม C # เป็นการแปลตามตัวอักษรของรหัส C # ครั้งสุดท้าย คุณสามารถเห็นตัวคุณเองได้ที่นี่: https://dotnetfiddle.net/QaiLRz (คลิก 'ดู IL')

ตอนนี้สิ่งหนึ่งที่คุณสังเกตได้ที่นี่คือในระหว่างกระบวนการรหัสจะซับซ้อนมากขึ้น วิธีที่ง่ายที่สุดในการสังเกตสิ่งนี้คือความจริงที่ว่าเราต้องการรหัสมากขึ้นเพื่อทำสิ่งเดียวกัน นอกจากนี้คุณยังอาจโต้แย้งว่าforeach, for, whileและbreakเป็นจริงสั้นมือสำหรับgotoซึ่งเป็นจริงบางส่วน

จาก IL ถึง Assembler

คอมไพเลอร์. NET JIT เป็นคอมไพเลอร์ SSA ฉันจะไม่เข้าไปดูรายละเอียดทั้งหมดของฟอร์ม SSA ที่นี่และวิธีสร้างคอมไพเลอร์ที่ปรับให้เหมาะสมมันมากเกินไป แต่สามารถให้ความเข้าใจพื้นฐานเกี่ยวกับสิ่งที่จะเกิดขึ้น เพื่อความเข้าใจที่ลึกซึ้งยิ่งขึ้นควรเริ่มต้นอ่านการเพิ่มประสิทธิภาพคอมไพเลอร์ (ฉันชอบหนังสือเล่มนี้เพื่อแนะนำสั้น ๆ : http://ssabook.gforge.inria.fr/latest/book.pdf ) และ LLVM (llvm.org) .

คอมไพเลอร์ปรับให้เหมาะสมทุกครั้งอาศัยความจริงที่ว่ารหัสนั้นง่ายและเป็นไปตามรูปแบบที่สามารถคาดเดาได้ ในกรณีของการวนรอบ FOR เราใช้ทฤษฎีกราฟเพื่อวิเคราะห์สาขาและเพิ่มประสิทธิภาพของ cycli ในสาขาของเรา (เช่นสาขาย้อนหลัง)

อย่างไรก็ตามตอนนี้เรามีสาขาไปข้างหน้าเพื่อใช้ลูปของเรา ตามที่คุณอาจเดาได้จริง ๆ แล้วนี่เป็นหนึ่งในขั้นตอนแรกที่ JIT จะแก้ไขเช่นนี้:

    int i=0; // for initialization

    if (i >= array.Length) // for condition
    {
        goto endOfLoop;
    }

startLoop:
    var item = array[i];
    // ...
    goto endOfLoop; // break
    // ...
    ++i;           // for post-expression

    if (i >= array.Length) // for condition
    {
        goto startLoop;
    }

endOfLoop:
    // ...

อย่างที่คุณเห็นตอนนี้เรามีสาขาย้อนกลับซึ่งก็คือวงเล็ก ๆ ของเรา สิ่งเดียวที่ยังน่ารังเกียจอยู่ที่นี่คือสาขาที่เราลงเอยด้วยbreakคำแถลงของเรา ในบางกรณีเราสามารถย้ายสิ่งนี้ในลักษณะเดียวกัน แต่ในบางกรณีเราสามารถอยู่ได้

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

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

คุณควรตระหนักว่า ณ จุดนี้ความเรียบง่ายforeachสามารถคาดเดาได้มากกว่าจากนั้นเป็นgotoประโยคที่ไปทั่วสถานที่ ในแง่ของ (1) ความสามารถในการอ่านและ (2) จากมุมมองของเครื่องมือเพิ่มประสิทธิภาพมันเป็นทางออกที่ดีกว่า

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

ช่วยซับซ้อนเกินไป ... ฉันควรทำอย่างไรดี?

บรรทัดล่างคือคุณควรใช้ภาษาสร้างที่คุณมีในการกำจัดของคุณซึ่งมักจะ (โดยนัย) สร้างรูปแบบที่คาดการณ์ได้สำหรับคอมไพเลอร์ของคุณ พยายามหลีกเลี่ยงการสาขาแปลกถ้าเป็นไปได้ (เฉพาะ: break, continue, gotoหรือreturnในช่วงกลางของอะไร)

ข่าวดีก็คือรูปแบบที่คาดการณ์ได้เหล่านี้มีทั้งที่อ่านง่าย (สำหรับมนุษย์) และง่ายต่อการตรวจจับ (สำหรับคอมไพเลอร์)

หนึ่งในรูปแบบเหล่านั้นเรียกว่า SESE ซึ่งย่อมาจาก Single Entry Single Exit

และตอนนี้เรามาถึงคำถามที่แท้จริง

ลองนึกภาพว่าคุณมีสิ่งนี้:

// a is a variable.

for (int i=0; i<100; ++i) 
{
  for (int j=0; j<100; ++j)
  {
     // ...

     if (i*j > a) 
     {
        // break everything
     }
  }
}

วิธีที่ง่ายที่สุดในการทำให้รูปแบบนี้สามารถคาดเดาได้คือเพียงกำจัดสิ่งที่ไม่ifสมบูรณ์ออกไป:

int i, j;
for (i=0; i<100 && i*j <= a; ++i) 
{
  for (j=0; j<100 && i*j <= a; ++j)
  {
     // ...
  }
}

ในกรณีอื่นคุณสามารถแยกวิธีเป็น 2 วิธี

// Outer loop in method 1:

for (i=0; i<100 && processInner(i); ++i) 
{
}

private bool processInner(int i)
{
  int j;
  for (j=0; j<100 && i*j <= a; ++j)
  {
     // ...
  }
  return i*j<=a;
}

ตัวแปรชั่วคราว? ดีเลวหรือน่าเกลียด?

คุณอาจตัดสินใจคืนบูลีนจากภายในลูป (แต่โดยส่วนตัวแล้วฉันชอบแบบฟอร์ม SESE เพราะนั่นเป็นวิธีที่คอมไพเลอร์จะเห็นมันและฉันคิดว่ามันอ่านง่ายกว่า)

บางคนคิดว่าการใช้ตัวแปรชั่วคราวนั้นสะอาดกว่าและเสนอวิธีแก้ปัญหาเช่นนี้:

bool more = true;
for (int i=0; i<100; ++i) 
{
  for (int j=0; j<100; ++j) 
  {
     // ...
     if (i*j > a) { more = false; break; } // yuck.
     // ...
  }
  if (!more) { break; } // yuck.
  // ...
}
// ...

ส่วนตัวผมไม่เห็นด้วยกับแนวทางนี้ ดูอีกครั้งเกี่ยวกับวิธีการรวบรวมรหัส ตอนนี้คิดเกี่ยวกับสิ่งนี้จะทำอย่างไรกับรูปแบบที่ดีและคาดเดาได้เหล่านี้ รับภาพหรือไม่

ใช่ให้ฉันสะกดมันออกมา จะเกิดอะไรขึ้นคือ:

• คอมไพเลอร์จะเขียนทุกอย่างเป็นสาขา
• ในขั้นตอนการปรับให้เหมาะสมคอมไพเลอร์จะทำการวิเคราะห์การไหลของข้อมูลในความพยายามที่จะลบmoreตัวแปรแปลก ๆที่เกิดขึ้นเพื่อใช้ในโฟลว์การควบคุมเท่านั้น
• หากประสบความสำเร็จตัวแปรmoreจะถูกลบออกจากโปรแกรมและจะเหลือเพียงกิ่งก้านเท่านั้น สาขาเหล่านี้จะได้รับการปรับปรุงเพื่อให้คุณได้รับเพียงสาขาเดียวจากวงใน
• หากไม่สำเร็จตัวแปรmoreจะถูกใช้ในลูปภายในสุดอย่างแน่นอนดังนั้นหากคอมไพเลอร์ไม่ปรับให้เหมาะสมมันมีโอกาสสูงที่จะถูกจัดสรรให้กับรีจิสเตอร์ (ซึ่งกินหน่วยความจำรีจิสเตอร์ที่มีค่า)

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

กล่าวอีกนัยหนึ่งสถานการณ์กรณีที่ดีที่สุดคือมันจะจบลงด้วยสิ่งนี้:

for (int i=0; i<100; ++i) 
{
  for (int j=0; j<100; ++j)
  {
     // ...
     if (i*j > a) { goto exitLoop; } // perhaps add a comment
     // ...
  }
  // ...
}
exitLoop:

// ...

ความเห็นส่วนตัวของฉันเกี่ยวกับเรื่องนี้ค่อนข้างง่าย: ถ้านี่คือสิ่งที่เราตั้งใจมาโดยตลอดลองทำให้โลกนี้ง่ายขึ้นสำหรับคอมไพเลอร์และการอ่านได้และเขียนมันทันที

TL; DR:

บรรทัดล่างสุด:

• ใช้เงื่อนไขง่ายๆในการวนรอบถ้าเป็นไปได้ ยึดติดกับโครงสร้างภาษาระดับสูงที่คุณมีให้มากที่สุด
• หากทุกอย่างล้มเหลวและคุณจะเหลืออย่างใดอย่างหนึ่งgotoหรือbool moreชอบอดีต

ปัจจัยเป็นฟังก์ชั่น / วิธีการและใช้ผลตอบแทนเร็วหรือจัดเรียงลูปของคุณเป็นประโยค กลับไป / ข้อยกเว้น / อะไรก็ตามที่ไม่เหมาะสมที่นี่อย่างแน่นอน

def do_until_equal():
  foreach a:
    foreach b:
      if a==b: return

คุณถามหาการผสมผสานระหว่างความรวดเร็วดีและไม่ใช้บูลีนไม่มีการใช้ goto และ C # คุณได้กำจัดวิธีที่เป็นไปได้ทั้งหมดในการทำสิ่งที่คุณต้องการ

วิธีที่รวดเร็วและน่าเกลียดที่สุดคือใช้ goto

บางครั้งการเขียนโค้ดลงในฟังก์ชั่นของตัวเองเป็นเรื่องที่ดีและใช้ผลตอบแทนเร็วกว่า - การรับคืนเร็วเป็นสิ่งที่เลวร้ายแม้ว่า:)

public void GetIndexOf(Transform transform, out int outX, out int outY)
{
    outX = -1;
    outY = -1;

    for (int x = 0; x < Columns.Length; x++)
    {
        var column = Columns[x];

        for (int y = 0; y < column.Transforms.Length; y++)
        {
            if(column.Transforms[y] == transform)
            {
                outX = x;
                outY = y;

                return;
            }
        }
    }
}

ฉันเคยเห็นตัวอย่างมากมายที่ใช้ "break" แต่ไม่มีใครที่ใช้ "ดำเนินการต่อ"

มันยังคงต้องการแฟล็กของการเรียงลำดับบางอย่างในลูปภายใน:

while( some_condition )
{
    // outer loop stuff
    ...

    bool get_out = false;
    for(...)
    {
        // inner loop stuff
        ...

        get_out = true;
        break;
    }

    if( get_out )
    {
        some_condition=false;
        continue;
    }

    // more out loop stuff
    ...

}

ตั้งแต่ฉันแรกเห็นbreakใน C สองสามทศวรรษหลังปัญหานี้มีปัญหาฉัน ฉันหวังว่าการเพิ่มประสิทธิภาพของภาษาจะมีส่วนขยายให้หยุดซึ่งจะทำให้:

break; // our trusty friend, breaks out of current looping construct.
break 2; // breaks out of the current and it's parent looping construct.
break 3; // breaks out of 3 looping constructs.
break all; // totally decimates any looping constructs in force.

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

อย่างไรก็ตามเพื่อแยกออกจากลูปซ้อนกันฉันทำอะไรเช่นนี้:

var isDone = false;
for (var x in collectionX) {
    for (var y in collectionY) {
        for (var z in collectionZ) {
            if (conditionMet) {
                // some code
                isDone = true;
            }
            if (isDone)
                break;
        }
        if (isDone) 
            break;
    }
    if (isDone)
        break;
}

... ฉันหวังว่าจะช่วยให้คนที่ชอบฉันต่อต้าน antio goto "fanboys" :)

นั่นเป็นวิธีที่ฉันทำ ยังคงเป็นวิธีแก้ปัญหา

foreach (var substring in substrings) {
  //To be used to break from 1st loop.
  int breaker=1;
  foreach (char c in substring) {
    if (char.IsLetter(c)) {
      Console.WriteLine(line.IndexOf(c));
      \\setting condition to break from 1st loop.
      breaker=9;
      break;
    }
  }
  if (breaker==9) {
    break;
  }
}

วิธีที่ง่ายที่สุดในการสิ้นสุดการวนซ้ำสองครั้งจะเป็นการสิ้นสุดการวนซ้ำแรกโดยตรง

string TestStr = "The frog jumped over the hill";
char[] KillChar = {'w', 'l'};

for(int i = 0; i < TestStr.Length; i++)
{
    for(int E = 0; E < KillChar.Length; E++)
    {
        if(KillChar[E] == TestStr[i])
        {
            i = TestStr.Length; //Ends First Loop
            break; //Ends Second Loop
        }
    }
}

ลูปสามารถแตกได้โดยใช้เงื่อนไขที่กำหนดเองในลูปทำให้มีโค้ดที่ชัดเจน

    static void Main(string[] args)
    {
        bool isBreak = false;
        for (int i = 0; ConditionLoop(isBreak, i, 500); i++)
        {
            Console.WriteLine($"External loop iteration {i}");
            for (int j = 0; ConditionLoop(isBreak, j, 500); j++)
            {
                Console.WriteLine($"Inner loop iteration {j}");

                // This code is only to produce the break.
                if (j > 3)
                {
                    isBreak = true;
                }                  
            }

            Console.WriteLine("The code after the inner loop will be executed when breaks");
        }

        Console.ReadKey();
    }

    private static bool ConditionLoop(bool isBreak, int i, int maxIterations) => i < maxIterations && !isBreak;   

ด้วยรหัสนี้เราได้ผลลัพธ์ต่อไปนี้:

• วนซ้ำภายนอก 0
• การวนซ้ำภายในวง 0
• การวนซ้ำภายในวงใน 1
• การวนซ้ำภายในวง 2
• การวนซ้ำภายในวง 3
• การวนซ้ำภายในวง 4
• รหัสหลังจากวนรอบด้านในจะถูกดำเนินการเมื่อหยุดพัก

ตัวเลือกอื่น ๆ ที่เป็นตัวเองเรียกฟังก์ชั่นที่ไม่ระบุชื่อ ไม่มีการข้ามไปไม่มีป้ายกำกับไม่มีตัวแปรใหม่ไม่ใช้ชื่อฟังก์ชันใหม่และสั้นกว่าหนึ่งบรรทัดตัวอย่างเมธอดแบบไม่ระบุชื่อที่ด้านบน

// self-invoked-anonymous-function
new Action(() =>
{
    for (int x = 0; x < 100; x++)
    {
        for (int y = 0; y < 100; y++)
        {
            return; // exits self invoked lambda expression
        }
    }
})();
Console.WriteLine("Hi");

โยนข้อยกเว้นที่กำหนดเองซึ่งออกไปนอกวง

การทำงานสำหรับfor, foreachหรือwhileหรือชนิดใด ๆ ของวงและภาษาที่ใช้try catch exceptionบล็อก

try 
{
   foreach (object o in list)
   {
      foreach (object another in otherList)
      {
         // ... some stuff here
         if (condition)
         {
            throw new CustomExcpetion();
         }
      }
   }
}
catch (CustomException)
{
   // log 
}

         bool breakInnerLoop=false
        for(int i=0;i<=10;i++)
        {
          for(int J=0;i<=10;i++)
          {
              if(i<=j)
                {
                    breakInnerLoop=true;
                    break;
                }
          }
            if(breakInnerLoop)
            {
            continue
            }
        }

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

            for (; j < 10; j++)
            {
                //solution
                bool breakme = false;
                for (int k = 1; k < 10; k++)
                {
                   //place the condition where you want to stop it
                    if ()
                    {
                        breakme = true;
                        break;
                    }
                }

                if(breakme)
                    break;
               }

เรียบง่ายและเรียบง่าย :)

คุณดูbreakคำหลักด้วยหรือไม่ Oo

นี่เป็นเพียงโค้ดหลอก แต่คุณควรจะเห็นสิ่งที่ฉันหมายถึง:

<?php
for(...) {
    while(...) {
        foreach(...) {
            break 3;
        }
    }
}

หากคุณคิดว่าbreakจะเป็นฟังก์ชั่นเช่นbreak()นั้นพารามิเตอร์ก็คือจำนวนลูปที่จะแยกออก ในขณะที่เราอยู่ในวงที่สามในรหัสที่นี่เราสามารถแยกออกจากทั้งสาม

คู่มือ: http://php.net/break

ฉันคิดว่าถ้าคุณไม่ต้องการทำสิ่ง "บูลีน" ทางออกเดียวคือการโยน เห็นได้ชัดว่าคุณไม่ควรทำ .. !