Mengapa pernyataan 'lanjutkan' tidak bisa berada di dalam blok 'akhirnya'?

Saya tidak punya masalah; Saya hanya penasaran. Bayangkan skenario berikut:

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

Ini tidak dapat dikompilasi, karena ini menimbulkan kesalahan kompiler CS0157 :

Kontrol tidak dapat meninggalkan isi klausa akhirnya

Mengapa?

finallyblok berjalan baik pengecualian dilempar atau tidak. Jika pengecualian dilemparkan, apa yang akan terjadicontinue dilakukan? Anda tidak dapat melanjutkan eksekusi loop, karena pengecualian yang tidak tertangkap akan mentransfer kontrol ke fungsi lain.

Bahkan jika tidak ada pengecualian dilempar, finallyakan berjalan ketika pernyataan transfer kontrol lain di dalam blok coba / tangkap dijalankan, sepertireturn , misalnya, yang membawa masalah yang sama.

Singkatnya, dengan semantik finallytidak masuk akal untuk mengizinkan transfer kontrol dari dalam afinally blok ke luarnya.

Mendukung ini dengan beberapa semantik alternatif akan lebih membingungkan daripada membantu, karena ada solusi sederhana yang membuat perilaku yang diinginkan menjadi lebih jelas. Jadi Anda mendapatkan kesalahan, dan dipaksa untuk memikirkan masalah Anda dengan benar. Ini adalah ide umum "melemparkan Anda ke lubang kesuksesan" yang terjadi di C #.

Jika Anda ingin mengabaikan pengecualian (lebih sering daripada bukan bukan ide yang buruk) dan terus menjalankan loop, gunakan blok catch all:

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

Jika Anda ingin continuehanya ketika tidak ada pengecualian yang tidak tertangkap dilemparkan, cukup letakkan di continueluar blok percobaan.

Berikut adalah sumber yang dapat dipercaya:

Pernyataan lanjutkan tidak dapat keluar dari blok akhirnya (Bagian 8.10). Ketika pernyataan lanjutan terjadi dalam blok akhirnya, target pernyataan lanjutan harus berada dalam blok akhirnya yang sama; jika tidak, kesalahan waktu kompilasi terjadi.

Ini diambil dari MSDN, 8.9.2 Pernyataan lanjutan .

Dokumentasinya mengatakan bahwa:

Pernyataan dari blok terakhir selalu dieksekusi ketika kontrol meninggalkan pernyataan percobaan. Ini benar apakah transfer kontrol terjadi sebagai hasil dari eksekusi normal, sebagai hasil dari eksekusi pernyataan break, continue, goto, atau return, atau sebagai akibat dari menyebarkan pengecualian dari pernyataan percobaan. Jika pengecualian dilemparkan selama eksekusi blok akhirnya, pengecualian tersebut disebarkan ke pernyataan coba terlampir berikutnya. Jika pengecualian lain sedang dalam proses disebarkan, pengecualian itu hilang. Proses menyebarkan pengecualian dibahas lebih lanjut dalam deskripsi pernyataan lemparan (Bagian 8.9.5).

Dari sini 8.10 Pernyataan percobaan .

Anda mungkin berpikir itu masuk akal, tetapi sebenarnya tidak masuk akal .

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

Apa yang ingin Anda lakukan jeda atau lanjutkan saat pengecualian dilemparkan? Tim penyusun C # tidak ingin membuat keputusan sendiri dengan asumsi breakataucontinue . Sebaliknya, mereka memutuskan untuk mengeluh bahwa situasi pengembang akan menjadi ambigu untuk mentransfer kontrol finally block.

Jadi itu adalah tugas pengembang untuk menyatakan dengan jelas apa yang dia ingin lakukan daripada mengkompilasi asumsi sesuatu yang lain.

Saya harap Anda mengerti mengapa ini tidak bisa dikompilasi!

Seperti yang dinyatakan orang lain, tetapi berfokus pada pengecualian, ini benar-benar tentang penanganan pengalihan kendali yang ambigu.

Dalam benak Anda, Anda mungkin memikirkan skenario seperti ini:

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;
}

Secara teoritis, Anda dapat melacak aliran kontrol dan berkata, ya, ini "ok". Tidak ada pengecualian yang dilemparkan, tidak ada kontrol yang ditransfer. Tapi desainer bahasa C # memiliki masalah lain dalam pikirannya.

Pengecualian yang Dilempar

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

The Dreaded Goto

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

    pigsfly:
}

Kembalinya

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

Break up

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

Jadi kesimpulannya, ya, sementara ada adalah sebuah sedikit kemungkinan menggunakan continuedalam situasi di mana kontrol tidak ditransfer, tapi bagus (sebagian?) Dari kasus melibatkan pengecualian atau returnblok. Perancang bahasa merasa ini terlalu ambigu dan (kemungkinan) tidak mungkin untuk memastikan pada waktu kompilasi bahwa Anda hanyacontinue digunakan dalam kasus di mana aliran kontrol tidak ditransfer.

Secara umum continuetidak masuk akal bila digunakan di finallyblok. Lihatlah ini:

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

"Ini tidak akan bisa dikompilasi dan saya pikir itu masuk akal"

Yah, menurutku tidak.

Ketika Anda benar-benar memilikinya catch(Exception)maka Anda tidak membutuhkan akhirnya (dan mungkin bahkan tidakcontinue ).

Ketika Anda memiliki yang lebih realistis catch(SomeException), apa yang harus terjadi jika pengecualian tidak tertangkap? Anda continueingin pergi ke satu arah, kecuali menangani yang lain.

Anda tidak dapat meninggalkan tubuh blok terakhir. Ini termasuk istirahat, kembali dan dalam kasus Anda melanjutkan kata kunci.

The finallyblok dapat dijalankan dengan pengecualian menunggu untuk rethrown. Tidaklah masuk akal untuk bisa keluar dari blok (dengancontinue atau apa pun) tanpa memunculkan kembali pengecualian.

Jika Anda ingin melanjutkan pengulangan apa pun yang terjadi, Anda tidak memerlukan pernyataan akhirnya: Tangkap saja pengecualiannya dan jangan lempar ulang.

finallyberjalan baik pengecualian yang tidak tertangkap dilemparkan atau tidak. Orang lain telah menjelaskan mengapa ini membuat continuetidak masuk akal, tetapi berikut adalah alternatif yang mengikuti semangat dari apa yang tampaknya diminta oleh kode ini. Pada dasarnya, finally { continue; }mengatakan:

1. Jika ada pengecualian yang tertangkap, lanjutkan
2. Jika ada pengecualian yang tidak tertangkap, izinkan untuk dibuang, tetapi tetap lanjutkan

(1) dapat dipenuhi dengan menempatkan continuedi akhir masing-masing catch, dan (2) dapat dipenuhi dengan menyimpan pengecualian yang tidak tertangkap untuk dibuang nanti. Anda bisa menulisnya seperti ini:

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);
}

Sebenarnya finallymau juga dieksekusi dalam kasus ketiga, dimana tidak ada pengecualian dilempar sama sekali, tertangkap atau tidak tertangkap. Jika itu diinginkan, Anda tentu saja dapat menempatkan satu continuesetelah blok coba-tangkap alih-alih di dalam masing-masing catch.

Secara teknis, ini adalah batasan dari CIL yang mendasarinya. Dari spesifikasi bahasa :

Transfer kontrol tidak pernah diizinkan untuk memasukkan penangan tangkapan atau klausa terakhir kecuali melalui mekanisme penanganan pengecualian.

dan

Transfer kontrol dari daerah yang dilindungi hanya diizinkan melalui instruksi pengecualian ( leave, end.filter, end.catch, atau end.finally)

Di halaman dokumen untuk brinstruksi :

Kontrol transfer masuk dan keluar dari percobaan, menangkap, menyaring, dan akhirnya blok tidak dapat dilakukan oleh instruksi ini.

Terakhir ini berlaku untuk semua instruksi cabang, termasuk beq, brfalse, dll

Para desainer bahasa hanya tidak ingin (atau tidak bisa) bernalar tentang semantik blok akhirnya diakhiri oleh transfer kontrol.

Satu masalah, atau mungkin masalah kuncinya, adalah bahwa file finally blok dijalankan sebagai bagian dari beberapa transfer kontrol non-lokal (pemrosesan pengecualian). Target dari transfer kontrol tersebut bukanlah loop yang melingkupi; pemrosesan pengecualian membatalkan perulangan dan melanjutkan penguliran lebih lanjut.

Jika kita memiliki transfer kontrol keluar dari finallyblok pembersihan, maka transfer kontrol asli sedang "dibajak". Itu dibatalkan, dan kontrol pergi ke tempat lain.

Semantik bisa dikerjakan. Bahasa lain memilikinya.

Para perancang C # memutuskan untuk melarang statis, transfer kendali "goto-like", dengan demikian menyederhanakan banyak hal.

Namun, bahkan jika Anda melakukan itu, itu tidak menyelesaikan pertanyaan tentang apa yang terjadi jika transfer dinamis dimulai dari finally: bagaimana jika blok terakhir memanggil fungsi, dan fungsi itu melempar? Proses pengecualian asli kemudian "dibajak".

Jika Anda memahami semantik bentuk pembajakan kedua ini, tidak ada alasan untuk menyingkirkan jenis pertama. Mereka benar-benar adalah hal yang sama: transfer kontrol adalah transfer kontrol, baik dalam lingkup leksikal yang sama atau tidak.