摆脱嵌套的 using(...) 语句

Question

有时我需要在一个函数中使用多个一次性对象。最常见的情况是拥有 StreamReader 和 StreamWriter，但有时甚至不止于此。

嵌套的 using 语句很快就会堆积起来并且看起来很难看。 为了解决这个问题，我创建了一个小类，它收集 IDisposable 对象并在其本身被释放时释放它们。

public class MultiDispose : HashSet<IDisposable>, IDisposable
{
    public MultiDispose(params IDisposable[] objectsToDispose)
    {
        foreach (IDisposable d in objectsToDispose)
        {
            this.Add(d);
        }
    }

    public T Add<T>(T obj) where T : IDisposable
    {
        base.Add(obj);
        return obj;
    }

    public void DisposeObject(IDisposable obj)
    {
        obj.Dispose();
        base.Remove(obj);
    }


    #region IDisposable Members

    public void Dispose()
    {
        foreach (IDisposable d in this)
        {
            d.Dispose();
        }

    }

    #endregion
}

所以我的代码现在看起来像这样：

        using (MultiDispose md = new MultiDispose())
        {
            StreamReader rdr = md.Add(new StreamReader(args[0]));
            StreamWriter wrt = md.Add(new StreamWriter(args[1]));
            WhateverElseNeedsDisposing w = md.Add(new WhateverElseNeedsDisposing());

            // code
        }

这种方法有什么问题可能会导致问题吗？ 我特意保留了从 HashSet 继承的 Remove 函数，以便该类更加灵活。 当然，滥用这个函数可能会导致对象没有被正确处理，但是如果没有这个类，还有很多其他的方法会搬起石头砸自己的脚。

Answer 1

你可以这样做：

using (var a = new A())
using (var b = new B())
{
    /// ...
}

Answer 2

关于一般原则的几点：

• 您的代码明显不符合惯用的 C# 风格。基本上，您要求使用您的代码的其他人采用一种不寻常的风格，但几乎没有什么好处。
• 正如其他人指出的那样，您可以嵌套 using 语句而无需额外的大括号
• 如果您发现自己在单个方法中有很多 using 语句，您可能需要考虑将其分解为较小的方法

• 如果有两个相同类型的变量，则可以使用单个 using 语句：

  using (Stream input = File.OpenRead("input.dat"),
         输出 = File.OpenWrite("output.dat"))
  {
  }
  

现在假设您确实想继续执行此操作：

• 您的代码将以难以处理的方式处置其包含的资源。 - 预测顺序。它应该嵌入一个列表，而不是使用集合 - 然后以与 Add 调用相反的顺序处理内容。
• 没有理由从 HashSet 或任何集合派生。您应该在类中拥有一个列表作为私有成员变量。
• 如果其中一个 Dispose 调用失败，则不会进行任何其他 Dispose 调用；使用传统的 using 语句，每次对 Dispose 的调用都是在其自己的 finally 块中进行的。

基本上，我认为这是一个坏主意。嵌套两层深一点也不痛苦；嵌套三个应该很少见；嵌套四个或更多强烈建议重构。您应该在设计时远离它，而不是试图应对深度嵌套的痛苦。

Answer 3

也许您只是展示了一个简单的示例，但我认为以下内容更具可读性。

 using (StreamReader rdr = new StreamReader(args[0])) 
 using (StreamWriter wrt = new StreamWriter(args[1])) 
 {     
   // code 
 }

Answer 4

您可以仅使用一对大括号来使嵌套的 using 语句更漂亮，如下所示：

using (StreamReader rdr = new StreamReader(args[0])) 
using (StreamWriter wrt = new StreamWriter(args[1])) 
{
    ///...
}

---

要回答您的问题，您需要以相反的加法顺序进行处理。
因此，您不能使用HashSet。

此外，没有理由向外界公开 IDisposable 列表。
因此，您不应继承任何集合类，而应维护一个私有 List。

然后，您应该具有公共 Add 和 Dispose 方法（并且没有其他方法），并在 Dispose 中向后循环列表。

Answer 5

就我个人而言，这会让我发疯。如果您发现嵌套的 using 语句很烦人，您可以恢复到 try/finally 语法。 Dispose 方法不应抛出异常，因此您可以假设多个一次性对象不需要单独包装在 try/finally 块中。

另外值得注意的是，您只需要一组括号来表示相邻的 using 块，例如：

using (var stream = File.Open(...))
using (var reader = new StreamReader(stream)) {

   // do stuff

}

Answer 6

我不得不说，我不同意那些想要一个接一个地使用语句的人，例如：

using (var a = new StreamReader())
using (var b = new StreamWriter())
{
 // Implementation
}

在我看来，这是非常不可读的 - 任何未包装的代码块都是糟糕的风格，并且可能会导致问题，除非所有从事此工作的开发人员都非常小​​心。

我会将其与以下内容相提并论：

if (someBoolean) DoSomething();
{
  // Some code block unrelated to the if statement
}

从技术上讲，它并不是无效的，但看起来很糟糕。

我同意 MultiDispose 概念可能不是最好的想法，因为它不是一种可接受的模式，但我也绝对不会走这条路。如果您无法将事物分解成更小的块，那么我建议您只使用嵌套的用法。