เหตุใดคำสั่ง 'ดำเนินการต่อ' จึงไม่สามารถอยู่ในบล็อก 'ในที่สุด' ได้?

ฉันไม่มีปัญหา ฉันแค่อยากรู้ ลองนึกภาพสถานการณ์ต่อไปนี้:

foreach (var foo in list)
{
    try
    {
         //Some code
    }
    catch (Exception)
    {
        //Some more code
    }
    finally
    {
        continue;
    }
}

สิ่งนี้จะไม่คอมไพล์เนื่องจากทำให้เกิดข้อผิดพลาดของคอมไพเลอร์ CS0157 :

การควบคุมไม่สามารถออกจากเนื้อความของประโยคสุดท้ายได้

ทำไม?

finallyบล็อกจะทำงานไม่ว่าจะมีข้อยกเว้นหรือไม่ก็ตาม หากเกิดข้อยกเว้นขึ้นห่าจะcontinueทำอย่างไร? คุณไม่สามารถดำเนินการลูปต่อไปได้เนื่องจากข้อยกเว้นที่ไม่ถูกจับจะโอนการควบคุมไปยังฟังก์ชันอื่น

แม้ว่าจะไม่มีข้อยกเว้นเกิดขึ้น แต่finallyจะทำงานเมื่อคำสั่งการถ่ายโอนการควบคุมอื่น ๆ ภายในการรันบล็อก try / catch เช่น a returnซึ่งทำให้เกิดปัญหาเดียวกัน

ในระยะสั้นด้วยความหมายของfinallyมันไม่สมเหตุสมผลที่จะอนุญาตให้โอนการควบคุมจากภายในfinallyบล็อกไปยังด้านนอกของมัน

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

หากคุณต้องการละเว้นข้อยกเว้น (บ่อยกว่าไม่ใช่ความคิดที่ไม่ดี) และดำเนินการวนซ้ำต่อไปให้ใช้บล็อก catch all:

foreach ( var in list )
{
    try{
        //some code
    }catch{
        continue;
    }
}

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

นี่คือแหล่งที่เชื่อถือได้:

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

มันจะนำมาจาก MSDN, 8.9.2 ยังคงคำสั่ง

เอกสารระบุว่า:

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

มันมาจากที่นี่8.10 คำสั่งลอง

คุณอาจคิดว่ามันสมเหตุสมผล แต่มันไม่สมเหตุสมผลเลย

foreach (var v in List)
{
    try
    {
        //Some code
    }
    catch (Exception)
    {
        //Some more code
        break; or return;
    }
    finally
    {
        continue;
    }
}

คุณตั้งใจจะหยุดพักหรือทำอะไรต่อเมื่อมีข้อยกเว้นเกิดขึ้น? ทีมคอมไพเลอร์ C # ไม่ต้องการตัดสินใจด้วยตัวเองโดยการสมมติbreakหรือcontinue. finally blockแต่พวกเขาตัดสินใจที่จะบ่นสถานการณ์ที่นักพัฒนาจะคลุมเครือต่อการควบคุมการโอนย้ายจาก

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

ฉันหวังว่าคุณจะเข้าใจว่าทำไมสิ่งนี้ถึงไม่รวบรวม!

ตามที่คนอื่น ๆ ระบุไว้ แต่เน้นไปที่ข้อยกเว้นจริงๆแล้วมันเกี่ยวกับการจัดการการควบคุมการถ่ายโอนที่ไม่ชัดเจน

ในใจของคุณคุณอาจนึกถึงสถานการณ์เช่นนี้:

public static object SafeMethod()
{
    foreach(var item in list)
    {
        try
        {
            try
            {
                //do something that won't transfer control outside
            }
            catch
            {
                //catch everything to not throw exceptions
            }
        }
        finally
        {
            if (someCondition)
                //no exception will be thrown, 
                //so theoretically this could work
                continue;
        }
    }

    return someValue;
}

ในทางทฤษฎีคุณสามารถติดตามขั้นตอนการควบคุมและพูดว่าใช่นี่คือ "ตกลง" ไม่มีการโยนข้อยกเว้นไม่มีการถ่ายโอนการควบคุม แต่นักออกแบบภาษา C # มีปัญหาอื่น ๆ อยู่ในใจ

ข้อยกเว้นที่ถูกโยน

public static void Exception()
{
    try
    {
        foreach(var item in list)
        {
            try
            {
                throw new Exception("What now?");
            }
            finally
            {
                continue;
            }
        }
    }
    catch
    {
        //do I get hit?
    }
}

Goto ที่น่ากลัว

public static void Goto()
{
    foreach(var item in list)
    {
        try
        {
            goto pigsfly;
        }
        finally
        {
            continue;
        }
    }

    pigsfly:
}

การกลับมา

public static object ReturnSomething()
{
    foreach(var item in list)
    {
        try
        {
            return item;
        }
        finally
        {
            continue;
        }
    }
}

เลิก

public static void Break()
{
    foreach(var item in list)
    {
        try
        {
            break;
        }
        finally
        {
            continue;
        }
    }
}

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

โดยทั่วไปcontinueไม่สมเหตุสมผลเมื่อใช้ในfinallyบล็อก ดูที่นี้:

foreach (var item in list)
{
    try
    {
        throw new Exception();
    }
    finally{
        //doesn't make sense as we are after exception
        continue;
    }
}

"สิ่งนี้จะไม่รวบรวมและฉันคิดว่ามันสมเหตุสมผลแล้ว"

ฉันคิดว่ามันไม่

เมื่อคุณมีจริงcatch(Exception)แล้วคุณไม่ต้องการในที่สุด (และอาจจะไม่ถึงด้วยซ้ำcontinue)

เมื่อคุณมีความเป็นจริงมากขึ้นcatch(SomeException)จะเกิดอะไรขึ้นเมื่อไม่พบข้อยกเว้น? คุณcontinueต้องการไปทางเดียวข้อยกเว้นในการจัดการอีกทางหนึ่ง

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

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

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

finallyทำงานไม่ว่าจะมีการโยนข้อยกเว้นที่ไม่ถูกจับหรือไม่ก็ตาม คนอื่น ๆ ได้อธิบายแล้วว่าเหตุใดสิ่งนี้จึงcontinueไร้เหตุผล แต่นี่เป็นอีกทางเลือกหนึ่งที่เป็นไปตามเจตนารมณ์ของสิ่งที่รหัสนี้ดูเหมือนจะขอ โดยทั่วไปfinally { continue; }กำลังพูดว่า:

1. เมื่อมีข้อยกเว้นที่จับได้ให้ดำเนินการต่อ
2. เมื่อมีข้อยกเว้นที่ไม่ถูกจับได้อนุญาตให้โยนได้ แต่ยังคงดำเนินการต่อไป

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

var exceptions = new List<Exception>();
foreach (var foo in list) {
    try {
        // some code
    } catch (InvalidOperationException ex) {
        // handle specific exception
        continue;
    } catch (Exception ex) {
        exceptions.Add(ex);
        continue;
    }
    // some more code
}
if (exceptions.Any()) {
    throw new AggregateException(exceptions);
}

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

ในทางเทคนิคมันเป็นข้อ จำกัด ของ CIL ที่อยู่เบื้องหลัง จากข้อกำหนดภาษา :

ไม่อนุญาตให้ถ่ายโอนการควบคุมเข้าสู่ตัวจัดการการจับหรือในที่สุดข้อยกเว้นผ่านกลไกการจัดการข้อยกเว้น

และ

การถ่ายโอนการควบคุมออกจากภูมิภาคที่มีการป้องกันที่ได้รับอนุญาตเท่านั้นที่ผ่านการเรียนการสอนข้อยกเว้น ( leave, end.filter, end.catchหรือend.finally)

ในหน้าเอกสารสำหรับbrคำแนะนำ :

การควบคุมการถ่ายโอนเข้าและออกจากการลองจับกรองและสุดท้ายไม่สามารถดำเนินการบล็อกได้ด้วยคำสั่งนี้

สุดท้ายนี้ถือเป็นจริงสำหรับทุกคำแนะนำสาขารวมทั้งbeq, brfalseฯลฯ

นักออกแบบภาษาไม่ต้องการ (หรือไม่สามารถ) ให้เหตุผลเกี่ยวกับความหมายของการบล็อกในที่สุดที่ถูกยกเลิกโดยการถ่ายโอนการควบคุม

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

หากเรามีการควบคุมการถ่ายโอนออกจากไฟล์ finallyบล็อกการล้างข้อมูลการถ่ายโอนการควบคุมเดิมจะถูก "ไฮแจ็ก" มันถูกยกเลิกและการควบคุมไปที่อื่น

อรรถศาสตร์สามารถหาได้ ภาษาอื่น ๆ ก็มี

นักออกแบบของ C # ตัดสินใจที่จะไม่อนุญาตให้มีการถ่ายโอนการควบคุมแบบคงที่ "เหมือนโกโต" ดังนั้นจึงทำให้สิ่งต่างๆง่ายขึ้น

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

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