如果finally块引发异常,究竟发生了什么?
具体来说,如果在finally块的中间抛出异常,会发生什么情况。该块中的其余语句(之后)是否被调用?
我知道异常会向上传播。
如果finally块引发异常,究竟发生了什么?
具体来说,如果在finally块的中间抛出异常,会发生什么情况。该块中的其余语句(之后)是否被调用?
我知道异常会向上传播。
Answers:
如果finally块引发异常,究竟发生了什么?
该异常会不断传播,并将(可以)在更高级别上进行处理。
你的finally块不会在引发异常的地方完成。
如果在处理较早的异常期间执行了finally块,则该第一个异常将丢失。
C#4语言规范§8.9.5:如果finally块引发另一个异常,则终止当前异常的处理。
ThreadAbortException
,否则整个finally块将首先完成,因为它是关键部分。
对于此类问题,我通常在Visual Studio中打开一个空的控制台应用程序项目,并编写一个小示例程序:
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");
}
}
}
运行程序时,您将看到执行catch
和finally
块的确切顺序。请注意,引发异常后的finally块中的代码将不会执行(实际上,在此示例程序中,Visual Studio甚至会警告您它检测到无法访问的代码):
从try块引发的内部catch块处理异常。 内心终于挡住了 从finally块引发的外部catch块处理异常。 外面终于挡住了
附加说明
正如迈克尔·达马托夫(Michael Damatov)所指出的,try
如果不在(内部)catch
块中处理该块,则会“吃掉” 该异常。实际上,在上面的示例中,重新抛出的异常没有出现在外部catch块中。为了更清楚地了解以下经过修改的示例:
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");
}
}
}
从输出中可以看到,内部异常是“丢失”(即被忽略):
内心终于挡住了 从finally块引发的外部catch块处理异常。 外面终于挡住了
finally
块(几乎)将始终执行,在这种情况下,内部的finally块也将保持这种状态(只需自己尝试示例程序(在不可恢复的情况下将不执行finally块)例外,例如EngineExecutionException
,但是在这种情况下,您的程序将立即终止)
如果有一个未决异常(当try
块中有一个finally
no时catch
),则新异常将替换该异常。
如果没有等待处理的异常,它将像在finally
块外抛出异常一样工作。
catch
块(重新)抛出异常。
我必须这样做是为了捕获试图关闭由于异常而从未打开过的流的错误。
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();
}
}
如果创建了webRequest,但是在
using (var sw = webRequest.GetRequestStream())
然后,最终将捕获异常,试图关闭它认为已打开的连接,因为已创建了webRequest。
如果最后在内部没有try-catch,则此代码在清理webRequest时将导致未处理的异常
if (webRequest.GetRequestStream() != null)
从那里开始,代码将无法正确处理所发生的错误而退出,从而导致调用方法出现问题。
希望这可以为例
在另一个异常处于活动状态时抛出异常将导致第一个异常被第二个(后来的)异常替换。
以下代码说明了发生的情况:
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);
}
}
几个月前,我也遇到过这样的事情,
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();
}
为了解决这样的问题,我制作了一个实用程序类,例如
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;
}
}
}
像这样使用
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);
}
但是如果您想使用参数和返回类型,那就另当别论了
异常会传播出去,应在更高级别上进行处理。如果未在更高级别上处理异常,则应用程序将崩溃。“最终”块的执行在引发异常的点停止。
无论是否有异常,“ finally”块都可以保证执行。
如果在try块中发生异常后正在执行“ finally”块,
如果没有处理该异常
如果finally块引发异常
然后,try块中发生的原始异常将丢失。
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");
}
}
}