Class instances often encapsulate control over resources that are not managed by the runtime, such as window handles (HWND), database connections, and so on. Therefore, you should provide both an explicit and an implicit way to free those resources. Provide implicit control by implementing the protected Finalize Method on an object (destructor syntax in C# and the Managed Extensions for C++). The garbage collector calls this method at some point after there are no longer any valid references to the object. In some cases, you might want to provide programmers using an object with the ability to explicitly release these external resources before the garbage collector frees the object. If an external resource is scarce or expensive, better performance can be achieved if the programmer explicitly releases resources when they are no longer being used. To provide explicit control, implement the Dispose method provided by the IDisposable Interface. The consumer of the object should call this method when it is done using the object. Dispose can be called even if other references to the object are alive.

注意，即使通过Dispose方法提供显式控制，也应该使用Finalize方法提供隐式清理。Finalize提供了一个备份，以防止程序员在调用Dispose失败时永久地泄漏资源。

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

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

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

我今天一直在寻找这个问题的答案。我将在这里分享我的经验。我的答案是基于这个联系，因为它有我所见过的最清楚的解释。

当您的对象访问非托管资源时，您必须手动释放这些资源。这可以通过IDisposable或finalizer来完成，这意味着它们都会释放非托管资源。

经验法则: 实现IDisposable以释放非托管资源，调用方代码必须调用Dispose方法。如果调用者忘记调用Dispose()方法，您仍然可以提供一个方法来释放那些非托管资源。第一个选择是使用安全句柄来包装非托管资源。第二个选项是定义终结器。在这种情况下，建议使用安全手柄。

我认为这种联系是对这个问题最明确的答案。我不知道为什么人们在网上对这个问题给出复杂的解释。这让我很困惑，直到我找到了那个联系。

finalizer方法在对象被垃圾收集时被调用，并且您无法保证何时会发生这种情况(您可以强制执行，但这会影响性能)。

另一方面，Dispose方法应该由创建类的代码调用，以便在代码处理完对象后立即清理和释放已获得的任何资源(非托管数据、数据库连接、文件句柄等)。

标准实践是实现IDisposable和Dispose，这样就可以在using语句中使用对象。例如使用(var foo = new MyObject()){}。在终结器中，你调用Dispose，以防调用代码忘记释放你。

Class instances often encapsulate control over resources that are not managed by the runtime, such as window handles (HWND), database connections, and so on. Therefore, you should provide both an explicit and an implicit way to free those resources. Provide implicit control by implementing the protected Finalize Method on an object (destructor syntax in C# and the Managed Extensions for C++). The garbage collector calls this method at some point after there are no longer any valid references to the object. In some cases, you might want to provide programmers using an object with the ability to explicitly release these external resources before the garbage collector frees the object. If an external resource is scarce or expensive, better performance can be achieved if the programmer explicitly releases resources when they are no longer being used. To provide explicit control, implement the Dispose method provided by the IDisposable Interface. The consumer of the object should call this method when it is done using the object. Dispose can be called even if other references to the object are alive.

注意，即使通过Dispose方法提供显式控制，也应该使用Finalize方法提供隐式清理。Finalize提供了一个备份，以防止程序员在调用Dispose失败时永久地泄漏资源。

以下是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;
        }
    }
}