C#中Finalize/Dispose方法的使用

Question

C# 2008

我已经在这方面工作了一段时间了，但我仍然对代码中 Finalize 和 dispose 方法的使用感到困惑。 我的问题如下：

1. 我知道我们在处理非托管资源时只需要一个终结器。 但是，如果有托管资源调用非托管资源，是否还需要实现终结器？

2. 但是，如果我开发一个不直接或间接使用任何非托管资源的类，我是否应该实现 IDisposable 以允许该类的客户端使用“using 语句”？

   实现 IDisposable 只是为了让您的类的客户端能够使用 using 语句是否可行？

   using(myClass objClass = new myClass()) 
     { 
         // 在这里做一些事情 
     } 
     

3. 我开发了下面这个简单的代码来演示 Finalize/dispose 的使用：

   公共类NoGateway：IDisposable 
     { 
         私有WebClient wc = null; 
   
         公共NoGateway() 
         { 
             wc = new WebClient(); 
             wc.DownloadStringCompleted += wc_DownloadStringCompleted; 
         } 
   
   
         // 启动异步调用以查找 NoGateway 是 true 还是 false 
         公共无效NoGatewayStatus（） 
         { 
             // 开始异步下载 
                 // 在这里做其他工作 
             wc.DownloadStringAsync(new Uri(www.xxxx.xxx)); 
         } 
   
         私有无效 wc_DownloadStringCompleted（对象发送者，Dow​​nloadStringCompletedEventArgs e） 
         { 
             // 在这里工作 
         } 
   
         // 释放 NoGateway 对象 
         公共无效处置（） 
         { 
             wc.DownloadStringCompleted -= wc_DownloadStringCompleted; 
             wc.Dispose(); 
             GC.SuppressFinalize(this); 
         } 
     } 
     

关于源代码的问题：

1. 这里我没有添加终结器，通常终结器会被GC调用，终结器将调用 Dispose。 由于我没有终结器，我什么时候调用 Dispose 方法？ 是不是该类的客户端必须调用它？

   所以我在示例中的类称为 NoGateway，客户端可以像这样使用和处置该类：

   using(NoGateway objNoGateway = new NoGateway()) 
     { 
         // 在这里做一些事情    
     } 
     

   当执行到using块末尾时，Dispose方法会自动调用吗？还是客户端必须手动调用dispose方法？ 即

   NoGateway objNoGateway = new NoGateway(); 
     // 对对象做一些事情 
     objNoGateway.Dispose();   // 完成了 
     

2. 我在我的NoGateway 类中使用WebClient 类。 因为 WebClient 实现了 IDisposable 接口，这是否意味着 WebClient 间接使用非托管资源？ 有没有硬性规定可以遵循？ 我如何知道某个类使用非托管资源？

Answer 1

据我所知，强烈建议不要使用终结器/析构函数：

public ~MyClass() {
  //dont use this
}

大多数情况下，这是因为不知道何时或是否会调用它。 处理方法要好得多，特别是如果您直接使用或处理的话。

使用效果很好。 用它 ：）

Answer 2

推荐的 IDisposable 模式位于此处。 在编写使用 IDisposable 的类时，通常应该使用两种模式：

当实现不使用非托管资源的密封类时，只需像普通接口实现一样实现 Dispose 方法：

public sealed class A : IDisposable
{
    public void Dispose()
    {
        // get rid of managed resources, call Dispose on member variables...
    }
}

当实现非密封类时，请像这样执行：

public class B : IDisposable
{    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // get rid of managed resources
        }   
        // get rid of unmanaged resources
    }

    // only if you use unmanaged resources directly in B
    //~B()
    //{
    //    Dispose(false);
    //}
}

请注意，我没有在 B 中声明终结器； 仅当您有实际的非托管资源需要处置时，您才应该实现终结器。 即使调用了 SuppressFinalize，CLR 处理可终结对象的方式也与处理不可终结对象的方式不同。

因此，除非必要，否则不应声明终结器，但如果类的继承者直接使用非托管资源，则可以为类的继承者提供一个钩子来调用 Dispose 并自行实现终结器：

public class C : B
{
    private IntPtr m_Handle;

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            // get rid of managed resources
        }
        ReleaseHandle(m_Handle);

        base.Dispose(disposing);
    }

    ~C() {
        Dispose(false);
    }
}

如果您是不直接使用非托管资源（SafeHandle 和朋友不算数，因为他们声明了自己的终结器），那么不要实现终结器，因为 GC 以不同的方式处理可终结的类，即使您稍后抑制终结器。 另请注意，即使 B 没有终结器，它仍然调用 SuppressFinalize 来正确处理任何实现终结器的子类。

当一个类实现 IDisposable 接口时，这意味着某个地方有一些非托管资源，当您使用完该类时应该将其删除。 实际资源封装在类中； 您不需要显式删除它们。 只需调用 Dispose() 或将类包装在 using(...) {} 中即可确保根据需要删除任何非托管资源。

Answer 3

实现 IDisposable 的官方模式很难理解。 我相信这个更好：

public class BetterDisposableClass : IDisposable {

  public void Dispose() {
    CleanUpManagedResources();
    CleanUpNativeResources();
    GC.SuppressFinalize(this);
  }

  protected virtual void CleanUpManagedResources() { 
    // ...
  }
  protected virtual void CleanUpNativeResources() {
    // ...
  }

  ~BetterDisposableClass() {
    CleanUpNativeResources();
  }

}

一个更好的解决方案是制定一条规则，您始终必须遵守为需要处理的任何非托管资源创建一个包装类：

public class NativeDisposable : IDisposable {

  public void Dispose() {
    CleanUpNativeResource();
    GC.SuppressFinalize(this);
  }

  protected virtual void CleanUpNativeResource() {
    // ...
  }

  ~NativeDisposable() {
    CleanUpNativeResource();
  }

}

使用 SafeHandle 及其派生类，这些类应该非常罕见。

即使存在继承，不直接处理非托管资源的一次性类的结果也是强大的：它们不再需要关心非托管资源。 它们的实施和理解简单：

public class ManagedDisposable : IDisposable {

  public virtual void Dispose() {
    // dispose of managed resources
  }

}

Answer 4

请注意，任何 IDisposable 实现都应遵循以下模式（恕我直言）。 我根据几位优秀的 .NET“大神”的信息开发了这个模式 .NET Framework 设计指南 （请注意，由于某种原因，MSDN 不遵循这一点！）。 .NET Framework 设计指南由 Krzysztof Cwalina（当时的 CLR 架构师）、Brad Abrams（我相信当时的 CLR 项目经理）和 Bill Wagner（[Effective C#] 和 [More effective C#]（只需看一下）编写。在 Amazon.com 上查找这些：

请注意，除非您的类直接包含（而不是继承）非托管资源，否则您永远不应该实现 Finalizer。 一旦您在类中实现了 Finalizer，即使它从未被调用，它也保证会存在。它会自动放置在终结队列中（在单个线程上运行）。此外，一个非常重要的注意事项...在终结器中执行的所有代码（如果您需要实现）必须是线程安全的并且异常安全！否则会发生不好的事情......（即，未确定的行为，在发生异常的情况下，致命的不可恢复的应用程序崩溃）

：

#region IDisposable implementation

//TODO remember to make this class inherit from IDisposable -> $className$ : IDisposable

// Default initialization for a bool is 'false'
private bool IsDisposed { get; set; }

/// <summary>
/// Implementation of Dispose according to .NET Framework Design Guidelines.
/// </summary>
/// <remarks>Do not make this method virtual.
/// A derived class should not be able to override this method.
/// </remarks>
public void Dispose()
{
    Dispose( true );

    // This object will be cleaned up by the Dispose method.
    // Therefore, you should call GC.SupressFinalize to
    // take this object off the finalization queue 
    // and prevent finalization code for this object
    // from executing a second time.

    // Always use SuppressFinalize() in case a subclass
    // of this type implements a finalizer.
    GC.SuppressFinalize( this );
}

/// <summary>
/// Overloaded Implementation of Dispose.
/// </summary>
/// <param name="isDisposing"></param>
/// <remarks>
/// <para><list type="bulleted">Dispose(bool isDisposing) executes in two distinct scenarios.
/// <item>If <paramref name="isDisposing"/> equals true, the method has been called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.</item>
/// <item>If <paramref name="isDisposing"/> equals false, the method has been called by the 
/// runtime from inside the finalizer and you should not reference 
/// other objects. Only unmanaged resources can be disposed.</item></list></para>
/// </remarks>
protected virtual void Dispose( bool isDisposing )
{
    // TODO If you need thread safety, use a lock around these 
    // operations, as well as in your methods that use the resource.
    try
    {
        if( !this.IsDisposed )
        {
            if( isDisposing )
            {
                // TODO Release all managed resources here

                $end$
            }

            // TODO Release all unmanaged resources here



            // TODO explicitly set root references to null to expressly tell the GarbageCollector
            // that the resources have been disposed of and its ok to release the memory allocated for them.


        }
    }
    finally
    {
        // explicitly call the base class Dispose implementation
        base.Dispose( isDisposing );

        this.IsDisposed = true;
    }
}

//TODO Uncomment this code if this class will contain members which are UNmanaged
// 
///// <summary>Finalizer for $className
lt;/summary>
///// <remarks>This finalizer will run only if the Dispose method does not get called.
///// It gives your base class the opportunity to finalize.
///// DO NOT provide finalizers in types derived from this class.
///// All code executed within a Finalizer MUST be thread-safe!</remarks>
//  ~$className$()
//  {
//     Dispose( false );
//  }
#endregion IDisposable implementation

如下 在派生类中实现 IDisposable 的代码。 请注意，您不需要在派生类的定义中显式列出对 IDisposable 的继承。

public DerivedClass : BaseClass, IDisposable (remove the IDisposable because it is inherited from BaseClass)


protected override void Dispose( bool isDisposing )
{
    try
    {
        if ( !this.IsDisposed )
        {
            if ( isDisposing )
            {
                // Release all managed resources here

            }
        }
    }
    finally
    {
        // explicitly call the base class Dispose implementation
        base.Dispose( isDisposing );
    }
}

我已将此实现发布在我的博客上： 如何正确实现 Dispose 模式

Answer 5

我同意 pm100 （并且应该在我之前的帖子中明确指出这一点）。

除非需要，否则永远不应该在类中实现 IDisposable。 具体来说，大约有 5 次您需要/应该实现 IDisposable：

1. 您的类显式包含（即不是通过继承）任何实现 IDisposable 的托管资源，并且一旦您的类不再存在就应该清除用过的。 例如，如果您的类包含 Stream、DbCommand、DataTable 等的实例。

2. 您的类显式包含实现 Close() 方法的任何托管资源 - 例如 IDataReader、IDbConnection 等。请注意，其中一些类请通过使用 Dispose() 以及 Close() 方法来实现 IDisposable。

3. 您的类显式包含非托管资源 - 例如 COM 对象、指针（是的，您可以在托管 C# 中使用指针，但它们必须在“不安全”块中声明，等等。
   对于非托管资源，还应确保在 RCW 上调用 System.Runtime.InteropServices.Marshal.ReleaseComObject()。 即使 RCW 理论上是一个托管包装器，但幕后仍然存在引用计数。

4. 如果您的类使用强引用订阅事件。 您需要取消注册/脱离活动。 在尝试取消注册/分离它们之前，始终要确保它们不为空！。

5. 您的类包含上述内容的任意组合...

处理 COM 对象并必须使用 Marshal.ReleaseComObject() 的推荐替代方法是使用System.Runtime.InteropServices.SafeHandle 类。

BCL（基类库团队）在这里有一篇关于它的很好的博客文章 http://blogs.msdn.com/bclteam/archive/2005/03/16/396900.aspx

需要注意的一个非常重要的事项是，如果您正在使用 WCF 并清理资源，您几乎应该始终避免“使用”块。 有很多博客文章以及 MSDN 上的一些文章都说明了为什么这是一个坏主意。 我也在这里发布了相关内容 - 不要将“using()”与 WCF 代理一起使用

Answer 6

使用 lambda 代替 IDisposable。

我从来没有对整个使用/IDisposable 的想法感到兴奋。 问题是它要求调用者：

• 知道他们必须使用 IDisposable
• 记住使用“using”。

我的新首选方法是使用工厂方法和 lambda 代替

想象一下我想用 SqlConnection 做一些事情（应该将其包装在 using 中）。 传统上，您会采用

using (Var conn = Factory.MakeConnection())
{
     conn.Query(....);
}

New way

Factory.DoWithConnection((conn)=>
{
    conn.Query(...);
}

在第一种情况下，调用者可以简单地不使用 using 语法。 在第二种情况下，用户别无选择。 没有创建 SqlConnection 对象的方法，调用者必须调用 DoWithConnection。

DoWithConnection 看起来这个

void DoWithConnection(Action<SqlConnection> action)
{
   using (var conn = MakeConnection())
   {
       action(conn);
   }
}

MakeConnection 现在是私有的

Answer 7

没有人回答关于您是否应该实现 IDisposable 的问题，即使您不需要它。

简短的回答：没有

长的回答：

这将允许您的班级的消费者使用“使用”。 我要问的问题是——他们为什么要这么做？ 大多数开发人员不会使用“使用”，除非他们知道必须使用“使用”——以及他们如何知道。 要么

• 从经验中显而易见（例如套接字类），要么
• 记录在案，
• 他们很谨慎，并且可以看到该类实现了 IDisposable

因此，通过实现 IDisposable，您告诉开发人员（至少是一些开发人员）该类包装了必须发布的东西。 他们会使用“using”——但在其他情况下，using 是不可能的（对象的范围不是本地的）； 在其他情况下，他们将不得不开始担心对象的生命周期 - 我肯定会担心。 但这不是必需的。

您实现了 Idisposable 来使他们能够使用 using，但除非您告诉他们，否则他们不会使用 using。

所以不要这样做

Answer 8

处置模式：

public abstract class DisposableObject : IDisposable
{
    public bool Disposed { get; private set;}      

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~DisposableObject()
    {
        Dispose(false);
    }

    private void Dispose(bool disposing)
    {
        if (!Disposed)
        {
            if (disposing)
            {
                DisposeManagedResources();
            }

            DisposeUnmanagedResources();
            Disposed = true;
        }
    }

    protected virtual void DisposeManagedResources() { }
    protected virtual void DisposeUnmanagedResources() { }
}

继承示例：

public class A : DisposableObject
{
    public Component components_a { get; set; }
    private IntPtr handle_a;

    protected override void DisposeManagedResources()
    {
        try
        {
          Console.WriteLine("A_DisposeManagedResources");
          components_a.Dispose();
          components_a = null;
        }
        finally
        { 
          base.DisposeManagedResources();
        }
    }

    protected override void DisposeUnmanagedResources()
    {
        try
        {
          Console.WriteLine("A_DisposeUnmanagedResources");
          CloseHandle(handle_a);
          handle_a = IntPtr.Zero;
        }
        finally
        { 
          base.DisposeUnmanagedResources();
        }
    }
}

public class B : A
{
    public Component components_b { get; set; }
    private IntPtr handle_b;

    protected override void DisposeManagedResources()
    {
        try
        {
          Console.WriteLine("B_DisposeManagedResources");
          components_b.Dispose();
          components_b = null;
        }
        finally
        { 
          base.DisposeManagedResources();
        }
    }

    protected override void DisposeUnmanagedResources()
    {
        try
        {
          Console.WriteLine("B_DisposeUnmanagedResources");
          CloseHandle(handle_b);
          handle_b = IntPtr.Zero;
        }
        finally
        { 
          base.DisposeUnmanagedResources();
        }
    }
}

Answer 9

1. 如果您使用的其他托管对象正在使用非托管资源，则您没有责任确保这些对象最终确定。 您的责任是，当在您的对象上调用 Dispose 时，对这些对象调用 Dispose，并在此停止。

2. 如果你的类不使用任何稀缺资源，我不明白为什么你会让你的类实现 IDisposable。 仅当您符合以下条件时才应这样做：

   • 知道你的对象很快就会有稀缺资源，只是不是现在（我的意思是，就像“我们仍在开发，它会在我们完成之前就在这里”，而不是“我认为我们”我需要这个”）
   • 利用稀缺资源

3. 是的，使用您的代码的代码必须调用对象的 Dispose 方法。 是的，使用您的对象的代码可以使用using，如您所示。

4. （又是 2？）WebClient 很可能使用非托管资源或实现 IDisposable 的其他托管资源。 然而，确切的原因并不重要。 重要的是它实现了 IDisposable，因此您需要根据这些知识采取行动，在使用完该对象后处理该对象，即使事实证明 WebClient 根本不使用其他资源。

Answer 10

另一个答案的某些方面略有不正确，原因有两个：

首先，

using(NoGateway objNoGateway = new NoGateway())

实际上相当于：

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

这听起来可能很荒谬，因为“new”运算符永远不应该返回“null”，除非出现 OutOfMemory 异常。 但请考虑以下情况：
1. 您调用返回 IDisposable 资源的 FactoryClass 或
2. 如果您的类型可能继承也可能不继承 IDisposable，具体取决于其实现 - 请记住，我在许多客户端上多次看到 IDisposable 模式实现不正确，其中开发人员只是添加 Dispose() 方法而不继承 IDisposable (不好，不好，不好）。 您还可能会遇到从属性或方法返回 IDisposable 资源的情况（再次糟糕，糟糕，糟糕 - 不要“放弃您的 IDisposable 资源）”

using(IDisposable objNoGateway = new NoGateway() as IDisposable)
{
    if (NoGateway != null)
    {
        ...

如果“as”运算符返回 null（或者属性或方法返回资源），并且“using”块中的代码可以防止“null”，由于“内置”空检查，当尝试对空对象调用 Dispose 时，您的代码不会崩溃。

您的回复不准确的第二个原因是因为以下内容：

GC 销毁对象时调用终结器

首先，终结（以及 GC 本身）是不确定的。 CLR 决定何时调用终结器。 即开发人员/代码不知道。 如果 IDisposable 模式正确实现（正如我上面发布的）并且 GC.SuppressFinalize() 已被调用，则 Finalizer 将不会被调用。 这是正确实施该模式的重要原因之一。 由于每个托管进程只有 1 个 Finalizer 线程，无论逻辑处理器的数量有多少，您都可以通过备份甚至通过忘记调用 GC.SuppressFinalize() 挂起 Finalizer 线程来轻松降低性能。

我在我的博客上发布了 Dispose 模式的正确实现： 如何正确实现 Dispose 模式

Answer 11

1) WebClient 是托管类型，因此不需要终结器。 如果您的用户不使用 NoGateway 类的 Dispose() 并且之后需要清理本机类型（不被 GC 收集），则需要终结器。 在这种情况下，如果用户不调用 Dispose()，则包含的 WebClient 将在 NoGateway 调用后立即由 GC 进行处理。

2）间接是的，但你不必担心。 您的代码是正确的，您无法阻止您的用户很容易忘记 Dispose() 。

Answer 12

来自 msdn 的模式

public class BaseResource: IDisposable
{
   private IntPtr handle;
   private Component Components;
   private bool disposed = false;
   public BaseResource()
   {
   }
   public void Dispose()
   {
      Dispose(true);      
      GC.SuppressFinalize(this);
   }
   protected virtual void Dispose(bool disposing)
   {
      if(!this.disposed)
      {        
         if(disposing)
         {
            Components.Dispose();
         }         
         CloseHandle(handle);
         handle = IntPtr.Zero;
       }
      disposed = true;         
   }
   ~BaseResource()      
   {      Dispose(false);
   }
   public void DoSomething()
   {
      if(this.disposed)
      {
         throw new ObjectDisposedException();
      }
   }
}
public class MyResourceWrapper: BaseResource
{
   private ManagedResource addedManaged;
   private NativeResource addedNative;
   private bool disposed = false;
   public MyResourceWrapper()
   {
   }
   protected override void Dispose(bool disposing)
   {
      if(!this.disposed)
      {
         try
         {
            if(disposing)
            {             
               addedManaged.Dispose();         
            }
            CloseHandle(addedNative);
            this.disposed = true;
         }
         finally
         {
            base.Dispose(disposing);
         }
      }
   }
}

Answer 13

using(NoGateway objNoGateway = new NoGateway())

相当于

try
{
    NoGateway = new NoGateway();
}

finally
{
    NoGateway.Dispose();
}

GC 销毁对象时调用终结器。 这可能是在与您离开系统时完全不同的时间。 IDisposable 的 Dispose 在您离开 using 块后立即调用。 因此，该模式通常是在不再需要资源后立即使用 using 来释放资源。