为什么 .NET 对象有方法 Finalize()？

Question

我知道垃圾收集器使用 Finalize 方法让对象释放非托管资源。据我所知，Object.Finalize 永远不会被 GC 直接调用（如果它的类型 overrides 通过实现终结器来实现 Finalize 方法，则在它的构造过程中将对象添加到 f-reachable 队列中）。

Object.Finalize 仅从自动生成的终结器代码调用：

try
{
  //My class finalize implementation
}
finally
{
  base.Finalize(); // Here chain of base calls will eventually reach Object.Finalize/
}

因此，拥有一个派生自 Object 的任意类不会调用 Object.Finalize - 您需要 Object.Finalize 的终结器才有意义，而对于大多数类来说，它没有意义并且未被使用（并不是说它的实现是实际上是空的）。

如果不覆盖 Object.Finalize 以及在不尝试{}finally{base.Finalize()} 通话？类似于 Add 方法的集合初始化方法 - 您不必实现任何接口或重写该方法 - 只需实现 public void Add(item) 方法即可。

这会使 C# 编译器稍微复杂一点，但通过删除一个冗余调用使终结器运行得稍微快一些，最重要的是 - 使 Object 类更易于理解，而无需使用具有空实现的受保护 Finalize 方法，而它不需要完成任何事情。

还可以实现从 Object 派生的 FinalizableObject 类，并使编译器派生所有具有终结器的类。它可以实现 IDisposable 并使disposing pattern, recommended by Microsoft 可重用，而无需在每个类中实现它。其实我很惊讶这样的基类不存在。

Answer 1

编辑

垃圾回收不会调用Object.Finalise 的子实现，除非该方法被覆盖。为什么它对所有对象都可用？这样它可以在需要时被覆盖，但除非它不会影响性能。查看文档here，它指出；

Object 类不提供 Finalize 方法的实现，并且垃圾收集器不会标记派生自 Object 的类型以进行终结，除非它们覆盖 Finalize 方法。

关于完成的说明

直接引用 Ben Watson 的优秀著作《Writing High-Performance .NET Code》，因为他的解释比我做得更好；

除非需要，否则永远不要实现终结器。终结器是代码，由垃圾收集器触发以清理非托管资源。它们是从单个线程一个接一个地调用的，并且只有在垃圾收集器在收集后声明对象死亡之后。这意味着如果你的类实现了一个终结器，你保证即使在应该杀死它的集合之后它也会留在内存中。这会降低整体 GC 效率并确保您的程序将 CPU 资源专用于清理对象。

如果你实现了终结器，你还必须实现IDisposable 启用显式清理的接口，并调用GC.SuppressFinalize(this) 在Dispose 方法中将对象从终结队列中移除。 只要在下一次收集之前调用Dispose，它就会正确清理对象，而无需运行终结器。下面的例子正确地演示了这种模式；

class Foo : IDisposable
{
    ~Foo()
    {
        Dispose(false);
    }

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

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            this.managedResource.Dispose();
        }
        // Cleanup unmanaged resource
        UnsafeClose(this.handle);
        // If the base class is IDisposable object, make sure you call:
        // base.Dispose();
    }
}

注意 有些人认为终结器可以保证运行。这通常是正确的，但并非绝对如此。如果程序被强制终止 然后不再运行代码，进程立即终止。在进程关闭时，所有终结器的时间也有时间限制。如果你的终结器在列表的末尾，它可能会被跳过。而且， 因为终结器是按顺序执行的，如果另一个终结器中有一个无限循环错误，那么它之后的终结器将永远不会运行。虽然终结器不在 GC 线程上运行，但它们由 GC 触发，因此如果您没有集合，终结器将不会运行。因此，您不应依赖终结器来清理进程外部的状态。

Microsoft 对终结器和 Disposable 模式 here 有一篇很好的文章

Answer 2

C# 语言的析构函数语法模糊了终结器真正 的作用。也许最好用一个示例程序来演示：

using System;

class Program {
    static void Main(string[] args) {
        var obj = new Example();
        obj = null;    // Avoid debugger extending its lifetime
        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.ReadLine();
    }
}

class Base { ~Base() { Console.WriteLine("Base finalizer called"); } }
class Derived : Base { ~Derived() { Console.WriteLine("Derived finalizer called"); } }
class Example : Derived { }

输出：

调用的派生终结器
基终结器调用

这种行为有一些值得注意的地方。 Example 类本身没有终结器，但无论如何都会调用它的基类终结器。在基类终结器之前调用派生类终结器并非偶然。请注意，派生类的终结器没有调用 base.Finalize()，尽管 Object.Finalize() 的 MSDN 文章要求它这样做，但无论如何都会调用它。

您可能很容易识别这种行为，这是virtual 方法的行为方式。一个覆盖调用基本方法的方法，就像通常的虚拟方法覆盖一样。否则正是它在 CLR 中的内容，Finalize() 是一个普通的虚拟方法，就像任何其他方法一样。 C# 编译器为 Derived 类的析构函数生成的实际代码类似于：

protected override Derived.Finalize() {
    try {
        Console.WriteLine("Derived finalizer called"); 
    }
    finally {
        base.Finalize();
    }
}

无效代码，但可以从 MSIL 逆向工程的方式。 C# 语法糖确保您永远不会忘记调用基本终结器，并且它不会被线程中止或 AppDomain 卸载中止。 C# 编译器不会以其他方式帮助并为 Example 类自动生成终结器； CLR 完成必要的工作来查找最派生类的终结器，遍历基类的方法表，直到找到一个。同样，通过设置一个标志来帮助类加载器，以指示 Example 具有带有终结器的基类，因此需要由 GC 特殊处理。基类终结器调用 Object.Finalize()，即使它没有做任何事情。

所以关键是 Finalize() 实际上是一个虚方法。因此，它需要在 Object 的方法表中的一个槽，以便派生类可以覆盖它。是否可以以不同的方式完成是非常主观的。当然不容易，也不是不强制每种语言实现都对其进行特殊处理。