我不再重复关于使用或释放非托管资源的通常内容，这些内容已经全部介绍过了。但我想指出一个常见的误解。给定以下代码

Public Class LargeStuff
  Implements IDisposable
  Private _Large as string()

  'Some strange code that means _Large now contains several million long strings.

  Public Sub Dispose() Implements IDisposable.Dispose
    _Large=Nothing
  End Sub

我意识到一次性实现没有遵循当前的指导原则，但希望你们都能理解。现在，当调用Dispose时，释放了多少内存？答：没有。调用Dispose可以释放非托管资源，它不能回收托管内存，只有GC可以这样做。这并不是说上述模式不是一个好主意，事实上遵循上述模式仍然是一个好想法。一旦Dispose运行完毕，没有什么可以阻止GC重新声明_Large使用的内存，即使LargeStuff的实例可能仍在范围内。_Large中的字符串也可能在第0代，但LargeStuff的实例可能在第2代，因此，内存将很快被重新占用。但是，添加一个finalizer来调用上面显示的Dispose方法是没有意义的。这将延迟内存的重新声明，以允许终结器运行。

大多数关于“非托管资源”的讨论的一个问题是，它们并没有真正定义这个术语，但似乎暗示它与非托管代码有关。虽然许多类型的非托管资源确实与非托管代码交互，但用这种术语来思考非托管资源是没有帮助的。

相反，我们应该认识到所有被管理的资源都有共同点：它们都包含一个对象，要求某个外部“事物”代表它做一些事情，而损害了其他一些“事物”，而另一个实体同意这样做，直到另行通知。如果物体被抛弃并消失得无影无踪，那么任何东西都不会告诉外部的“事物”，它不再需要代表不再存在的物体改变自己的行为；因此，“东西”的有用性将永久性地降低。

因此，非托管资源表示外部“事物”代表对象改变其行为的协议，如果对象被放弃并不再存在，这将毫无用处地损害外部“事物的有用性。被管理的资源是一个对象，它是此类协议的受益人，但如果它被放弃，它已签署接收通知，并将使用该通知在其被销毁之前整理其事务。

Dispose模式的目的是提供一种清理托管和非托管资源的机制，何时发生取决于Dispose方法的调用方式。在您的示例中，Dispose的使用实际上并没有执行任何与Dispose相关的操作，因为清除列表对正在处理的集合没有影响。同样，将变量设置为null的调用对GC也没有影响。

关于如何实现Dispose模式的更多详细信息，您可以查看本文，但基本上如下所示：

public class SimpleCleanup : IDisposable
{
    // some fields that require cleanup
    private SafeHandle handle;
    private bool disposed = false; // to detect redundant calls

    public SimpleCleanup()
    {
        this.handle = /*...*/;
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Dispose managed resources.
                if (handle != null)
                {
                    handle.Dispose();
                }
            }

            // Dispose unmanaged managed resources.

            disposed = true;
        }
    }

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

这里最重要的方法是Dispose（bool），它实际上在两种不同的情况下运行：

dispositing==true：用户代码直接或间接调用了该方法。可以释放托管和非托管资源。dispositing==false：该方法已由运行时从终结器内部调用，不应引用其他对象。只能释放非托管资源。

简单地让GC负责清理的问题是，你无法真正控制GC何时运行一个收集周期（你可以调用GC.Collect（），但你真的不应该这样做），所以资源可能会比需要的时间更长。记住，调用Dispose（）实际上不会导致收集循环，也不会以任何方式导致GC收集/释放对象；它只是提供了更明确地清理所用资源的方法，并告诉GC该清理已经执行。

IDisposable和dispose模式的重点不是立即释放内存。对Dispose的调用实际上只有在处理dispositing==false场景和处理非托管资源时才有机会立即释放内存。对于托管代码，在GC运行一个收集循环之前，内存实际上不会被回收，这是您无法控制的（除了调用GC.Collect（）之外，我已经提到过这不是一个好主意）。

由于.NET中的字符串不使用任何未更改的资源，也不实现IDisposable，因此您的方案并不真正有效，因此无法强制“清理”它们

给定的代码示例不是IDisposable用法的好示例。字典清除通常不应转到Dispose方法。字典项在超出范围时将被清除和处理。需要IDisposable实现来释放一些内存/处理程序，即使它们超出范围也不会释放/释放。

下面的示例显示了IDisposable模式的一个很好的示例，其中包含一些代码和注释。

public class DisposeExample
{
    // A base class that implements IDisposable. 
    // By implementing IDisposable, you are announcing that 
    // instances of this type allocate scarce resources. 
    public class MyResource: IDisposable
    {
        // Pointer to an external unmanaged resource. 
        private IntPtr handle;
        // Other managed resource this class uses. 
        private Component component = new Component();
        // Track whether Dispose has been called. 
        private bool disposed = false;

        // The class constructor. 
        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

        // Implement IDisposable. 
        // Do not make this method virtual. 
        // A derived class should not be able to override this method. 
        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.
            GC.SuppressFinalize(this);
        }

        // Dispose(bool disposing) executes in two distinct scenarios. 
        // If disposing equals true, the method has been called directly 
        // or indirectly by a user's code. Managed and unmanaged resources 
        // can be disposed. 
        // If disposing 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. 
        protected virtual void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called. 
            if(!this.disposed)
            {
                // If disposing equals true, dispose all managed 
                // and unmanaged resources. 
                if(disposing)
                {
                    // Dispose managed resources.
                    component.Dispose();
                }

                // Call the appropriate methods to clean up 
                // unmanaged resources here. 
                // If disposing is false, 
                // only the following code is executed.
                CloseHandle(handle);
                handle = IntPtr.Zero;

                // Note disposing has been done.
                disposed = true;

            }
        }

        // Use interop to call the method necessary 
        // to clean up the unmanaged resource.
        [System.Runtime.InteropServices.DllImport("Kernel32")]
        private extern static Boolean CloseHandle(IntPtr handle);

        // Use C# destructor syntax for finalization code. 
        // This destructor will run only if the Dispose method 
        // does not get called. 
        // It gives your base class the opportunity to finalize. 
        // Do not provide destructors in types derived from this class.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here. 
            // Calling Dispose(false) is optimal in terms of 
            // readability and maintainability.
            Dispose(false);
        }
    }
    public static void Main()
    {
        // Insert code here to create 
        // and use the MyResource object.
    }
}

我使用IDisposable的场景：清理非托管资源、取消订阅事件、关闭连接

我用于实现IDisposable（非线程安全）的习惯用法：

class MyClass : IDisposable {
    // ...

    #region IDisposable Members and Helpers
    private bool disposed = false;

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

    private void Dispose(bool disposing) {
        if (!this.disposed) {
            if (disposing) {
                // cleanup code goes here
            }
            disposed = true;
        }
    }

    ~MyClass() {
        Dispose(false);
    }
    #endregion
}

IDisposable适用于取消订阅事件。