C#：IDisposable 类需要“使用”条款？

Question

如果我使用 IDisposable 类，我是否应该始终使用 using 子句，例如：

using (MyClass myclass = new MyClass())
{
...
}

Answer 1

using 语句确保即使发生异常或对象超出范围，也会调用 Dispose 来释放资源。

这比使用以下代码块更简单，

try
{
   ...
}
catch()
{
   // Handle exception
}
finally
{
    // Free resources by calling Dispose()
}

注意
如果不想处理异常，则不需要catch 块。在这种情况下，一个 try...finally 块就足够了（正如其他答案中指出的那样）。

替代方式
您可以在同一个 using 语句中创建一次性对象的多个实例，例如

using(MyClass myclass1 = new MyClass(), 
      MyClass myclass2 = new MyClass())
{
    ...
}

示例
从 理解 C# 中的 'using' 语句

using (MyResource myRes = new MyResource())
{
    myRes.DoSomething();
}

被翻译为（由 CLR）

MyResource myRes= new MyResource();
try
{
    myRes.DoSomething();
}
finally
{
    // Check for a null resource.
    if (myRes!= null)
    {
        // Call the object's Dispose method.
        ((IDisposable)myRes).Dispose();
    }
}

您可以查看在示例开头指定的链接中生成了 MSIL。

更多信息

• using 语句（C# 参考）
• C# 中 using 语句的绝佳用途
• 实现 Dispose 方法
• 实施 Finalize 和 Dispose 来清理非托管资源
• 相关：使用指令（C# 参考）

Answer 2

它使其代码更具可读性。因此，通常您应该在 using 块中声明并实例化该对象。它确保即使发生异常也会调用 Dispose 方法。在编译时，相同的表达式将类似于这样：

{
  MyClass myclass = new MyClass ();
  try {
    //Do something with myclass
  }
  finally {
    if (myclass != null)
      ((IDisposable)myclass).Dispose();
  }
}

Answer 3

如果一个类实现了IDisposable，那么当您处理完该对象后，您应该始终调用Dispose。 C# 提供了 using 语句作为语法糖，以简化此操作。因此，不需要使用 using 来调用 Dispose。也就是说，它是调用 Dispose 的事实上的标准方法。即，如果您的代码没有使用 using 而是在finally 块中调用Dispose，那么对于经验丰富的编码人员来说，它看起来会有点奇怪。

using 块的扩展（假设 MyClass 是引用类型）是：

{
    MyClass myclass = new MyClass();
    try {
        //...
    }
    finally {
        if (myclass != null) ((IDisposable)myclass).Dispose();
    }
}

using 版本更易于编码且更易于阅读。

Answer 4

简单地说，如果它实现了 IDisposable，并且您希望调用该方法（也在您执行操作时的 finally 块中出现异常时）。请使用 using。GC

不会为您调用 Dispose()！有些类实现了终结器 ~ClassName () 但尽量避免这种情况，因为它有很多副作用并且不明显，

您可以将 using 语句读为：

TestClass test = new TestClass();
try
{
      test.DoSomething();
}
finally
{
      test.Dispose();
}

Answer 5

只要对象的生命周期足够短，您就应该始终这样做。有时，您必须单独处理清理工作，因为您的对象具有较长的生命周期，这些对象在代码块完成后仍将持续很长时间。

Answer 6

创建 IDisposable 对象时存在三种情况：

1. 该对象将在一段时间内被需要，但在当前代码块退出后将不再需要。
2. 该对象将被提供给当前例程的调用者，然后由当前例程的调用者负责。
3. 负责 IDisposable 对象的类将其存储在一个字段中，以便在将来的方法/属性调用中使用。

在场景#1中，使用“using”块来创建对象；其清理工作将自动进行。

在场景 #2 中，使用带有“ok”变量的“try-finally”块，该变量最初设置为“False”，但在“try”结束时或在任何返回之前设置为“True”；最后，如果“oK”为 false，则调用 Dispose 以确保部分构造的对象得到清理。

在场景 #3 中，对象创建后立即将其存储在字段中，并定义一个 IDisposable.Dispose 方法，该方法会将字段中的值复制到变量中，将字段清空，如果变量非空，处理它（如果有可能多个线程同时调用 Dispose，请使用 Interlocked.Exchange 来锁定并清除该字段）。构造函数也应该像场景 #2 中的函数一样受到保护。

Answer 7

using 子句是以下代码块的语法糖：

MyClass myclass = null;
try
{
     myclass = new MyClass();
     //do work
}
finally
{
     if(myclass != null)
          myclass.Dispose();
}

如果类实现了 IDisposable，则应确保在使用完它后调用 Dispose。 using 子句只是一种简单的方法。所以你不必使用“using”来做到这一点，但你应该确保它被调用。