使用 IDisposable 检查约束——疯狂还是天才？

Question

我在今天正在处理的代码库中遇到了一个模式，最初看起来非常聪明，后来让我发疯，现在我想知道是否有一种方法可以挽救聪明的部分，同时最大限度地减少疯狂。

我们有一堆实现 IContractObject 的对象，以及一个如下所示的 InvariantChecker 类：

internal class InvariantChecker : IDisposable
{
    private IContractObject obj;

    public InvariantChecker(IContractObject obj)
    {
        this.obj = obj;
    }

    public void Dispose()
    {
        if (!obj.CheckInvariants())
        {
            throw new ContractViolatedException();
        }
    }
}

internal class Foo : IContractObject
{
    private int DoWork()
    {
        using (new InvariantChecker(this))
        {
            // do some stuff
        }
        // when the Dispose() method is called here, we'll throw if the work we
        // did invalidated our state somehow
    }
}

它用于提供相对轻松的状态一致性运行时验证。这不是我写的，但最初看起来这是一个很酷的主意。

但是，如果 Foo.DoWork 抛出异常，就会出现问题。当抛出异常时，我们很可能处于不一致的状态，这意味着 InvariantChecker 也会抛出，隐藏原始异常。当异常在调用堆栈中向上传播时，这种情况可能会发生多次，每个帧上都有一个 InvariantChecker 来隐藏下面帧中的异常。为了诊断问题，我必须禁用 InvariantChecker 中的 throw，然后才能看到原始异常。

这显然是可怕的。然而，有没有什么方法可以挽救最初想法的巧妙之处，而又不会出现可怕的异常隐藏行为？

Answer 1

我不喜欢以这种方式重载 using 的含义。为什么不使用采用委托类型的静态方法呢？所以你可以这样写：

InvariantChecker.Check(this, () =>
{
    // do some stuff
});

或者甚至更好，只需将其设为扩展方法即可：（

this.CheckInvariantActions(() =>
{
    // do some stuff
});

请注意，需要“this”部分才能让 C# 编译器查找适用于 this.) 这还允许您使用“正常”方法来实现操作（如果需要），并使用方法组转换为其创建委托。如果您有时想从正文返回，您可能还希望允许它返回一个值。

现在 CheckInvariantActions 可以使用类似的东西：

action();
if (!target.CheckInvariants())
{
    throw new ContractViolatedException();
}

我还建议 CheckInvariants 应该直接抛出异常，而不是仅仅返回 bool - 这样异常可以提供有关 哪个不变量被违反了。

Answer 2

这是对使用模式的可怕滥用。使用模式是为了处理非托管资源，而不是为了像这样的“聪明”技巧。我建议直接编写代码。

Answer 3

如果您真的想要这样做：

internal class InvariantChecker : IDisposable
{
    private IContractObject obj;

    public InvariantChecker(IContractObject obj)
    {
        this.obj = obj;
    }

    public void Dispose()
    {
        if (Marshal.GetExceptionCode() != 0xCCCCCCCC && obj.CheckInvariants())
        {
            throw new ContractViolatedException();
        }
    }
}

Answer 4

而不是这样：

using (new InvariantChecker(this)) {
  // do some stuff
}

只需执行此操作（假设您没有从 do some stuff 返回）：

// do some stuff
this.EnforceInvariants();

如果您需要从 do some stuff 返回，我相信一些重构是有序的：

DoSomeStuff(); // returns void
this.EnforceInvariants();

...

var result = DoSomeStuff(); // returns non-void
this.EnforceInvariants();
return result;

它更简单，你不会遇到问题你之前有过。

你只需要一个简单的扩展方法：

public static class InvariantEnforcer {
  public static void EnforceInvariants(this IContractObject obj) {
    if (!obj.CheckInvariants()) {
      throw new ContractViolatedException();
    }
  }
}

Answer 5

向 InvariantChecker 类添加一个属性，允许您禁止检查/抛出。

internal class InvariantChecker : IDisposable
{
    private IContractObject obj;

    public InvariantChecker(IContractObject obj)
    {
        this.obj = obj;
    }

    public bool Suppress { get; set; }

    public void Dispose()
    {
        if (!this.Suppress)
        {
            if (!obj.CheckInvariants())
            {
                throw new ContractViolatedException();
            }
        }
    }
}

internal class Foo : IContractObject
{
    private int DoWork()
    {
        using (var checker = new InvariantChecker(this))
        {
            try
            {
                // do some stuff
            }
            catch
            {
                checker.Suppress = true;
                throw;
            }
        }
    }
}

Answer 6

如果您当前的问题是获取原始异常 - 转到调试 ->异常并检查所有 CLR 异常的“抛出”情况。当抛出异常时它会中断，因此你会首先看到它。如果从 VS 的角度来看“不是您的代码”抛出异常，您可能还需要关闭工具->选项->调试->“仅我的代码”选项。

Answer 7

要做到这一点，需要一种干净的方法来确定调用 Dispose 时是否有异常处于待处理状态。要么微软应该提供一种标准化的方法来随时查明当前 try-finally 块退出时将出现哪些异常（如果有），要么微软应该支持扩展的 Dispose 接口（可能是 DisposeEx，它将继承 Dispose）接受待处理异常参数。