มีใครยังใช้ [goto] ใน C # และถ้าเป็นเช่นนั้นทำไม? [ปิด]

ฉันสงสัยว่ามีใครยังใช้ไวยากรณ์คำหลัก "goto" ใน C # หรือไม่และมีเหตุผลอะไรที่เป็นไปได้ในการทำเช่นนั้น

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

ไปที่คำจำกัดความของคำหลัก

มีบางกรณี (หายาก) ที่ goto สามารถปรับปรุงการอ่านได้จริง ในความเป็นจริงเอกสารที่คุณเชื่อมโยงกับรายการสองตัวอย่าง:

การใช้ goto โดยทั่วไปคือการถ่ายโอนการควบคุมไปยังฉลากสวิตช์เคสเฉพาะหรือเลเบลเริ่มต้นในคำสั่งสวิตช์

คำสั่ง goto ยังมีประโยชน์ในการออกจากลูปที่ซ้อนกันลึก ๆ

นี่คือตัวอย่างสำหรับอันหลัง:

for (...) {
    for (...) {
        ...
        if (something)
            goto end_of_loop;
    }
}

end_of_loop:

แน่นอนว่ามีวิธีอื่น ๆ ในการแก้ปัญหานี้เช่นกันเช่นการปรับโครงสร้างโค้ดใหม่ให้เป็นฟังก์ชันการใช้บล็อกหลอกรอบ ๆ เป็นต้น (ดูรายละเอียดในคำถามนี้ ) ตามหมายเหตุด้านข้างนักออกแบบภาษา Java ตัดสินใจที่จะแบนgoto โดยสิ้นเชิงและแนะนำคำสั่งแบ่งที่มีป้ายกำกับแทน

ส่วนนี้ผมจำได้

switch (a)     
{ 
    case 3: 
        b = 7;
        // We want to drop through into case 4, but C# doesn't let us
    case 4: 
        c = 3;
        break; 
    default: 
        b = 2;
        c = 4;
        break; 
}

อะไรทำนองนี้

switch (a)     
{
    case 3: 
        b = 7;
        goto case 4;    
    case 4: 
        c = 3;
        break;     
    default: 
        b = 2;
        c = 4;
        break;
}

อ้างถึงสิ่งนี้

ฉันใช้มันอย่างกว้างขวางในEduasyncเพื่อแสดงชนิดของรหัสที่คอมไพเลอร์สร้างให้คุณเมื่อใช้วิธีการ async ใน C # 5 คุณจะเห็นสิ่งเดียวกันในบล็อกตัววนซ้ำ

ในรหัส "ปกติ" ฉันจำครั้งสุดท้ายที่ใช้ไม่ได้ ...

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

gotoผมจำไม่ได้เคยใช้ แต่บางทีมันอาจช่วยเพิ่มความตั้งใจของการวนซ้ำตลอดไปที่คุณไม่ต้องการออกจริงๆ (ไม่breakแต่คุณยังทำได้returnหรือthrow):

forever: {
  // ...
  goto forever;
}

จากนั้นอีกครั้งง่ายๆwhile (true)ควรพอเพียง ...

นอกจากนี้คุณยังสามารถใช้ในสถานการณ์ที่คุณต้องการซ้ำแรกของวงที่จะเริ่มต้นในช่วงกลางของวง: ดูที่นี่เช่น

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

ดูรายละเอียดการใช้งานบล็อก Iterator: เครื่องที่สร้างขึ้นโดยอัตโนมัติสำหรับรายละเอียดเพิ่มเติมเกี่ยวกับสาเหตุ / วิธีที่คอมไพเลอร์ C # จัดการสิ่งนี้

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

ดูคำสั่ง Go-to ที่ถือว่าเป็นอันตรายสำหรับการโต้แย้งgotoเช่นเดียวกับประวัติศาสตร์การเขียนโปรแกรมแบบคลาสสิก

โปรเซสเซอร์ใช้คำสั่งกระโดดอย่างน้อยหนึ่งคำสั่งและฉันแน่ใจว่าข้อความจำนวนมากใช้คำสั่งเหล่านี้ในการนำไปใช้หรือตีความ

สิ่งที่ดีอย่างหนึ่งเกี่ยวกับการใช้ภาษารุ่นที่ 3หรือ4ก็คือรายละเอียดทางกายภาพเหล่านี้จะแยกออกไปจากเรา ในขณะที่เราควรคำนึงถึงกฎแห่งนามธรรมที่รั่วไหลฉันคิดว่าเราควรใช้เครื่องมือของเราตามที่ตั้งใจไว้ ( ขออภัย ) ถ้าฉันกำลังเขียนโค้ดและgotoดูเหมือนจะเป็นความคิดที่ดีก็คงถึงเวลาที่ต้อง refactor จุดประสงค์ของภาษาที่มีโครงสร้างคือเพื่อหลีกเลี่ยง "การกระโดด" เหล่านี้และเพื่อสร้างกระแสเชิงตรรกะในวิศวกรรมของเรา

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

หากใครสามารถเสนอการใช้งานgotoที่ดูเหมือนดีกว่าการปรับโครงสร้างใหม่ฉันยินดีที่จะถอนคำตอบของฉัน

ฉันหวังว่าฉันจะไม่ผิดที่รีบวิ่งไปที่ " โรงเก็บจักรยาน " ที่นี่ อย่างที่ Kragen พูดอะไรที่ดีพอสำหรับDijkstraคือสิ่งที่ดีพอสำหรับฉัน

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