Was passiert, wenn ein finally-Block eine Ausnahme auslöst?

Was passiert genau , wenn ein finally-Block eine Ausnahme auslöst?

Was passiert insbesondere, wenn die Ausnahme in der Mitte eines finally-Blocks ausgelöst wird? Werden die restlichen Anweisungen (nach) in diesem Block aufgerufen?

Mir ist bewusst, dass sich Ausnahmen nach oben ausbreiten werden.

Wenn ein finally-Block eine Ausnahme auslöst , was genau passiert dann?

Diese Ausnahme breitet sich immer weiter aus und wird (kann) auf einer höheren Ebene behandelt.

Ihr endgültiger Block wird nicht über den Punkt hinaus abgeschlossen, an dem die Ausnahme ausgelöst wird.

Wenn der finally-Block während der Behandlung einer früheren Ausnahme ausgeführt wurde, geht diese erste Ausnahme verloren.

C # 4-Sprachspezifikation § 8.9.5: Wenn der finally-Block eine weitere Ausnahme auslöst, wird die Verarbeitung der aktuellen Ausnahme beendet.

Bei Fragen wie diesen öffne ich normalerweise ein leeres Konsolenanwendungsprojekt in Visual Studio und schreibe ein kleines Beispielprogramm:

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

Wenn Sie das Programm ausführen, sehen Sie die genaue Reihenfolge, in der catchund finallyBlöcke ausgeführt werden. Beachten Sie, dass Code im finally-Block nach dem Auslösen der Ausnahme nicht ausgeführt wird (in diesem Beispielprogramm warnt Visual Studio Sie sogar, dass nicht erreichbarer Code erkannt wurde):

Ausnahme beim Behandeln des inneren Fangblocks vom Try-Block ausgelöst.
Inner endlich blockieren
Ausnahme für die Behandlung des äußeren Fangblocks, die vom endgültigen Block ausgelöst wird.
Außen endlich blockieren

Zusätzliche Bemerkung

Wie Michael Damatov betonte, wird eine Ausnahme vom tryBlock "gegessen", wenn Sie sie nicht in einem (inneren) catchBlock behandeln. Tatsächlich wird im obigen Beispiel die erneut ausgelöste Ausnahme nicht im äußeren Catch-Block angezeigt. Um dies noch deutlicher zu machen, schauen Sie sich das folgende leicht modifizierte Beispiel an:

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

Wie Sie aus der Ausgabe sehen können, ist die innere Ausnahme "verloren" (dh ignoriert):

Inner endlich blockieren
Ausnahme für die Behandlung des äußeren Fangblocks, die vom endgültigen Block ausgelöst wird.
Außen endlich blockieren

Wenn eine Ausnahme aussteht (wenn der tryBlock eine, finallyaber keine hat catch), ersetzt die neue Ausnahme diese.

Wenn keine Ausnahme ansteht, funktioniert dies genauso wie das Auslösen einer Ausnahme außerhalb des finallyBlocks.

Die Ausnahme wird weitergegeben.

Schnelles (und ziemlich offensichtliches) Snippet zum Speichern der "ursprünglichen Ausnahme" (in tryBlock geworfen ) und zum Opfer von "endgültige Ausnahme" (in finallyBlock geworfen ), falls das Original für Sie wichtiger ist:

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

Wenn der obige Code ausgeführt wird, überträgt "Original Exception" den Aufrufstapel und "Endlich Exception" geht verloren.

Ich musste dies tun, um einen Fehler beim Schließen eines Streams zu erkennen, der aufgrund einer Ausnahme nie geöffnet wurde.

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

Wenn die webRequest erstellt wurde, aber während des ein Verbindungsfehler aufgetreten ist

using (var sw = webRequest.GetRequestStream())

Dann würde der Endlich eine Ausnahme abfangen, die versucht, Verbindungen zu schließen, die er für offen hielt, weil die webRequest erstellt wurde.

Wenn der Code schließlich keinen Try-Catch enthalten würde, würde dieser Code beim Bereinigen der webRequest eine nicht behandelte Ausnahme verursachen

if (webRequest.GetRequestStream() != null) 

Von dort aus würde der Code beendet, ohne den aufgetretenen Fehler ordnungsgemäß zu behandeln, und daher Probleme für die aufrufende Methode verursachen.

Hoffe das hilft als Beispiel

Wenn Sie eine Ausnahme auslösen, während eine andere Ausnahme aktiv ist, wird die erste Ausnahme durch die zweite (spätere) Ausnahme ersetzt.

Hier ist ein Code, der veranschaulicht, was passiert:

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

• Führen Sie den Code aus und Sie sehen "zweite Ausnahme"
• Kommentieren Sie die try and catch-Anweisungen aus und Sie sehen "erste Ausnahme".
• Kommentieren Sie auch den Wurf aus; Anweisung und Sie werden wieder "zweite Ausnahme" sehen.

Vor einigen Monaten stand ich auch so etwas gegenüber,

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

Um dieses Problem zu lösen, habe ich eine Utility-Klasse wie erstellt

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

Und so verwendet

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

Wenn Sie jedoch Parameter und Rückgabetypen verwenden möchten, ist dies eine andere Geschichte

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

Die Art und Weise, wie die von CodeA und CodeB ausgelösten Ausnahmen behandelt werden, ist dieselbe.

Eine in einem finallyBlock ausgelöste Ausnahme hat nichts Besonderes. Behandeln Sie sie als den durch Code B ausgelösten Ausnahmefall.

Die Ausnahme breitet sich aus und sollte auf einer höheren Ebene behandelt werden. Wenn die Ausnahme nicht auf der höheren Ebene behandelt wird, stürzt die Anwendung ab. Die Blockausführung "finally" stoppt an dem Punkt, an dem die Ausnahme ausgelöst wird.

Unabhängig davon, ob es eine Ausnahme gibt oder nicht, wird die Ausführung des Blocks "finally" garantiert.

1. Wenn der "finally" -Block ausgeführt wird, nachdem im try-Block eine Ausnahme aufgetreten ist,

2. und wenn diese Ausnahme nicht behandelt wird

3. und wenn der finally-Block eine Ausnahme auslöst

Dann geht die ursprüngliche Ausnahme, die im try-Block aufgetreten ist, verloren.

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

Toller Artikel für Details

Es wird eine Ausnahme ausgelöst;) Sie können diese Ausnahme in einer anderen catch-Klausel abfangen.