Mengapa pengembalian hasil tidak dapat muncul di dalam blok percobaan dengan tangkapan?

Berikut ini tidak masalah:

try
{
    Console.WriteLine("Before");

    yield return 1;

    Console.WriteLine("After");
}
finally
{
    Console.WriteLine("Done");
}

The finallyblok berjalan ketika semuanya telah selesai mengeksekusi ( IEnumerator<T>mendukung IDisposableuntuk menyediakan cara untuk memastikan ini bahkan ketika pencacahan ditinggalkan sebelum selesai).

Tapi ini tidak baik:

try
{
    Console.WriteLine("Before");

    yield return 1;  // error CS1626: Cannot yield a value in the body of a try block with a catch clause

    Console.WriteLine("After");
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
}

Misalkan (demi argumen) bahwa pengecualian dilemparkan oleh salah satu WriteLinepanggilan di dalam blok percobaan. Apa masalah melanjutkan eksekusi di catchblok?

Tentu saja, bagian pengembalian hasil (saat ini) tidak dapat melempar apa pun, tetapi mengapa hal itu menghentikan kami dari memiliki penutup try/ catchuntuk menangani pengecualian yang dilemparkan sebelum atau sesudah yield return?

Pembaruan: Ada komentar menarik dari Eric Lippert di sini - tampaknya mereka sudah memiliki cukup masalah dalam menerapkan perilaku coba / akhirnya dengan benar!

EDIT: Halaman MSDN tentang kesalahan ini adalah: http://msdn.microsoft.com/en-us/library/cs1x15az.aspx . Itu tidak menjelaskan mengapa.

Saya menduga ini adalah masalah kepraktisan daripada kelayakan. Saya menduga ada sangat, sangat sedikit waktu di mana pembatasan ini sebenarnya merupakan masalah yang tidak dapat diatasi - tetapi kompleksitas tambahan dalam kompiler akan menjadi sangat signifikan.

Ada beberapa hal seperti ini yang pernah saya temui:

• Atribut tidak boleh generik
• Ketidakmampuan X untuk diturunkan dari XY (kelas bersarang di X)
• Blok Iterator menggunakan bidang publik di kelas yang dihasilkan

Dalam setiap kasus ini, dimungkinkan untuk mendapatkan sedikit lebih banyak kebebasan, dengan biaya kerumitan ekstra dalam kompiler. Tim membuat pilihan pragmatis, yang saya tepuk tangani mereka - saya lebih suka memiliki bahasa yang sedikit lebih ketat dengan kompiler akurat 99,9% (ya, ada bug; saya menemukan satu di SO beberapa hari yang lalu) daripada lebih bahasa fleksibel yang tidak dapat dikompilasi dengan benar.

EDIT: Berikut adalah bukti semu tentang bagaimana mengapa itu layak.

Pertimbangkan bahwa:

• Anda dapat memastikan bahwa bagian hasil pengembalian itu sendiri tidak memunculkan pengecualian (menghitung sebelumnya nilai, lalu Anda hanya menyetel bidang dan mengembalikan "benar")
• Anda diizinkan mencoba / menangkap yang tidak menggunakan pengembalian hasil dalam blok iterator.
• Semua variabel lokal di blok iterator adalah variabel instan dalam tipe yang dihasilkan, sehingga Anda dapat dengan bebas memindahkan kode ke metode baru

Sekarang ubah:

try
{
    Console.WriteLine("a");
    yield return 10;
    Console.WriteLine("b");
}
catch (Something e)
{
    Console.WriteLine("Catch block");
}
Console.WriteLine("Post");

menjadi (semacam pseudo-code):

case just_before_try_state:
    try
    {
        Console.WriteLine("a");
    }
    catch (Something e)
    {
        CatchBlock();
        goto case post;
    }
    __current = 10;
    return true;

case just_after_yield_return:
    try
    {
        Console.WriteLine("b");
    }
    catch (Something e)
    {
        CatchBlock();
    }
    goto case post;

case post;
    Console.WriteLine("Post");


void CatchBlock()
{
    Console.WriteLine("Catch block");
}

Satu-satunya duplikasi adalah dalam menyiapkan blok coba / tangkap - tetapi itu adalah sesuatu yang pasti dapat dilakukan oleh kompilator.

Saya mungkin melewatkan sesuatu di sini - jika demikian, beri tahu saya!

Semua yieldpernyataan dalam definisi iterator diubah menjadi keadaan dalam mesin keadaan yang secara efektif menggunakan switchpernyataan untuk memajukan keadaan. Jika itu benar - benar menghasilkan kode untuk yieldpernyataan dalam coba / tangkap itu harus menduplikasi semua yang ada di tryblok untuk setiap yield pernyataan sambil mengecualikan setiap yieldpernyataan lain untuk blok itu. Ini tidak selalu memungkinkan, terutama jika satu yieldpernyataan bergantung pada pernyataan sebelumnya.

Saya akan berspekulasi bahwa karena cara tumpukan panggilan mendapat luka / dibatalkan ketika Anda menghasilkan kembali dari enumerator menjadi tidak mungkin untuk mencoba / menangkap blok untuk benar-benar "menangkap" pengecualian. (karena blok pengembalian hasil tidak ada di tumpukan, meskipun ia berasal dari blok iterasi)

Untuk mendapatkan gambaran tentang apa yang saya bicarakan menyiapkan blok iterator dan foreach menggunakan iterator itu. Periksa seperti apa Call Stack di dalam blok foreach dan kemudian periksa di dalam blok percobaan / akhirnya iterator.

Saya telah menerima jawaban THE INVINCIBLE SKEET sampai seseorang dari Microsoft datang untuk menuangkan ide tersebut. Tetapi saya tidak setuju dengan bagian masalah pendapat - tentu saja kompilator yang benar lebih penting daripada yang lengkap, tetapi kompilator C # sudah sangat pintar dalam memilah transformasi ini untuk kita sejauh yang dilakukannya. Sedikit lebih banyak kelengkapan dalam hal ini akan membuat bahasa lebih mudah digunakan, diajarkan, dijelaskan, dengan kasus tepi atau gotcha yang lebih sedikit. Jadi saya pikir itu akan sepadan dengan usaha ekstra. Beberapa orang di Redmond menggaruk-garuk kepala selama dua minggu, dan sebagai hasilnya jutaan pembuat kode selama dekade berikutnya dapat sedikit lebih santai.

(Saya juga menyimpan keinginan kotor agar ada cara untuk membuat yield returnpengecualian yang telah dimasukkan ke dalam mesin negara "dari luar", dengan kode yang mendorong pengulangan. Tapi alasan saya menginginkan ini cukup kabur.)

Sebenarnya satu pertanyaan yang saya miliki tentang jawaban Jon adalah berkaitan dengan ekspresi pengembalian hasil yang dilempar.

Jelas hasil pengembalian 10 tidak terlalu buruk. Tapi ini buruk:

yield return File.ReadAllText("c:\\missing.txt").Length;

Jadi, bukankah lebih masuk akal untuk mengevaluasi ini di dalam blok coba / tangkap sebelumnya:

case just_before_try_state:
    try
    {
        Console.WriteLine("a");
        __current = File.ReadAllText("c:\\missing.txt").Length;
    }
    catch (Something e)
    {
        CatchBlock();
        goto case post;
    }
    return true;

Masalah selanjutnya adalah blok coba / tangkap bersarang dan pengecualian yang muncul kembali:

try
{
    Console.WriteLine("x");

    try
    {
        Console.WriteLine("a");
        yield return 10;
        Console.WriteLine("b");
    }
    catch (Something e)
    {
        Console.WriteLine("y");

        if ((DateTime.Now.Second % 2) == 0)
            throw;
    }
}
catch (Something e)
{
    Console.WriteLine("Catch block");
}
Console.WriteLine("Post");

Tapi saya yakin itu mungkin ...