推荐的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和friend不计算在内，因为它们声明了自己的终结器)，那么就不要实现终结器，因为GC以不同的方式处理可终结类，即使您稍后抑制了终结器。还要注意，即使B没有终结器，它仍然调用SuppressFinalize来正确处理任何实现了终结器的子类。

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

using(NoGateway objNoGateway = new NoGateway())

等于

try
{
    NoGateway = new NoGateway();
}

finally
{
    NoGateway.Dispose();
}

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

处理模式:

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();
        }
    }
}

1) WebClient是一个托管类型，所以你不需要终结器。如果您的用户不Dispose()您的NoGateway类，并且本机类型(不被GC收集)之后需要清理，则需要结束器。在这种情况下，如果用户没有调用Dispose()，所包含的WebClient将在NoGateway调用之后被GC丢弃。

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

推荐的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和friend不计算在内，因为它们声明了自己的终结器)，那么就不要实现终结器，因为GC以不同的方式处理可终结类，即使您稍后抑制了终结器。还要注意，即使B没有终结器，它仍然调用SuppressFinalize来正确处理任何实现了终结器的子类。

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

另一个答案的某些方面有点不正确，原因有二:

首先,

using(NoGateway objNoGateway = new NoGateway())

Actually相当于:

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

This may sound ridiculous since the 'new' operator should never return 'null' unless you have an OutOfMemory exception. But consider the following cases: 1. You call a FactoryClass that returns an IDisposable resource or 2. If you have a type that may or may not inherit from IDisposable depending on its implementation - remember that I've seen the IDisposable pattern implemented incorrectly many times at many clients where developers just add a Dispose() method without inheriting from IDisposable (bad, bad, bad). You could also have the case of an IDisposable resource being returned from a property or method (again bad, bad, bad - don't 'give away your IDisposable resources)

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

如果'as'操作符返回null(或返回资源的属性或方法)，并且'using'块中的代码可以防止'null'，那么在尝试对空对象调用Dispose时，您的代码不会因为'内置'空检查而崩溃。

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

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

First, Finalization (as well as GC itself) is non-deterministic. THe CLR determines when it will call a finalizer. i.e. the developer/code has no idea. If the IDisposable pattern is implemented correctly (as I've posted above) and GC.SuppressFinalize() has been called, the the Finalizer will NOT be called. This is one of the big reasons to properly implement the pattern correctly. Since there is only 1 Finalizer thread per managed process, regardless of the number of logical processors, you can easily degrade performance by backing up or even hanging the Finalizer thread by forgetting to call GC.SuppressFinalize().

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