使用块嘉豪？

Question

我想你对以下主题的意见：

假设我们有一个负责实现一个特定目的的方法，但要做到这一点，它需要一个重要的数字支持的本地范围对象，许多其中实施IDisposable。

MS编码标准说当使用本地IDisposable对象时，不需要“存活”该方法的范围（不会被返回或不会被分配给某些长期存在的object的状态信息），您应该使用using构造。

的问题是，在某些情况下，你可以得到的using块嵌套“地狱”：

using (var disposableA = new DisposableObjectA()) 
{ 
    using (var disposableB = new DisposableObjectB()) 
    { 
      using (var disposableC = new DisposableObjectC()) 
      { 
       //And so on, you get the idea. 
      } 
    } 
} 

你能以某种方式减轻这一点，如果一些正在使用的对象，从一个共同的基础得到或实施实施IDisposable的共同interface。当然，这需要花费一定的代价，只要你需要真正的对象类型就可以投射这些对象。有时候，这可能是可行的，只要铸造量不失控：

using (var disposableA = new DisposableObjectA()) 
{ 
    using (DisposableBaseObject disposableB = new DisposableObjectB(), 
      disposableC = new DisposableObjectC) 
    { 
      using (var disposableD = new DisposableObjectD()) 
      { 
       //And so on, you get the idea. 
      } 
    } 
} 

另一种选择是不使用using块，直接实现try-catch块。这看起来像：

DisposableObjectA disposableA = null; 
DisposableObjectB disposableB = null; 
DisposableObjectC disposableC = null; 
... 

try 
{ 
    disposableA = new DisposableObjectA(); 
    .... 
} 
finally 
{ 
    if (disposableA != null) 
    { 
      disposableA.Dispose(); 
    } 

    if (disposableB != null) 
    { 
      disposableB.Dispose(); 
    } 

    //and so on 
} 

有趣的是，VS Code Analyzer会将此代码标记为“错误”。它会通知您，并非所有可能的执行路径都确保所有可丢弃对象在超出范围之前将被丢弃。我只能看到发生这种情况时，如果某些物体在丢弃时抛出，而在我看来永远不会发生的情况下发生，如果它发生了，它通常表示某种事情真的搞糟了，而且您可能比您更快，更优雅地退出可以从你的整个应用程序。

所以，问题是：你更喜欢什么样的方法？不管有多少块，或者超过一定的限制，最好是使用嵌套的using块，最好是使用try-catch块？

Answer 1

你不需要花括号，如果有只有一个语句，例如：

using (var disposableA = new DisposableObjectA()) 
using (var disposableB = new DisposableObjectB()) 
using (var disposableC = new DisposableObjectC()) 
{ 
       //And so on, you get the idea. 
} 

这不取决于闲来无事外块发生，虽然。

Answer 2

我想你忘记了using声明（许多人一样），并不一定需要一个代码块，但也可以是单个语句。

using (var disposableA = new DisposableObjectA()) 
using (var disposableB = new DisposableObjectB()) 
using (var disposableC = new DisposableObjectC()) 
{ 
    //And so on, you get the idea. 
} 

我认为这极大地简化了问题：作为你的第一个例子可以写。请注意，如果您需要在调用实现IDisposable的实例之间执行某些操作，则不会有帮助。

我甚至走那么远，有意义窝其它块。 foreach就是一个例子。

IEnumerable<int> ints = ...; 

using (var disposableA = new DisposableObjectA()) 
using (var disposableB = new DisposableObjectB()) 
using (var disposableC = new DisposableObjectC()) 
foreach (int i in ints) 
{ 
    // Work with disposableA, disposableB, disposableC, and i. 
} 

应当指出的是，VS代码分析是正确的，当它告诉你，这是不正确的：

DisposableObjectA disposableA = null; 
DisposableObjectB disposableB = null; 
DisposableObjectC disposableC = null; 
... 

try 
{ 
    disposableA = new DisposableObjectA(); 
    .... 
} 
finally 
{ 
    if (disposableA != null) 
    { 
      disposableA.Dispose(); 
    } 

    if (disposableB != null) 
    { 
      disposableB.Dispose(); 
    } 

    //and so on 
} 

当您使用using堆放在彼此的顶部，它的巢他们在多个try/finally块，像这样：

DisposableObjectA disposableA = null; 
DisposableObjectB disposableB = null; 
DisposableObjectC disposableC = null; 
... 

try 
{ 
    disposableA = new DisposableObjectA(); 

    try 
    { 
     disposableB = new DisposableObjectB(); 

     // Try/catch block with disposableC goes here. 
    } 
    finally 
    { 
     if (disposableB != null) 
     { 
       disposableB.Dispose(); 
     }  
    } 
} 
finally 
{ 
    if (disposableA != null) 
    { 
      disposableA.Dispose(); 
    }  
} 

在你的榜样，如果有异常被抛出时disposableA.Dispose被执行，然后disposableB和disposableC没有得到安置（该finally退出块），如果在disposableB被调用时抛出一个错误，那么disposableC没有关闭，等

Answer 3

唯一真正的“问题”与你第一个代码示例是深层嵌套，这可以使阅读和维护代码变得困难。作为其他答案的替代方案，建议您只需放下花括号，还可以通过将最深嵌套的代码重构为单独的函数来解决此问题。这将创建和处理一次性物品的顾虑与实际使用它们的问题区分开来。

using (var a = new DisposableObjectA()) 
{ 
    using (var b = new DisposableObjectB()) 
    { 
     using (var c = new DisposableObjectC()) 
     { 
       SomeFunction(a,b,c); 
     } 
    } 
}