c# “最后” 仅在异常时运行的块

Question

编辑：我已经查看了答案代码：没有他们做了我想做的事情（我已经检查过）。 似乎没有办法在本机 C# 中做我想做的事情。 我想这不是一场灾难，只是一种耻辱，因为 .NET 确实支持它（请参阅已接受的答案）。

谢谢大家。

---

我有这样的 C# 代码（测试框架的一部分，除了在调试器下之外永远不会运行），它指出它是为了避免实际捕获异常，因为这使得调试堆栈的展开部分中的代码变得非常痛苦。

Bool bad = true;
try
{
   MightThrow();
   bad = false;
}
finally
{
   if(bad) DoSomeLoggingOnFailure();

   //// Does not catch!!!! 
   //// exception continues to unwind stack.

   //// Note that re throwing the exception is NOT
   //// the same as not catching it in the first place
}

他们有更好的方法吗？

对于未捕获的异常，解决方案的行为必须与调试器下的行为完全相同。 它必须导致唯一的一次机会异常，并且调试器在异常最初抛出时中断，而不是在 catch 块中。

具体来说，我需要调试器针对未捕获的异常来停止内部 MightThrow。

以下不起作用，因为它无法让调试器在正确的位置中断

try { ... } catch { throw; }

，而这不起作用，因为它丢失了堆栈信息（并且也在错误的位置中断）。

try { ... } catch(Exception e) { throw e; }

我知道在 D 中我可以使用 范围（失败） 块

Answer 1

怎么样：

try
{
  MightThrow();
}
catch
{
  DoSomethingOnFailure();
  throw; // added based on new information in the original question
}

真的，这就是你所做的一切。 最后是用于无论是否发生异常都必须运行的事情。

[编辑：澄清]

根据您提到的评论，您希望继续引发异常而不修改其原始堆栈跟踪。 在这种情况下，您需要使用我添加的朴素的投掷。 这将允许异常在堆栈中继续向上，并且仍然允许您处理部分异常。 典型的情况可能是关闭网络连接或文件。

[第二次编辑：关于您的澄清]

具体来说，我需要打开调试器
未捕获的异常停止在
投掷的原点（在
MightThrow) 不在 catch 块中。

我反对打破最佳实践（是的，这是部分处理异常的最佳实践）来为调试添加一些次要的价值。 您可以轻松检查异常以确定抛出异常的位置。

[最终编辑：你已经有了答案]

kronoz 已贴心地为您提供了您所寻求的答案。 不要违反最佳实践——正确使用 Visual Studio！ 您可以将 Visual Studio 设置为在引发异常时准确中断。 以下是有关该主题的官方信息。

我实际上不知道这个功能，所以去给他接受的答案。 但是请不要仅仅为了方便自己调试而尝试以某种时髦的方式处理异常。 你所做的就是让自己面对更多的错误。

Answer 2

如果您对调试器只是在异常发生的地方精确停止感兴趣，那么您是否考虑过第一次机会异常？

如果打开“工具”|“异常”，然后勾选“公共语言运行时异常”框，则调试器将在异常点停止，无论是否有任何 try/catch/finally 块。

更新：您可以通过展开“异常”对话框中的 [+] 树来指定要捕获的精确异常。 当然，每次发生指定类型的任何异常时它都会触发，即使在调试会话期间，您也可以随意打开和关闭它，因此请明智地使用使用断点你可以让它执行你的命令。 我成功地使用它来解决由于使用反射来实例化对象而产生的“调用的目标引发了异常”的问题。 在这种情况下非常有用的工具。 另请注意，据我所知，本地变量和堆栈跟踪应该完全可用（刚刚做了一个快速测试，它们可用），所以没有问题。

当然，如果您想记录日志，那么这超出了 IDE 调试器的范围； 在这种情况下，第一次机会例外对你没有帮助！

至少尝试一下； 我发现它们非常有用，并且它们可能比您想象的更适合您的问题。

Answer 3

有什么问题：

try
{
   MightThrow();
}
catch
{
   DoSomthingOnFailure();
   throw;
}

Answer 4

对于只应在异常时运行的代码，请使用 catch 块：

try
{
   MightThrow();
}
catch (Exception ex)
{
   // this runs only when there was an exception
   DoSomthingOnFailure();
   // pass exception on to caller
   throw; 
}
finally
{
   // this runs everytime
   Cleanup();
}

Answer 5

这就是你想要的。 它只会在发生错误时调用此方法，并且“throw”语句将在调用堆栈完好无损的情况下重新抛出异常。

try
{
   MightThrow();
}
catch
{
   DoSomthingOnFailure();
   throw;
}

Answer 6

仅在失败时运行的“finally”块称为“catch”（不带参数）。 :-)

现在，有一个小警告。 如果您希望为特定异常类型提供专门的“catch”情况，并拥有适用于所有异常的通用“catch”，则必须执行一些自定义逻辑。

因此，我会做类似的事情：

  try
  {
    MightThrow();
  }
  catch(MyException ex)
  {
    // Runs on MyException
    MySpecificFailureHandler()
    // Since we have handled the exception and can't execute the generic
    // "catch" block below, we need to explicitly run the generic failure handler
    MyGenericFailureHandler()
  }
  catch
  {
    // Runs on any exception hot handled specifically before
    MyGenericFailureHandler()
    // If you want to mimic "finally" behavior and propagate the exception
    // up the call stack
    throw;
  }
  finally
  {
    // Runs on any failure or success
    MyGenericCleanupHandler();
  }

Answer 7

根据我的测试，到目前为止，每个示例都丢失了原始的 StackTrace。 这是一个应该适合您的解决方案。

private static void PreserveStackTrace(Exception exception)
{
  MethodInfo preserveStackTrace = typeof(Exception).GetMethod("InternalPreserveStackTrace",
    BindingFlags.Instance | BindingFlags.NonPublic);
  preserveStackTrace.Invoke(exception, null);
}

try
{
   MightThrow();
}
catch (Exception ex)
{
    DoSomethingOnFailure();
    PreserveStackTrace(ex);
    throw;
}

Answer 8

只捕获“MightThrow”不抛出的异常怎么样？

Bool bad = true;
try
{
   MightThrow();
   bad = false;
}
catch (SomePrivateMadeUpException foo)
{ 
   //empty
}
finally
{
   if(bad) DoSomeLoggingOnFailure();   
}

Answer 9

让我以我理解的方式回顾一下您的需求：

1. 您希望一些代码仅在生成异常时运行，以便进行一些日志记录。
2. 您希望在调试器下运行测试框架并在引发异常的位置中断。

为了满足您的第一个要求，您应该按照每个人建议的方式编写代码 - 使用无参数的 catch 和 throw。

为了在使用无参数 catch 时满足第二个要求，您可以将调试器配置为在引发异常时中断，而不仅仅是在存在未处理的异常时中断。 我怀疑你知道如何做到这一点，但为了答案的完整性，我将其放在这里：在 VS 中，你可以在 Debug -> 中执行此操作。 异常-> 公共语言运行时异常 -> 选中抛出复选框。

如果您知道您的应用程序会引发大量已处理的异常，那么这可能不适合您。 此时，满足第一个要求的唯一选择是编写最终用于异常日志记录的代码，或者按照 Greg Beech 的建议查看直接 IL 发出路径。

然而，finally 代码是否被执行取决于您使用的调试器。 特别是，VS 将在执行finally 之前因未处理的异常而中断，并且不会让您继续。 因此，除非您此时脱离进程，否则您的日志记录代码将永远不会被执行。 换句话说，第二个要求会干扰第一个要求的满足。

Answer 10

您可以将逻辑封装在自定义类中，例如：

    public  class Executor
{
    private readonly Action mainActionDelegate;
    private readonly Action onFaultDelegate;

    public Executor(Action mainAction, Action onFault)
    {
        mainActionDelegate = mainAction;
        onFaultDelegate = onFault;
    }

    public  void Run()
    {
        bool bad = true;
        try
        {
            mainActionDelegate();
            bad = false;
        }
        finally
        {
            if(bad)
            {
                onFaultDelegate();
            }
        }
    }

}

并将其用作：

            new Executor(MightThrow, DoSomeLoggingOnFailure).Run();

希望这会有所帮助。

Answer 11

您可以在 VB.net 中编写或让别人为您编写一个小程序集，该程序集实现接受四个委托的 TryFaultCatchFinally(of T) 方法：

1. TryMethod - 执行“Try”块的 Action(of T)。
2. FaultMethod —— 一个 Predicate(Of T, Exception)，如果发生异常，将在任何“finally”块运行之前调用； 如果它返回 true，则 Catch 块将运行，否则不会运行。
3. CatchMethod —— 如果发生异常并且FaultMethod 返回true，则执行一个Action(Of T, Exception)； 发生在“finally”块运行之后。
4. FinalMethod —— 作为“Finally”块执行的 Action(OF T、Exception、Boolean)。 如果 TryMethod 运行完成，则传入的异常将为 null，或者将保留导致其退出的异常。 如果捕获到异常，则布尔值为 true，否则为 false。

请注意，执行FaultMethod 时，我们可以在Finally 块破坏导致异常的对象状态之前检查该状态。 执行此操作时必须小心（抛出异常时持有的任何锁将继续持有），但这种能力有时仍然很方便，尤其是在调试时。

我建议例程看起来像这样：

    Shared Sub TryFaultCatchFinally(Of T)(ByVal TryProc As Action(Of T), _
                                          ByVal FaultProc As Func(Of T, Exception, Boolean), _
                                          ByVal CatchProc As Action(Of T, Exception), _
                                          ByVal FinallyProc As Action(Of T, Exception, Boolean), _
                                          ByVal Value As T)
        Dim theException As Exception = Nothing
        Dim exceptionCaught As Boolean = False
        Try
            TryProc(Value)
            theException = Nothing
            exceptionCaught = False
        Catch Ex As Exception When CopyExceptionAndReturnFalse(Ex, theException) OrElse FaultProc(Value, Ex)
            exceptionCaught = True
            CatchProc(Value, Ex)
        Finally
            FinallyProc(Value, theException, exceptionCaught)
        End Try
    End Sub

Answer 12

这不是和： 一样吗

try 
{
    MightThrow();
}
catch (Exception e) 
{
    DoSomethingOnFailure();
    throw e;
}

？

Answer 13

不，我认为这是一个常见的习语。

编辑
需要明确的是，“捕获”然后“重新抛出”策略提供相同的运行时语义，但是它们改变了附加 VS 调试器时的体验。 工具和维护很重要； 调试通常要求您“捕获所有第一次机会异常”，如果由于代码中的“catch-then-re throw”而最终导致大量“虚假”第一次机会异常，那么这确实会损害调试代码的能力。 这个惯用语是关于与工具良好交互，以及清楚地表达意图（你不想“捕获”，决定无法处理，然后重新抛出，相反，你只想记录异常确实发生了，但让它就这样过去了）。

Answer 14

您是否考虑过使用 DebuggerStepThrough 属性？
http://msdn.microsoft.com/en-us/library /system.diagnostics.debuggerstepthroughattribute.aspx

[DebuggerStepThrough]
internal void MyHelper(Action someCallback)
{
    try
    {
        someCallback();
    }
    catch(Exception ex)
    {
        // Debugger will not break here
        // because of the DebuggerStepThrough attribute
        DoSomething(ex);
        throw;
    }
}

Answer 15

在 C# 6 中添加异常过滤器后，一种选择是使用错误返回异常过滤器，如下所示：

void PerformMightThrowWithExceptionLogging()
{
    try
    {
        MightThrow();
    }
    catch (Exception e) when (Log(e))
    {
        // Cannot enter here, since Log returns false.
    }
}

bool Log(Exception e)
{
   DoSomeLoggingOnFailure(e);
   // Return false so the exception filter is not matched, and therefore the stack is kept.
   // This means the debugger breaks where the exception actually happened, etc.
   return false;
}

请参阅 https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/try-catch 了解更多详细信息异常过滤器。

Answer 16

try
{
   MightThrow();
}
catch
{
   DoSomethingOnFailure();
}

Answer 17

因此，在 .NET 中，您所要求的在理论上是可能的，但这并不容易。

CIL 实际上定义了五种类型的异常处理块！ 您在 C# 中习惯使用的 try、catch 和 finally 以及另外两个：

• filter - 类似于 catch 块，但可以运行任意代码来确定是否要处理错误，而不仅仅是匹配类型。 该块可以访问异常对象，并且对异常堆栈跟踪具有与 catch 块相同的效果。

• fault - 类似于 finally 块，但它仅在发生异常时运行。 该块无权访问异常对象，并且对异常堆栈跟踪没有影响（就像 finally 块）。

filter 在某些 .NET 语言（例如 VB.NET、C++/CLI）中可用，但遗憾的是在 C# 中不可用。 但是，除了 CIL 之外，我不知道还有什么语言可以表达 fault 块。

因为它可以在 IL 中完成，但这意味着并非一切都会丢失。 理论上，您可以使用 Reflection.Emit 动态发出一个具有 fault 块的函数，然后将您想要运行的代码作为 lambda 表达式传递（即一个用于 try 部分，一个用于故障）部分，等等），但是（a）这并不容易，并且（b）我不相信这实际上会为您提供比当前获得的更有用的堆栈跟踪。

抱歉，答案不是“如何做”类型的事情，但至少现在您知道了！ 恕我直言，您现在所做的可能是最好的方法。

---

请注意，那些说问题中使用的方法是“不好的做法”的人，实际上并非如此。 当您实现 catch 块时，您会说“当异常发生时，我需要对异常对象执行某些操作”，而当您实现 finally 时，您会说“我不需要异常对象，但我需要在函数结束之前做一些事情”。

如果你实际上想说的是“我不需要异常对象，但我需要在异常发生时做一些事情”，那么你就处于两者之间，即你想要一个 fault< /代码> 块。 由于这在 C# 中不可用，因此您没有理想的选择，因此您也可以选择不太可能因忘记重新抛出而导致错误的选项，并且不会破坏堆栈跟踪。