如何确定.NET异常是否正在被处理？

Question

我们正在研究 C# 中的一种编码模式，其中我们希望将“using”子句与一个特殊类一起使用，其 Dispose() 方法根据“using”主体是否执行不同的操作正常退出或异常退出。

据我所知，CLR 会跟踪当前正在处理的异常，直到它被“catch”处理程序消耗为止。然而，尚不完全清楚这些信息是否以任何方式暴露给代码访问。您知道是否存在，如果是，如何访问它？

例如：

using (var x = new MyObject())
{
    x.DoSomething();
    x.DoMoreThings();
}

class MyObject : IDisposable
{
    public void Dispose()
    {
        if (ExceptionIsBeingHandled)
            Rollback();
        else
            Commit();
    }
}

这看起来几乎像 System.Transactions.TransactionScope ，只不过成功/失败不是由调用 x.Complete() 确定的，而是基于是否using 主体正常退出。

Answer 1

https://www.codewrecks.com/post/old/2008/07/Detecting-if-finally-block-is-executing-for-an-manhandled-exception/ 描述了一种用于检测的“黑客”行为您的代码是否在异常处理模式下执行。它使用 Marshal.GetExceptionPointers 查看异常是否“活动”。

但请记住：

备注

GetExceptionPointers 仅为结构化异常处理 (SEH) 的编译器支持而公开。
注意注：

该方法使用SecurityAction.LinkDemand来防止不受信任的代码调用它；仅直接调用方需要具有 SecurityPermissionAttribute.UnmanagedCode 权限。如果可以从部分受信任的代码调用您的代码，请勿在未经验证的情况下将用户输入传递给 Marshal 类方法。有关使用 LinkDemand 成员的重要限制，请参阅 Demand 与 LinkDemand。

Answer 2

不是问题的答案，只是注意我从未最终在实际代码中使用“接受的”黑客，因此它仍然在很大程度上未经“野外”测试。相反，我们采用了这样的方法：

DoThings(x =>
{
    x.DoSomething();
    x.DoMoreThings();
});

其中

public void DoThings(Action<MyObject> action)
{
    bool success = false;
    try
    {
        action(new MyObject());
        Commit();
        success = true;
    }
    finally
    {
        if (!success)
            Rollback();
    }
}

关键点是它与问题中的“使用”示例一样紧凑，并且不使用任何 hack。

其中的缺点是性能损失（在我们的例子中完全可以忽略不计），以及当我实际上希望 F10 直接进入 x.DoSomething() 时，它会进入 DoThings。两者都很小。

Answer 3

您无法获得此信息。

我将使用类似于 DbTransaction 类所使用的模式：也就是说，您的 IDisposable 类应该实现与 DbTransaction.Commit() 类似的方法。然后，您的 Dispose 方法可以根据是否调用 Commit 来执行不同的逻辑（在 DbTransaction 的情况下，如果未显式提交事务，则事务将回滚）。

然后，您班级的用户将使用以下模式，类似于典型的 DbTransaction：

using(MyDisposableClass instance = ...)
{
    ... do whatever ...

    instance.Commit();
} // Dispose logic depends on whether or not Commit was called.

编辑 我看到您已编辑您的问题以表明您了解此模式（您的示例使用 TransactionScope）。尽管如此，我认为这是唯一现实的解决方案。

Answer 4

using 语句只是 try finally 块的语法糖。您可以通过完整地编写 tryfinally ，然后添加一个 catch 语句来处理您的特殊情况来获得您想要的东西：

try
{
    IDisposable x = new MyThing();
}
catch (Exception exception) // Use a more specific exception if possible.
{
    x.ErrorOccurred = true; // You could even pass a reference to the exception if you wish.
    throw;
}
finally
{
    x.Dispose();
}

在 MyThing 中，如果您愿意，您可以这样做，例如：

class MyThing : IDisposable
{
    public bool ErrorOccurred() { get; set; }

    public void Dispose()
    {
        if (ErrorOccurred) {
            RollBack();
        } else {
            Commit();
        }
    }
}

注意：我还想知道为什么您想要做这个。它有一些代码味道。 Dispose 方法旨在清理非托管资源，而不是处理异常。您可能最好在 catch 块中编写异常处理代码，而不是在 dispose 中，并且如果您需要共享代码，请创建一些可以从这两个地方调用的有用的辅助函数。

这是做你想做的事情的更好方法：

using (IDisposable x = new MyThing())
{
    x.Foo();
    x.Bar();
    x.CommitChanges();
}

class MyThing : IDisposable
{
    public bool IsCommitted { get; private set; }

    public void CommitChanges()
    {
        // Do stuff needed to commit.
        IsCommitted = true;
    }

    public void Dispose()
    {
        if (!IsCommitted)
            RollBack();
    }
}

Answer 5

这似乎并不是一个坏主意。它在 C#/.NET 中似乎并不理想。

在 C++ 中，有一个函数可以使代码检测它是否由于异常而被调用。这对于 RAII 析构函数来说是最重要的；对于析构函数来说，根据控制流是正常还是异常来选择提交或中止是一件小事。我认为这是一种相当自然的方法，但缺乏内置支持（以及解决方法在道德上可疑的性质；对我来说，它感觉相当依赖于实现）可能意味着应该采取更传统的方法。