Dispose和Finalize之间的主要区别是:

Dispose通常由代码调用。当您调用它时，资源立即被释放。人们忘记调用这个方法，所以使用(){}语句被发明出来。当您的程序完成{}内代码的执行时，它将自动调用Dispose方法。

您的代码不会调用Finalize。它意味着由垃圾收集器(GC)调用。这意味着在将来的任何时候，只要GC决定这样做，就可以释放资源。当GC工作时，它将通过许多Finalize方法。如果你在这里面有沉重的逻辑，它会使过程变慢。这可能会导致程序的性能问题。所以小心你放进去的东西。

我个人会在Dispose中编写大部分销毁逻辑。希望这能消除困惑。

Finalize在该对象不再使用时由GC调用。

Dispose只是一个普通的方法，该类的用户可以调用它来释放任何资源。

如果用户忘记调用Dispose，如果类实现了Finalize，那么GC将确保它被调用。

以下是MCSD认证工具包(考试70-483)第193页中的一些关键信息:

析构函数≈(几乎等于)base.Finalize()，析构函数被转换为Finalize方法的重写版本，该方法执行析构函数的代码，然后调用基类的Finalize方法。这是完全不确定的，你不知道什么时候会被调用，因为这取决于GC。

如果一个类不包含托管资源和非托管资源，它就不应该实现IDisposable或具有析构函数。

如果类只有托管资源，它应该实现IDisposable，但不应该有析构函数。(当析构函数执行时，您仍然不能确定托管对象 所以你不能调用它们的Dispose()方法。)

如果类只有非托管资源，则需要实现IDisposable，并需要析构函数以防程序不调用Dispose()。

Dispose()方法必须能够安全地运行多次。您可以通过使用一个变量来跟踪它以前是否运行过来实现这一点。

Dispose()应该同时释放托管和非托管资源。

析构函数应该只释放非托管资源。当析构函数执行时，您 不能确定托管对象是否仍然存在，因此无论如何都不能调用它们的Dispose方法。这是通过使用规范的受保护的void Dispose(bool Dispose)模式获得的，其中只有在Dispose == true时才释放(Dispose)托管资源。

释放资源后，Dispose()应该调用GC。SuppressFinalize，这样对象就可以 跳过结束队列。

一个具有非托管资源和托管资源的类的实现示例:

using System;

class DisposableClass : IDisposable
{
    // A name to keep track of the object.
    public string Name = "";

    // Free managed and unmanaged resources.
    public void Dispose()
    {
        FreeResources(true);

        // We don't need the destructor because
        // our resources are already freed.
        GC.SuppressFinalize(this);
    }

    // Destructor to clean up unmanaged resources
    // but not managed resources.
    ~DisposableClass()
    {
        FreeResources(false);
    }

    // Keep track if whether resources are already freed.
    private bool ResourcesAreFreed = false;

    // Free resources.
    private void FreeResources(bool freeManagedResources)
    {
        Console.WriteLine(Name + ": FreeResources");
        if (!ResourcesAreFreed)
        {
            // Dispose of managed resources if appropriate.
            if (freeManagedResources)
            {
                // Dispose of managed resources here.
                Console.WriteLine(Name + ": Dispose of managed resources");
            }

            // Dispose of unmanaged resources here.
            Console.WriteLine(Name + ": Dispose of unmanaged resources");

            // Remember that we have disposed of resources.
            ResourcesAreFreed = true;
        }
    }
}

Finalize是backstop方法，由垃圾回收器在回收对象时调用。Dispose是“确定性清理”方法，应用程序调用它来释放有价值的本机资源(窗口句柄、数据库连接等)，当它们不再需要时，而不是让它们无限期地保留，直到GC到达对象。

作为对象的用户，您总是使用Dispose。Finalize是针对GC的。

As the implementer of a class, if you hold managed resources that ought to be disposed, you implement Dispose. If you hold native resources, you implement both Dispose and Finalize, and both call a common method that releases the native resources. These idioms are typically combined through a private Dispose(bool disposing) method, which Dispose calls with true, and Finalize calls with false. This method always frees native resources, then checks the disposing parameter, and if it is true it disposes managed resources and calls GC.SuppressFinalize.

99%的情况下，你都不需要担心。但是，如果你的对象持有对非托管资源的引用(例如，窗口句柄，文件句柄)，你需要为托管对象提供一种释放这些资源的方法。Finalize对释放资源进行隐式控制。它由垃圾回收器调用。Dispose是一种对资源释放进行显式控制的方法，可以直接调用。

关于垃圾收集的主题还有很多很多需要学习，但这只是一个开始。

这是我知道的最好的例子。

 public abstract class DisposableType: IDisposable
  {
    bool disposed = false;

    ~DisposableType()
    {
      if (!disposed) 
      {
        disposed = true;
        Dispose(false);
      }
    }

    public void Dispose()
    {
      if (!disposed) 
      {
        disposed = true;
        Dispose(true);
        GC.SuppressFinalize(this);
      }
    }

    public void Close()
    {
      Dispose();
    }

    protected virtual void Dispose(bool disposing)
    {
      if (disposing) 
      {
        // managed objects
      }
      // unmanaged objects and resources
    }
  }