Điều gì xảy ra nếu một khối cuối cùng ném một ngoại lệ?

Nếu một khối cuối cùng ném một ngoại lệ, chính xác thì chuyện gì sẽ xảy ra?

Cụ thể, điều gì xảy ra nếu ngoại lệ được ném giữa chừng qua một khối cuối cùng. Phần còn lại của câu lệnh (sau) trong khối này có được gọi không?

Tôi biết rằng các ngoại lệ sẽ lan truyền lên trên.

Nếu một khối cuối cùng ném một ngoại lệ chính xác những gì xảy ra?

Ngoại lệ đó lan truyền ra ngoài và sẽ (có thể) được xử lý ở mức cao hơn.

Khối cuối cùng của bạn sẽ không được hoàn thành ngoài điểm ném ngoại lệ.

Nếu khối cuối cùng được thực thi trong quá trình xử lý một ngoại lệ trước đó thì ngoại lệ đầu tiên đó sẽ bị mất.

Đặc tả ngôn ngữ C # 4 § 8,9.5: Nếu khối cuối cùng ném ngoại lệ khác, việc xử lý ngoại lệ hiện tại bị chấm dứt.

Đối với những câu hỏi như thế này, tôi thường mở một dự án ứng dụng bảng điều khiển trống trong Visual Studio và viết một chương trình mẫu nhỏ:

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

Khi bạn chạy chương trình, bạn sẽ thấy thứ tự chính xác trong đó catch và finallycác khối được thực thi. Xin lưu ý rằng mã trong khối cuối cùng sau khi ném ngoại lệ sẽ không được thực thi (thực tế, trong chương trình mẫu này, Visual Studio thậm chí sẽ cảnh báo bạn rằng nó đã phát hiện mã không thể truy cập được):

Xử lý khối bắt bên trong ngoại lệ ném từ khối thử.
Khối cuối cùng bên trong
Xử lý ngoại lệ khối bắt bên ngoài ném từ khối cuối cùng.
Bên ngoài khối cuối cùng

Ghi chú bổ sung

Như Michael Damatov đã chỉ ra, một ngoại lệ từ trykhối sẽ bị "ăn" nếu bạn không xử lý nó trong catchkhối (bên trong) . Trong thực tế, trong ví dụ trên, ngoại lệ ném lại không xuất hiện trong khối bắt bên ngoài. Để làm cho điều đó rõ ràng hơn nữa, nhìn vào mẫu được sửa đổi một chút sau đây:

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

Như bạn có thể thấy từ đầu ra, ngoại lệ bên trong là "mất" (tức là bị bỏ qua):

Khối cuối cùng bên trong
Xử lý ngoại lệ khối bắt bên ngoài ném từ khối cuối cùng.
Bên ngoài khối cuối cùng

Nếu có một ngoại lệ đang chờ xử lý (khi trykhối có finallynhưng không có catch), ngoại lệ mới sẽ thay thế ngoại lệ đó.

Nếu không có ngoại lệ đang chờ xử lý, nó hoạt động giống như ném một ngoại lệ bên ngoài finallykhối.

Ngoại lệ được tuyên truyền.

Đoạn mã nhanh (và khá rõ ràng) để lưu "ngoại lệ gốc" (ném theo trykhối) và hy sinh "ngoại lệ cuối cùng" (ném theo finallykhối), trong trường hợp bản gốc quan trọng hơn đối với bạn:

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

Khi mã ở trên được thực thi, "Ngoại lệ gốc" sẽ truyền lên ngăn xếp cuộc gọi và "Cuối cùng là ngoại lệ" bị mất.

Tôi đã phải làm điều này để bắt lỗi khi cố gắng đóng một luồng không bao giờ được mở vì một ngoại lệ.

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

nếu webRequest được tạo nhưng đã xảy ra lỗi kết nối trong quá trình

using (var sw = webRequest.GetRequestStream())

sau đó cuối cùng sẽ bắt gặp một ngoại lệ khi cố gắng đóng các kết nối mà nó nghĩ là mở vì webRequest đã được tạo.

Nếu cuối cùng không có thử bắt bên trong, mã này sẽ gây ra ngoại lệ chưa được xử lý trong khi dọn dẹp webRequest

if (webRequest.GetRequestStream() != null) 

từ đó mã sẽ thoát mà không xử lý đúng lỗi đã xảy ra và do đó gây ra sự cố cho phương thức gọi.

Hy vọng điều này sẽ giúp làm ví dụ

Ném một ngoại lệ trong khi một ngoại lệ khác đang hoạt động sẽ dẫn đến ngoại lệ đầu tiên được thay thế bằng ngoại lệ thứ hai (sau này).

Đây là một số mã minh họa những gì xảy ra:

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

• Chạy mã và bạn sẽ thấy "ngoại lệ thứ hai"
• Bỏ ghi chú các câu lệnh thử và bắt và bạn sẽ thấy "ngoại lệ đầu tiên"
• Cũng không chú ý đến việc ném; tuyên bố và bạn sẽ thấy "ngoại lệ thứ hai" một lần nữa.

Vài tháng trước tôi cũng phải đối mặt với một cái gì đó như thế này,

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

Để giải quyết vấn đề như vậy tôi đã tạo một lớp tiện ích như

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

Và được sử dụng như thế này

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

nhưng nếu bạn muốn sử dụng paramaters và trả về các loại đó là một câu chuyện khác

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

Cách xử lý các ngoại lệ do CodeA và CodeB xử lý là như nhau.

Một ngoại lệ được ném trong một finallykhối không có gì đặc biệt, coi nó là ngoại lệ được ném bởi mã B.

Ngoại lệ lan truyền lên, và nên được xử lý ở mức cao hơn. Nếu ngoại lệ không được xử lý ở cấp cao hơn, ứng dụng sẽ gặp sự cố. Việc thực thi khối "cuối cùng" dừng tại điểm ném ngoại lệ.

Bất kể có một ngoại lệ hay không, khối "cuối cùng" được đảm bảo để thực thi.

1. Nếu khối "cuối cùng" đang được thực thi sau khi xảy ra ngoại lệ trong khối thử,

2. và nếu ngoại lệ đó không được xử lý

3. và nếu khối cuối cùng ném một ngoại lệ

Sau đó, ngoại lệ ban đầu xảy ra trong khối thử bị mất.

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

Bài viết tuyệt vời để biết chi tiết

Nó ném một ngoại lệ;) Bạn có thể bắt ngoại lệ đó trong một số mệnh đề bắt khác.