406

C# 2008

我已经为此工作了一段时间,但我仍然对在代码中使用 finalize 和 dispose 方法感到困惑。我的问题如下:

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

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

    实现 IDisposable 只是为了让你的类的客户使用 using 语句是否可行?

    using(myClass objClass = new myClass())
    {
        // Do stuff here
    }
    
  3. 我在下面开发了这个简单的代码来演示 Finalize/dispose 的使用:

    public class NoGateway : IDisposable
    {
        private WebClient wc = null;
    
        public NoGateway()
        {
            wc = new WebClient();
            wc.DownloadStringCompleted += wc_DownloadStringCompleted;
        }
    
    
        // Start the Async call to find if NoGateway is true or false
        public void NoGatewayStatus()
        {
            // Start the Async's download
                // Do other work here
            wc.DownloadStringAsync(new Uri(www.xxxx.xxx));
        }
    
        private void wc_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            // Do work here
        }
    
        // Dispose of the NoGateway object
        public void Dispose()
        {
            wc.DownloadStringCompleted -= wc_DownloadStringCompleted;
            wc.Dispose();
            GC.SuppressFinalize(this);
        }
    }
    

关于源代码的问题:

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

    因此,我在示例中的类称为 NoGateway,客户端可以像这样使用和处置该类:

    using(NoGateway objNoGateway = new NoGateway())
    {
        // Do stuff here   
    }
    

    执行到 using 块的末尾时会自动调用 Dispose 方法,还是客户端必须手动调用 dispose 方法?IE

    NoGateway objNoGateway = new NoGateway();
    // Do stuff with object
    objNoGateway.Dispose(); // finished with it
    
  2. 我在WebClient课堂上使用该NoGateway课程。因为WebClient实现了IDisposable接口,这是否意味着WebClient间接使用了非托管资源?是否有严格的规则来遵循这一点?我怎么知道一个类使用了非托管资源?

4

13 回答 13

444

推荐的 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;中声明终结器。如果您有实际的非托管资源要处置,您应该只实施终结器。CLR 处理可终结对象与不可终结对象的方式不同,即使SuppressFinalize被调用也是如此。

因此,除非必须,否则不应声明终结器,但如果您的类的继承者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 接口时,这意味着在某个地方存在一些非托管资源,当您使用完该类时应该摆脱这些资源。实际资源封装在类中;您不需要明确删除它们。只需在 a 中调用Dispose()或包装类using(...) {}将确保在必要时摆脱任何非托管资源。

于 2009-05-22T16:52:59.980 回答
126

实现的官方模式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
  }

}
于 2010-01-29T17:19:14.513 回答
39

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

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

我整理的模式(并为其编写了代码片段)如下:

#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$</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 模式

于 2010-01-13T21:40:07.420 回答
23

我同意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 上关于为什么这是一个坏主意。我也在这里发布过 -不要在 WCF 代理中使用 'using()'

于 2010-01-14T00:25:15.513 回答
13

使用 lambdas 而不是 IDisposable。

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

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

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

想象一下,我想用 SqlConnection 做一些事情(应该包含在 using 中的东西)。经典地你会做

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

新方法

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

在第一种情况下,调用者根本无法使用 using 语法。在第二种情况下,用户别无选择。没有创建SqlConnection 对象的方法,调用者必须调用DoWithConnection。

DoWithConnection 看起来像这样

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

MakeConnection现在是私人的

于 2011-07-20T16:25:06.647 回答
12

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

简短的回答:没有

长答案:

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

  • 从经验中可以看出他们(例如套接字类)
  • 其记录在案
  • 他们很谨慎,可以看到该类实现了 IDisposable

因此,通过实现 IDisposable 你是在告诉开发者(至少是一些)这个类包含了一些必须发布的东西。他们将使用“使用”——但在其他情况下使用是不可能的(对象的范围不是本地的);在其他情况下,他们将不得不开始担心对象的生命周期——我肯定会担心。但这不是必需的

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

所以不要这样做

于 2010-01-13T21:53:49.110 回答
5

处置模式:

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();
        }
    }
}
于 2014-08-28T10:57:14.353 回答
4
  1. 如果您正在使用使用非托管资源的其他托管对象,则确保这些对象已完成不是您的责任。您的责任是在对您的对象调用 Dispose 时对这些对象调用 Dispose,并且它会停在那里。

  2. 如果您的课程不使用任何稀缺资源,我看不出您为什么要让您的课程实现 IDisposable。只有在以下情况下,您才应该这样做:

    • 知道你很快就会在你的对象中拥有稀缺的资源,而不是现在(我的意思是“我们仍在开发,它会在我们完成之前就在这里”,而不是“我认为我们需要这个")
    • 利用稀缺资源
  3. 是的,使用您的代码的代码必须调用对象的 Dispose 方法。是的,使用您的对象的代码可以using像您展示的那样使用。

  4. (又是 2 次?)WebClient 可能使用非托管资源或其他实现 IDisposable 的托管资源。然而,确切的原因并不重要。重要的是它实现了 IDisposable,因此当您完成对象时,即使 WebClient 根本不使用任何其他资源,也需要您通过处置该对象来根据该知识采取行动。

于 2009-05-22T16:55:34.987 回答
4

由于两个原因,另一个答案的某些方面略有不正确:

第一的,

using(NoGateway objNoGateway = new NoGateway())

实际上相当于:

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

这听起来很荒谬,因为除非您有 OutOfMemory 异常,否则“new”运算符永远不应该返回“null”。但请考虑以下情况: 1. 您调用返回 IDisposable 资源的 FactoryClass 或 2. 如果您有一个类型可能会或可能不会从 IDisposable 继承,具体取决于其实现 - 请记住,我已经看到 IDisposable 模式被错误地实现了很多在许多客户端,开发人员只是添加一个 Dispose() 方法而不从 IDisposable 继承(坏、坏、坏)。您还可能遇到从属性或方法返回 IDisposable 资源的情况(再次糟糕,糟糕,糟糕 - 不要“放弃您的 IDisposable 资源)

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

如果“as”运算符返回 null(或返回资源的属性或方法),并且您在“using”块中的代码防止出现“null”,则在尝试对 null 对象调用 Dispose 时,您的代码不会因为以下原因而崩溃“内置”空值检查。

您的回复不准确的第二个原因是由于以下 stmt:

在 GC 销毁您的对象时调用终结器

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

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

于 2011-03-09T14:48:51.353 回答
2

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

2)间接是的,但您不必担心。你的代码是正确的,你不能防止你的用户很容易忘记 Dispose()。

于 2009-05-22T16:50:58.203 回答
2

来自 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);
         }
      }
   }
}
于 2010-03-28T09:52:50.790 回答
1
using(NoGateway objNoGateway = new NoGateway())

相当于

try
{
    NoGateway = new NoGateway();
}

finally
{
    NoGateway.Dispose();
}

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

于 2009-05-22T16:50:11.437 回答
-5

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

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

大多数情况下,这是由于不知道何时或是否会调用它。dispose 方法要好得多,特别是如果您直接使用或 dispose。

使用是好的。用它 :)

于 2009-05-22T16:56:53.360 回答