我如何知道使用“using”的最佳位置？

Question

我对 C# 有点陌生，更习惯脚本语言。 我喜欢“使用”的想法，你实例化一个对象，然后只要你需要它，你就可以在它的范围内进行操作，然后当它完成它的目的时，让它自行处理。

但是，这对我来说并不自然。 当人们向我展示使用它的示例时，我认为它是完成工作的好工具，但我从未想过在自己的编程中使用它解决问题。

我如何识别使用 using 的好地方以及如何将它与 try-catch 块结合使用。 它们是否进入块内部，或者您通常希望将 using 语句包含在 try 块内？

Answer 1

using 只能与实现 IDisposable 的类型一起使用； 它保证即使发生错误也会调用 Dispose() 方法。

此代码：

using (MyDisposableType x = new MyDisposableType())
{  
    // use x
}

相当于：

MyDisposableType x = new MyDisposableType();
try
{  
    // use x
}
finally 
{ 
    x.Dispose(); 
}

Answer 2

我很少编写 try/catch 块 - 大多数异常都会被抛出到（接近）堆栈顶部。 如果我确实需要一个try/catch块，我不确定将其放在using语句内部与外部是否特别一致。 这实际上取决于您是否希望在运行异常处理代码之前或之后释放资源。

如果您询问何时，您应该编写using语句 - 任何时候您“拥有”一个实现IDisposable的对象（直接或间接通过继承）并控制其生命周期。 这通常是一个使用非托管资源（如文件句柄或网络连接）的对象。 它并不总是非常明显，但你可以通过经验来学习。 几乎任何与 IO 相关的东西都是一次性的，Windows 句柄（用于字体等）也类似。

Answer 3

我过去常常将其视为“每次类型实现 IDisposable 时都使用它，并且您将不再需要此特定实例”。

Answer 4

如果您想知道如何在您自己的设计中创造性地使用它，请查看您自己的一些代码，以了解在退出封闭块之前绝对必须执行特定代码位的情况。 在这些情况下，try/finally 或 using 可以为您提供帮助。

特别是，如果您尝试通过捕获所有异常来实现此目的，那么您确实必须更改为 try/finally 或 using 。

如果该模式出现多次，您可以创建一个实现 IDisposable 的类来捕获该模式，并允许您使用 using 语句调用该模式。 但如果您遇到的特定情况似乎是一次性的，那么只需使用 try/finally 即可。

两者非常相似，实际上 - using 是根据 try/finally 指定的，但即使我们只有 using< /code>，我们可以自己构建 try/finally：

public class DisposeAnything : IDisposable
{
    public Action Disposer;

    public void Dispose()
    {
        Disposer();
    }
}

现在你可以说：

using (new DisposeAnything 
      {
          Disposer = () => File.Delete(tempFileName) 
      })
{
    // blah
}

这与以下内容相同：

try
{
    // blah
}
finally
{
    File.Delete(tempFileName);
}

只需将其视为执行某些代码的一种方法离开范围后。

Answer 5

Mitch 说的是，另外..

您可以在 try..catch 块外部或内部使用 using 语句，这实际上取决于您想要实现的目标，即您是否合理地期望在使用您所使用的特定对象时抛出异常。例如，计划从中恢复。

出于同样的原因，如果需要，您还可以在finally 块中释放一个实现IDisposable 的对象。

Answer 6

您可以将 using 包含在 try/catch 块内，也可以将 try/catch 块包含在 using 内。

using 很好的一种情况是当您使用 DBConnection 和 DBCommands 执行数据库操作时：

using (SqlConnection conn = new SqlConnection(connectionString))
using (SqlCommand command = new SqlCommand(sql, conn))
{
  // do something here
}

现在，当您离开 using 块时，您的命令将被释放并关闭连接。

Answer 7

米奇说的是对的。 因此，using 的主要用途是确保 IDisposable 对象得到处置，不必编写 try/catch 或 try/finally 语句。

现在，您可能也会对更高级的用途感兴趣。 当您使用 using 语句时，编译器会生成一个 try/finally，并且还会在它生成的 finally 内部为您生成对 Dispose() 的调用。 您可以使用此 Dispose() 方法作为“钩子”来执行您想要的任何操作...不必与释放资源相关。

例如，Jeffrey Richter 在他编写的计时器对象中使用了它。 你可以用它做这样的事情（仅概念性的）：

using(var x = new Timer())
{
  // Do the operation you want timed
}

// Now, the timer has been stopped, because the 
// compiler-generated call to Dispose() has already 
// occurred, and Jeffrey uses Dispose() to stop 
// the timer.

Answer 8

如果一个类实现了 IDisposable，这可能是有充分理由的。 因此，任何实现 IDisposable 的类都应该被释放。

Answer 9

鉴于它就是所谓的“语法糖”，并且将生成与 try/finally dispose 构造相同的 IL，它实际上只是“简化”此类代码的一种好方法。

我喜欢用它来简化大量使用一次性对象的代码部分，即访问文件和图形对象等资源，并且我想确保我不会忘记处理资源对象的处置。

Answer 10

当您需要确定性对象处置时，请使用using。 例如，如果您打开一个文件，该文件将被锁定。 您通常会希望尽快关闭该文件，以便其他程序可以访问它。 如果你不使用 using 并写成这样：

System.IO.FileStream writeStream = new System.IO.FileStream( fileName, System.IO.FileMode.OpenOrCreate ) );
System.IO.BinaryWriter writer = new System.IO.BinaryWriter( writeStream ) );
//do smth 

并且在“do smth”期间发生异常，你不知道对文件操作的对象何时实际被释放并且文件被关闭。 使用using，您可以确定一旦离开using语句块 - 无论是直接还是通过异常，usinging语句中的对象都是通过调用 IDisposable::Dispose 进行处置：

using( System.IO.FileStream writeStream = new System.IO.FileStream( fileName, System.IO.FileMode.OpenOrCreate ) ) {
    using( System.IO.BinaryWriter writer = new System.IO.BinaryWriter( writeStream ) ) {
        //do stmth
    }
}

Answer 11

我注意到，当已知 Dispose 方法确实会引起注意时，程序员就不会费心调用它，因为它似乎毫无意义。 但是，如果该对象实现了 IDisposable （希望）是有原因的，并且该对象的未来版本实际上可能在 Dispose 方法中包含代码 - 因此请始终调用它。