Apa yang terjadi jika blok akhirnya melempar pengecualian?

Jika blok akhirnya melempar pengecualian, apa yang sebenarnya terjadi?

Secara khusus, apa yang terjadi jika pengecualian dilemparkan di tengah jalan melalui blok akhirnya. Apakah sisa pernyataan (setelah) di blok ini dipanggil?

Saya menyadari bahwa pengecualian akan menyebar ke atas.

Jika blok akhirnya melempar pengecualian apa yang sebenarnya terjadi?

Pengecualian itu menyebar keluar dan naik, dan akan (dapat) ditangani pada tingkat yang lebih tinggi.

Blok Anda akhirnya tidak akan selesai melampaui titik di mana pengecualian dilemparkan.

Jika blok akhirnya dieksekusi selama penanganan pengecualian sebelumnya maka pengecualian pertama hilang.

C # 4 Spesifikasi Bahasa § 8.9.5: Jika blok akhirnya mengeluarkan pengecualian lain, pemrosesan pengecualian saat ini dihentikan.

Untuk pertanyaan seperti ini, saya biasanya membuka proyek aplikasi konsol kosong di Visual Studio dan menulis program sampel kecil:

using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            try
            {
                throw new Exception("exception thrown from try block");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Inner catch block handling {0}.", ex.Message);
                throw;
            }
            finally
            {
                Console.WriteLine("Inner finally block");
                throw new Exception("exception thrown from finally block");
                Console.WriteLine("This line is never reached");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Outer catch block handling {0}.", ex.Message);
        }
        finally
        {
            Console.WriteLine("Outer finally block");
        }
    }
}

Ketika Anda menjalankan program ini, Anda akan melihat urutan yang tepat di mana catchdan finallyblok dieksekusi. Harap dicatat bahwa kode di blok akhirnya setelah pengecualian dilemparkan tidak akan dieksekusi (pada kenyataannya, dalam program sampel ini Visual Studio bahkan akan memperingatkan Anda bahwa ia telah mendeteksi kode yang tidak terjangkau):

Pengecualian penanganan blok tangkapan dalam dilemparkan dari blok percobaan.
Bagian dalam akhirnya menghalangi
Pengecualian penanganan tangkapan blok luar dilempar dari akhirnya blok.
Bagian luar akhirnya menghalangi

Keterangan tambahan

Seperti yang ditunjukkan Michael Damatov, pengecualian dari tryblok akan "dimakan" jika Anda tidak menanganinya di catchblok (bagian dalam) . Bahkan, dalam contoh di atas pengecualian yang dilemparkan kembali tidak muncul di blok tangkapan luar. Untuk membuatnya terlihat lebih jelas pada sampel yang sedikit dimodifikasi berikut ini:

using System;

class Program
{
    static void Main(string[] args)
    {
        try
        {
            try
            {
                throw new Exception("exception thrown from try block");
            }
            finally
            {
                Console.WriteLine("Inner finally block");
                throw new Exception("exception thrown from finally block");
                Console.WriteLine("This line is never reached");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine("Outer catch block handling {0}.", ex.Message);
        }
        finally
        {
            Console.WriteLine("Outer finally block");
        }
    }
}

Seperti yang Anda lihat dari output, pengecualian dalam adalah "hilang" (yaitu diabaikan):

Bagian dalam akhirnya menghalangi
Pengecualian penanganan tangkapan blok luar dilempar dari akhirnya blok.
Bagian luar akhirnya menghalangi

Jika ada pengecualian tertunda (ketika tryblok memiliki finallytetapi tidak catch), pengecualian baru menggantikan yang itu.

Jika tidak ada pengecualian yang tertunda, ia berfungsi seperti melempar pengecualian di luar finallyblok.

Pengecualian disebarkan.

Cuplikan cepat (dan agak jelas) untuk menyimpan "pengecualian asli" (dilemparkan ke dalam tryblok) dan mengorbankan "akhirnya pengecualian" (dilemparkan ke dalam finallyblok), jika yang asli lebih penting bagi Anda:

try
{
    throw new Exception("Original Exception");
}
finally
{
    try
    {
        throw new Exception("Finally Exception");
    }
    catch
    { }
}

Ketika kode di atas dijalankan, "Pengecualian Asli" menyebarkan tumpukan panggilan, dan "Pengecualian Akhirnya" hilang.

Saya harus melakukan ini untuk menangkap kesalahan saat mencoba menutup aliran yang tidak pernah dibuka karena pengecualian.

errorMessage = string.Empty;

try
{
    byte[] requestBytes = System.Text.Encoding.ASCII.GetBytes(xmlFileContent);

    webRequest = WebRequest.Create(url);
    webRequest.Method = "POST";
    webRequest.ContentType = "text/xml;charset=utf-8";
    webRequest.ContentLength = requestBytes.Length;

    //send the request
    using (var sw = webRequest.GetRequestStream()) 
    {
        sw.Write(requestBytes, 0, requestBytes.Length);
    }

    //get the response
    webResponse = webRequest.GetResponse();
    using (var sr = new StreamReader(webResponse.GetResponseStream()))
    {
        returnVal = sr.ReadToEnd();
        sr.Close();
    }
}
catch (Exception ex)
{
    errorMessage = ex.ToString();
}
finally
{
    try
    {
        if (webRequest.GetRequestStream() != null)
            webRequest.GetRequestStream().Close();
        if (webResponse.GetResponseStream() != null)
            webResponse.GetResponseStream().Close();
    }
    catch (Exception exw)
    {
        errorMessage = exw.ToString();
    }
}

jika webRequest dibuat tetapi terjadi kesalahan koneksi selama

using (var sw = webRequest.GetRequestStream())

kemudian yang terakhir akan menangkap pengecualian yang mencoba menutup koneksi yang dianggapnya terbuka karena webRequest telah dibuat.

Jika akhirnya tidak memiliki try-catch di dalam, kode ini akan menyebabkan pengecualian tidak tertangani saat membersihkan webRequest

if (webRequest.GetRequestStream() != null) 

dari sana kode akan keluar tanpa benar menangani kesalahan yang terjadi dan karena itu menyebabkan masalah untuk metode panggilan.

Semoga ini bisa membantu sebagai contoh

Melempar pengecualian saat pengecualian lain aktif akan menghasilkan pengecualian pertama digantikan oleh pengecualian kedua (nanti).

Berikut adalah beberapa kode yang menggambarkan apa yang terjadi:

    public static void Main(string[] args)
    {
        try
        {
            try
            {
                throw new Exception("first exception");
            }
            finally
            {
                //try
                {
                    throw new Exception("second exception");
                }
                //catch (Exception)
                {
                    //throw;
                }
            }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

• Jalankan kode dan Anda akan melihat "pengecualian kedua"
• Batalkan komentar mencoba dan menangkap pernyataan dan Anda akan melihat "pengecualian pertama"
• Hapus tanda komentar lemparan; pernyataan dan Anda akan melihat "pengecualian kedua" lagi.

Beberapa bulan yang lalu saya juga menghadapi sesuatu seperti ini,

    private  void RaiseException(String errorMessage)
    {
        throw new Exception(errorMessage);
    }

    private  void DoTaskForFinally()
    {
        RaiseException("Error for finally");
    }

    private  void DoTaskForCatch()
    {
        RaiseException("Error for catch");
    }

    private  void DoTaskForTry()
    {
        RaiseException("Error for try");
    }


        try
        {
            /*lacks the exception*/
            DoTaskForTry();
        }
        catch (Exception exception)
        {
            /*lacks the exception*/
            DoTaskForCatch();
        }
        finally
        {
            /*the result exception*/
            DoTaskForFinally();
        }

Untuk mengatasi masalah tersebut saya membuat kelas utilitas seperti

class ProcessHandler : Exception
{
    private enum ProcessType
    {
        Try,
        Catch,
        Finally,
    }

    private Boolean _hasException;
    private Boolean _hasTryException;
    private Boolean _hasCatchException;
    private Boolean _hasFinnallyException;

    public Boolean HasException { get { return _hasException; } }
    public Boolean HasTryException { get { return _hasTryException; } }
    public Boolean HasCatchException { get { return _hasCatchException; } }
    public Boolean HasFinnallyException { get { return _hasFinnallyException; } }
    public Dictionary<String, Exception> Exceptions { get; private set; } 

    public readonly Action TryAction;
    public readonly Action CatchAction;
    public readonly Action FinallyAction;

    public ProcessHandler(Action tryAction = null, Action catchAction = null, Action finallyAction = null)
    {

        TryAction = tryAction;
        CatchAction = catchAction;
        FinallyAction = finallyAction;

        _hasException = false;
        _hasTryException = false;
        _hasCatchException = false;
        _hasFinnallyException = false;
        Exceptions = new Dictionary<string, Exception>();
    }


    private void Invoke(Action action, ref Boolean isError, ProcessType processType)
    {
        try
        {
            action.Invoke();
        }
        catch (Exception exception)
        {
            _hasException = true;
            isError = true;
            Exceptions.Add(processType.ToString(), exception);
        }
    }

    private void InvokeTryAction()
    {
        if (TryAction == null)
        {
            return;
        }
        Invoke(TryAction, ref _hasTryException, ProcessType.Try);
    }

    private void InvokeCatchAction()
    {
        if (CatchAction == null)
        {
            return;
        }
        Invoke(TryAction, ref _hasCatchException, ProcessType.Catch);
    }

    private void InvokeFinallyAction()
    {
        if (FinallyAction == null)
        {
            return;
        }
        Invoke(TryAction, ref _hasFinnallyException, ProcessType.Finally);
    }

    public void InvokeActions()
    {
        InvokeTryAction();
        if (HasTryException)
        {
            InvokeCatchAction();
        }
        InvokeFinallyAction();

        if (HasException)
        {
            throw this;
        }
    }
}

Dan digunakan seperti ini

try
{
    ProcessHandler handler = new ProcessHandler(DoTaskForTry, DoTaskForCatch, DoTaskForFinally);
    handler.InvokeActions();
}
catch (Exception exception)
{
    var processError = exception as ProcessHandler;
    /*this exception contains all exceptions*/
    throw new Exception("Error to Process Actions", exception);
}

tetapi jika Anda ingin menggunakan paramater dan mengembalikan tipe itu adalah cerita lain

public void MyMethod()
{
   try
   {
   }
   catch{}
   finally
   {
      CodeA
   }
   CodeB
}

Cara pengecualian yang dilontarkan oleh CodeA dan CodeB ditangani adalah sama.

Pengecualian yang dilemparkan ke dalam finallyblok tidak ada yang spesial, memperlakukannya sebagai pengecualian dengan membuang kode B.

Pengecualian menyebar, dan harus ditangani di tingkat yang lebih tinggi. Jika pengecualian tidak ditangani di tingkat yang lebih tinggi, aplikasi macet. Eksekusi blok "akhirnya" berhenti pada titik di mana pengecualian dilemparkan.

Terlepas dari apakah ada pengecualian atau tidak, blok "akhirnya" dijamin untuk dieksekusi.

1. Jika blok "akhirnya" dijalankan setelah pengecualian terjadi di blok coba,

2. dan jika pengecualian itu tidak ditangani

3. dan jika blok akhirnya melempar pengecualian

Maka pengecualian asli yang terjadi di blok percobaan hilang.

public class Exception
{
    public static void Main()
    {
        try
        {
            SomeMethod();
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
    }

    public static void SomeMethod()
    {
        try
        {
            // This exception will be lost
            throw new Exception("Exception in try block");
        }
        finally
        {
            throw new Exception("Exception in finally block");
        }
    }
} 

Artikel bagus untuk Detail

Ini melempar pengecualian;) Anda dapat menangkap pengecualian itu dalam beberapa klausa tangkapan lainnya.