在finally块中抛出异常

Question

有没有办法获取当前抛出的异常（如果存在）？

我想减少代码量并对任务进行一些重用，如下所示：

Exception thrownException = null;
try {
    // some code with 3rd party classes, which can throw unexpected exceptions
}
catch( Exception exc ) {
    thrownException = exc;
    LogException( exc );
}
finally {
    if ( null == thrownException ) {
        // some code
    }
    else {
        // some code
    }
}

并将其替换为以下代码：

using( ExceptionHelper.LogException() ) {
    // some code with 3rd party classes, which can throw unexpected exceptions
}
using( new ExceptionHelper { ExceptionAction = ()=> /*some cleaning code*/ } ) {
    // some code with 3rd party classes, which can throw unexpected exceptions
}

public class ExceptiohHelper : IDisposable {
    public static ExceptionHelper LogException() {
        return new ExceptionHelper();
    }

    public Action SuccessfulAction {get; set;}
    public Action ExceptionAction {get; set;}

    public void Dispose() {
        Action action;
        Exception thrownException = TheMethodIDontKnow();
        if ( null != thrownException ) {
            LogException( thrownException );
            action = this.ExceptionAction;
        }
        else {
            action = this.SuccessfulAction;
        }

        if ( null != action ) {
            action();
        }
    }
}

这种情况可能吗？

谢谢

Answer 1

这个想法是在 catch 块中处理异常...

也就是说，Exception 是引用类型，因此您始终可以在 try 范围之外声明 Exception 变量...

Exception dontDoThis;
try
{
    foo.DoSomething();
}
catch(Exception e)
{
    dontDoThis = e;
}
finally
{
    // use dontDoThis...
}

Answer 2

对于下面的事情你有什么看法呢。不要将问题视为“如何获取最后一个异常？”，而是将其更改为“如何通过更多控制来运行一段代码？”会怎样？

例如：
您可以使用 ActionRunner，而不是 ExceptionHelper。

public class ActionRunner
{
    public Action AttemptAction { get; set; }
    public Action SuccessfulAction { get; set; }
    public Action ExceptionAction { get; set; }

    public void RunAction()
    {
        try
        {
            AttemptAction();
            SuccessfulAction();
        }
        catch (Exception ex)
        {
            LogException(ex);
            ExceptionAction();
        }
    }

    private void LogException(Exception thrownException) { /* log here... */ }
}

假设只有 AttemptAction 在调用之间有所不同，它至少会给您一些 SuccessAction 和 ExceptionAction 的重用。

var actionRunner = new ActionRunner
{
    AttemptAction = () =>
    {
        Console.WriteLine("Going to throw...");
        throw new Exception("Just throwing");
    },
    ExceptionAction = () => Console.WriteLine("ExceptionAction"),
    SuccessfulAction = () => Console.WriteLine("SuccessfulAction"),
};
actionRunner.RunAction();

actionRunner.AttemptAction = () => Console.WriteLine("Running some other code...");
actionRunner.RunAction();

Answer 3

如果您希望捕获意外异常，则应该处理 UnhandledException 。您应该只在您打算处理的较低级别捕获异常（而不仅仅是记录），否则您应该让它们冒泡并在较高级别捕获，或者正如我之前在 UnhandledException 方法中提到的那样。

Answer 4

这是一个非常古老的问题，但现在有一些可能性。

此 github 问题包含如何实现此目的的示例：

async Task Main()
{
    using var activity1 = new Activity();
    try
    {
        using var activity2 = new Activity();
        await ThrowAsync();
    }
    catch
    {       
    }
}

public Task ThrowAsync() => Task.Run(() => throw new OperationCanceledException());

public sealed class Activity : IDisposable
{
    [ThreadStatic]
    private static GCHandle _currentExceptionHandle;
    
    static Activity()
    {
        AppDomain.CurrentDomain.FirstChanceException += (s,e) =>
        {
            if (_currentExceptionHandle.IsAllocated)
            {
                _currentExceptionHandle.Free();
            }
            _currentExceptionHandle = GCHandle.Alloc(e.Exception, GCHandleType.Weak);
        };
    }
    
    private readonly IntPtr _exceptionAddress;

    public Activity()
    {
        _exceptionAddress = Marshal.GetExceptionPointers();
    }

    public void Dispose()
    {
        var curentExceptionAddr = Marshal.GetExceptionPointers();
        var isExceptionBubblingUp = _exceptionAddress != curentExceptionAddr && curentExceptionAddr != IntPtr.Zero;
        if (isExceptionBubblingUp && _currentExceptionHandle.Target is Exception currentException)
        {
            Console.WriteLine($"Thrown exception {currentException}");
        }
        else if (_currentExceptionHandle.IsAllocated)
        {
            _currentExceptionHandle.Free();
        }
    }
}