c# - 标准处理模式？为什么我们在虚拟方法中需要 "disposing"参数，并且终结器不是总是在处理后调用？

Question

为什么我们在下面的代码片段中需要参数disposing。

此外，我们在终结器中使用 false 调用 dispose，它不会释放或进行清理。

如果 dispose 永远不会被调用怎么办？

dispose 不是总是在 finalizer 之前被调用吗？

using System;
public class MyClass : IDisposable 
{ 
    private bool disposed = false;  
    protected virtual void Dispose(bool disposing) 
    {    
        if (!disposed)
        {
            **//Do we really need this condition?
            if (disposing)**
            { 
                // called via myClass.Dispose().    
                // OK to use any private object references
            }
            disposed = true; 
        } 
    }
    public void Dispose() 
        // Implement IDisposable     
    {
        Dispose(true);   
        GC.SuppressFinalize(this); 
    } 
    ~MyClass() // the finalizer
    {
        //why do we need to call with false?
        Dispose(false);    
    }
} 

换句话说，为什么不呢？

using System;
public class MyClass : IDisposable 
{ 
    private bool disposed = false;  
    protected virtual void Dispose(bool suppressFinalize) 
    {    
        if (!disposed)
        {
            //Do we really need this condition?

                // called via myClass.Dispose().    
                // OK to use any private object references            
            disposed = true; 
        }
        if (!suppressFinalize)
        {
            GC.SuppressFinalize(this); 
        }
    }
    public void Dispose() 
        // Implement IDisposable     
    {
        Dispose(true);   

    } 
    ~MyClass() // the finalizer
    {
        //why do we need to call with false?
        Dispose(false);    
    }
} 

事实上，我真的需要finalizer吗？为什么不是这个？

using System;
public class MyClass : IDisposable 
{     
    public void Dispose() 
        // Implement IDisposable     
    {
        //just do the cleanup and release resources
        GC.SuppressFinalize(this);
    } 

} 

Answer 1

Moreover we invoke dispose with false, in finalizer and it wont release or do the clean up.

确实 - 在这种情况下，它会假设其他类处理它们自己的清理，并且只清理直接的非托管资源。

So what if dispose never get called?

然后终结器将被调用，它将清理任何直接非托管资源，但不用担心间接资源。 p>

Isn't dispose always get called before finalizer?

如果没有人出于任何原因调用它，则不会。

我认为这种模式比它需要的更复杂，因为它试图解释充当其他类的基类的类，这些类可能需要终结器。密封你的类，你就可以准确地实现你所期望的:)

您可能还想阅读 Joe Duffy 的 "Never write a finalizer again"博客文章和 long explanation of the pattern .