范围可以用“using”来阻止吗？关键字对异常有反应吗？

Question

我需要在我的代码中进行一些日志记录。我需要使用公司内部开发的库来记录一些信息。这是它的工作原理。

Recorder recorder = Recorder.StartTiming();
DoSomeWork();
recorder.Stop();  // Writes some diagnostic information.

为了确保 Stop() 始终被调用，我创建了一个包装类，它允许干净的“using”块。

using (RecorderWrapper recorderWrapper = new RecorderWrapper)  // Automatically calls Recorder.StartTiming() under the covers
{
   DoSomeWork();
}  // When the recorderWrapper goes out of scope, the 'using' statement calls recorderWrapper.Dispose() automatically - which calls recorder.Stop() under the covers

到目前为止效果很好。但是，我的公司需要进行一项更改，原始代码看起来像这样：

Recorder recorder = Recorder.StartTiming();
try
{
   DoSomeWork();
}
catch (Exception ex)
{
   recorder.ReportFailure(ex);  // Write out some exception details associated with this "transaction"
}
recorder.Stop();  // Writes some diagnostic information.

我想避免在使用 RecorderWrapper 的所有“使用”范围块中进行 try/catch。有没有办法可以容纳“ReportFailure()”调用并仍然利用“using”范围块？

具体来说，我希望团队中的每个人都能“陷入成功的深渊”，即轻松地做正确的事情。对我来说，这意味着很难忘记调用 recorder.Stop() 或忘记 try/catch。

谢谢！

Answer 1

您也许可以在记录器上创建一个方法来隐藏它：

public void Record(Action act)
{
    try
    {
        this.StartTiming();
        act();
    }
    catch(Exception ex)
    {
        this.ReportFailure(ex);
    }
    finally
    {
        this.Stop();
    }
}

所以您的示例将是：

recorder.Record(DoSomeWork);

Answer 2

您总是可以尝试类似的方法：

280Z28 编辑：我在这里使用类似于 Stopwatch.StartNew()。将您的 Recorder 类设置为 IDisposable，并从 Dispose() 调用 Stop()。我认为没有比这更清楚的了。

using (Recorder recorder = Recorder.StartNew())
{
    try
    {
        DoSomeWork();
    }
    catch (Exception ex)
    {
        recorder.ReportFailure(ex);
    }
}

Answer 3

您可以继续使用现有的 RecorderWrapper，但添加一个 TryExecuting 方法，该方法接受您想要发生的情况的 lambda，并在 try/catch 块中运行它。例如：

using (RecorderWrapper recorderWrapper = new RecorderWrapper)  // Automatically calls Recorder.StartTiming() under the covers
{
    recorderWrapper.TryExecuting(() => DoSomeWork());
}

RecorderWrapper 内部：

public void TryExecuting(Action work)
{
    try { work(); }
    catch(Exception ex) { this.ReportFailure(ex); }
}

Answer 4

您可以复制 TransactionScope 使用的模式，并编写一个必须主动完成的包装器 - 如果您不调用 Complete()，然后 Dispose() 方法（无论哪种方式都会被调用）假设一个异常并执行您的处理代码：

using(Recorder recorder = Recorder.StartTiming()) {
    DoSomeWork();
    recorder.Complete();
}

不过，就我个人而言，我会坚持使用 try/catch - 这对将来的维护者来说更清楚- 并且它提供对异常的访问。

Answer 5

不，using 块只是 try/finally 块的语法糖。它不涉及 try/catch。那时您将不得不自己处理它，因为看起来您需要例外来进行日志记录。

Answer 6

using 块实际上是一个 try/finally 块，它对相关对象调用 dispose。

所以，这：（

using(a = new A())
{
    a.Act();
}

我认为，完全）等同于：

a = new A();
try
{
    a.Act();
}
finally
{
    a.Dispose();
}

并且您可以将捕获物附加到 try 块的末尾。

编辑：

作为罗布解决方案的替代方案：

Recorder recorder = Recorder.StartNew()
try
{
    DoSomeWork();
}
catch (Exception ex)
{
    recorder.ReportFailure(ex);
}
finally
{
    recorder.Dispose();
}

Answer 7

糟糕，我没有注意到 StartTiming 正在创建一个新的 Recorder 实例。我已经更新了代码来解决这个问题。 Wrap 函数现在不再采用 Recorder 参数，而是将它创建的记录器作为参数传递给调用者传入的操作委托，以便调用者可以在需要时使用它。

嗯，我已经需要做一些与此模式非常相似的事情，lambda、Action 委托和闭包使这一切变得容易：

首先定义一个类来进行包装：

public static class RecorderScope
{
   public static void Wrap(Action<Recorder> action)
   {
      Recorder recorder = Recorder.StartTiming();
      try
      {
         action(recorder);
      }
      catch(Exception exception)
      {
         recorder.ReportFailure(exception);
      }
      finally
      {
         recorder.Stop();
      }
   }
}

现在，像这样使用：

RecorderScope.Wrap(
   (recorder) =>
   {
      // note, the recorder is passed in here so you can use it if needed -
      // if you never need it you can remove it from the Wrap function.
      DoSomeWork();
   });

但有一个问题 - 是否真的希望 catch 处理程序吞下异常而不重新抛出它？这通常是一个不好的做法。

顺便说一句，我将对此模式添加一个有用的补充。虽然，听起来它并不适用于您在这种情况下所做的事情：曾经想做类似上面的事情，您想要用一组启动操作和完成操作来包装一些代码，但您也需要能够编写一些特定的异常处理代码。好吧，如果您将 Wrap 函数更改为也采用 Action 委托并将 T 约束为 Exception，那么您就得到了一个包装器，它允许用户指定要捕获的异常类型以及要执行的代码来处理它，例如

public static class RecorderScope
{
   public static void Wrap(Action<Recorder> action, 
      Action<Recorder, T1> exHandler1)
      where T1: Exception
   {
      Recorder recorder = Recorder.StartTiming();
      try
      {
         action(recorder);
      }
      catch(T1 ex1)
      {
         exHandler1(recorder, ex1);
      }
      finally
      {
         recorder.Stop();
      }
   }
}

： use..（请注意，您必须指定异常的类型，因为它显然无法推断出来。这就是您想要的）：

RecorderScope.Wrap(
   (recorder) =>
   {
      DoSomeWork();
   },
   (recorder, MyException ex) =>
   {
      recorder.ReportFailure(exception);
   });

然后，您可以通过提供 Wrap 函数的多个重载来扩展此模式，该重载接受多个异常处理程序委托。通常五个重载就足够了 - 您需要一次捕获五种以上不同类型的异常是很不寻常的。

Answer 8

不要添加另一级间接。如果需要捕获异常，请使用 try..catch..finally 并在 finally 块中调用 Dispose()。