Menangkap pengecualian dengan "catch, when"

Saya menemukan fitur baru ini di C # yang memungkinkan penangan tangkapan untuk mengeksekusi ketika kondisi tertentu terpenuhi.

int i = 0;
try
{
    throw new ArgumentNullException(nameof(i));
}
catch (ArgumentNullException e)
when (i == 1)
{
    Console.WriteLine("Caught Argument Null Exception");
}

Saya mencoba untuk memahami kapan ini mungkin berguna.

Satu skenario bisa jadi seperti ini:

try
{
    DatabaseUpdate()
}
catch (SQLException e)
when (driver == "MySQL")
{
    //MySQL specific error handling and wrapping up the exception
}
catch (SQLException e)
when (driver == "Oracle")
{
    //Oracle specific error handling and wrapping up of exception
}
..

tetapi sekali lagi ini adalah sesuatu yang dapat saya lakukan dalam penangan yang sama dan mendelegasikan ke metode yang berbeda tergantung pada jenis driver. Apakah ini membuat kode lebih mudah dipahami? Bisa dibilang tidak.

Skenario lain yang dapat saya pikirkan adalah seperti:

try
{
    SomeOperation();
}
catch(SomeException e)
when (Condition == true)
{
    //some specific error handling that this layer can handle
}
catch (Exception e) //catchall
{
    throw;
}

Sekali lagi ini adalah sesuatu yang dapat saya lakukan seperti:

try
{
    SomeOperation();
}
catch(SomeException e)
{
    if (condition == true)
    {
        //some specific error handling that this layer can handle
    }
    else
        throw;
}

Apakah menggunakan fitur 'catch, when' membuat penanganan exception lebih cepat karena handler dilewati seperti itu dan stack unwinding bisa terjadi jauh lebih awal dibandingkan dengan menangani kasus penggunaan spesifik dalam handler? Adakah kasus penggunaan khusus yang lebih cocok dengan fitur ini yang kemudian dapat diadopsi sebagai praktik yang baik?

Catch block sudah memungkinkan Anda untuk memfilter jenis pengecualian:

catch (SomeSpecificExceptionType e) {...}

The whenklausul memungkinkan Anda untuk memperpanjang filter ini untuk ekspresi generik.

Dengan demikian, Anda menggunakan whenklausa untuk kasus di mana jenis pengecualian tidak cukup berbeda untuk menentukan apakah pengecualian harus ditangani di sini atau tidak.

Kasus penggunaan yang umum adalah jenis pengecualian yang sebenarnya merupakan pembungkus untuk beberapa jenis kesalahan yang berbeda.

Inilah kasus yang sebenarnya saya gunakan (di VB, yang sudah memiliki fitur ini untuk beberapa waktu):

try
{
    SomeLegacyComOperation();
}
catch (COMException e) when (e.ErrorCode == 0x1234)
{
    // Handle the *specific* error I was expecting. 
}

Sama untuk SqlException, yang juga memiliki ErrorCodeproperti. Alternatifnya akan seperti itu:

try
{
    SomeLegacyComOperation();
}
catch (COMException e)
{
    if (e.ErrorCode == 0x1234)
    {
        // Handle error
    }
    else
    {
        throw;
    }
}

yang bisa dibilang kurang elegan dan sedikit merusak stack trace .

Selain itu, Anda dapat menyebutkan jenis pengecualian yang sama dua kali dalam blok coba-tangkap yang sama:

try
{
    SomeLegacyComOperation();
}
catch (COMException e) when (e.ErrorCode == 0x1234)
{
    ...
}
catch (COMException e) when (e.ErrorCode == 0x5678)
{
    ...
}

yang tidak akan mungkin terjadi tanpa whenkondisi tersebut.

Dari wiki Roslyn (penekanan milik saya):

Filter pengecualian lebih disukai daripada menangkap dan melempar ulang karena mereka membiarkan tumpukan tidak terganggu . Jika pengecualian nanti menyebabkan tumpukan dibuang, Anda dapat melihat dari mana asalnya, bukan hanya tempat terakhir dimunculkan kembali.

Ini juga merupakan bentuk umum dan diterima dari "penyalahgunaan" untuk menggunakan filter pengecualian untuk efek samping; misalnya penebangan. Mereka dapat memeriksa pengecualian "terbang lewat" tanpa menghalangi jalurnya . Dalam kasus tersebut, filter akan sering menjadi panggilan ke fungsi helper kembali-palsu yang mengeksekusi efek samping:

private static bool Log(Exception e) { /* log it */ ; return false; }

… try { … } catch (Exception e) when (Log(e)) { }

Poin pertama patut didemonstrasikan.

static class Program
{
    static void Main(string[] args)
    {
        A(1);
    }

    private static void A(int i)
    {
        try
        {
            B(i + 1);
        }
        catch (Exception ex)
        {
            if (ex.Message != "!")
                Console.WriteLine(ex);
            else throw;
        }
    }

    private static void B(int i)
    {
        throw new Exception("!");
    }
}

Jika kita menjalankan ini di WinDbg hingga pengecualian tercapai, dan mencetak tumpukan menggunakan !clrstack -i -akita akan melihat bingkai dari A:

003eef10 00a7050d [DEFAULT] Void App.Program.A(I4)

PARAMETERS:
  + int i  = 1

LOCALS:
  + System.Exception ex @ 0x23e3178
  + (Error 0x80004005 retrieving local variable 'local_1')

Namun, jika kita mengubah program untuk menggunakan when:

catch (Exception ex) when (ex.Message != "!")
{
    Console.WriteLine(ex);
}

Kami akan melihat tumpukan juga berisi Bbingkai:

001af2b4 01fb05aa [DEFAULT] Void App.Program.B(I4)

PARAMETERS:
  + int i  = 2

LOCALS: (none)

001af2c8 01fb04c1 [DEFAULT] Void App.Program.A(I4)

PARAMETERS:
  + int i  = 1

LOCALS:
  + System.Exception ex @ 0x2213178
  + (Error 0x80004005 retrieving local variable 'local_1')

Informasi tersebut bisa sangat berguna saat men-debug crash dump.

Ketika sebuah eksepsi dilemparkan, lintasan pertama penanganan eksepsi mengidentifikasi di mana eksepsi akan ditangkap sebelum melepaskan tumpukan; jika / ketika lokasi "catch" diidentifikasi, semua blok "akhirnya" dijalankan (perhatikan bahwa jika pengecualian lolos dari blok "akhirnya", pemrosesan pengecualian sebelumnya dapat ditinggalkan). Setelah itu terjadi, kode akan melanjutkan eksekusi di "catch".

Jika ada breakpoint dalam fungsi yang dievaluasi sebagai bagian dari "when", breakpoint tersebut akan menangguhkan eksekusi sebelum stack unwinding terjadi; sebaliknya, breakpoint pada "catch" hanya akan menghentikan eksekusi setelah semua finallyhandler berjalan.

Akhirnya, jika baris 23 dan 27 foopanggilan bar, dan panggilan pada baris 23 melontarkan pengecualian yang tertangkap di dalam foodan ditarik kembali pada baris 57, maka jejak tumpukan akan menyarankan bahwa pengecualian terjadi saat memanggil bardari baris 57 [lokasi pelemparan ulang] , menghancurkan informasi apa pun tentang apakah pengecualian terjadi pada panggilan baris-23 atau baris-27. Menggunakan whenuntuk menghindari menangkap pengecualian di tempat pertama menghindari gangguan seperti itu.

BTW, pola berguna yang sangat aneh di C # dan VB.NET adalah menggunakan pemanggilan fungsi dalam whenklausa untuk menyetel variabel yang dapat digunakan dalam finallyklausa untuk menentukan apakah fungsi selesai secara normal, untuk menangani kasus di mana suatu fungsi tidak memiliki harapan untuk "menyelesaikan" pengecualian apa pun yang terjadi tetapi harus mengambil tindakan berdasarkan pengecualian tersebut. Misalnya, jika pengecualian dilemparkan dalam metode pabrik yang seharusnya mengembalikan objek yang merangkum sumber daya, sumber daya apa pun yang diperoleh harus dirilis, tetapi pengecualian yang mendasarinya harus meresap ke pemanggil. Cara terbersih untuk menanganinya secara semantik (meskipun tidak secara sintaksis) adalah dengan memiliki filefinallycekal apakah pengecualian terjadi dan, jika demikian, lepaskan semua sumber daya yang diperoleh atas nama objek yang tidak akan dikembalikan. Karena kode pembersihan tidak memiliki harapan untuk menyelesaikan kondisi apa pun yang menyebabkan pengecualian, seharusnya tidak catchdemikian, tetapi hanya perlu mengetahui apa yang terjadi. Memanggil fungsi seperti:

bool CopySecondArgumentToFirstAndReturnFalse<T>(ref T first, T second)
{
  first = second;
  return false;
}

dalam whenklausa akan memungkinkan fungsi pabrik untuk mengetahui bahwa sesuatu telah terjadi.