当我们没有析构函数时为什么要调用 SuppressFinalize

Question

我有几个问题无法得到正确的答案。

1）当我们没有析构函数时，为什么要在Dispose函数中调用SuppressFinalize。

2) Dispose 和 Finalize 用于在对象被垃圾收集之前释放资源。无论它是托管资源还是非托管资源，我们都需要释放它，那么为什么我们需要在 dispose 函数中添加一个条件，即当我们从 IDisposable:Dispose 调用此重写函数时传递“true”，而从 Finalize 调用时传递 false。

请参阅我从网上复制的以下代码。

class Test : IDisposable
   {
     private bool isDisposed = false;

     ~Test()
     {
       Dispose(false);
     }

     protected void Dispose(bool disposing)
     {
       if (disposing)
       {
         // Code to dispose the managed resources of the class
       }
       // Code to dispose the un-managed resources of the class

       isDisposed = true;
     }

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

如果我删除布尔保护的 Dispose 函数并实现如下所示，会怎么样。

   class Test : IDisposable
   {
     private bool isDisposed = false;

     ~Test()
     {
       Dispose();
     }


     public void Dispose()
     {
      // Code to dispose the managed resources of the class
      // Code to dispose the un-managed resources of the class
      isDisposed = true;

      // Call this since we have a destructor . what if , if we don't have one 
       GC.SuppressFinalize(this);
     }
   }       

Answer 1

我在这里冒险，但是......大多数人不需要需要成熟的处置模式。它被设计为在直接访问非托管资源（通常通过 IntPtr）和继承方面是可靠的。大多数时候，这些实际上都不是必需的。

如果您只是持有对实现 IDisposable 的其他内容的引用，那么您几乎肯定不需要终结器 - 直接持有资源的任何内容都负责处理该资源。您可以这样做：

public sealed class Foo : IDisposable
{
    private bool disposed;
    private FileStream stream;

    // Other code

    public void Dispose()
    {
        if (disposed)
        {
            return;
        }
        stream.Dispose();
        disposed = true;
    }
}

请注意，这不是线程安全的，但这可能不会成为问题。

由于不必担心子类直接保存资源的可能性，因此您不需要抑制终结器（因为没有终结器） - 并且您也不需要提供一种子类自定义处置的方法。没有继承，生活会更简单。

如果您确实需要允许不受控制的继承（即您不愿意打赌子类会有非常特殊的需求），那么您需要采用完整的模式。

请注意，与 .NET 1.1 中相比，使用 .NET 2.0 中的 SafeHandle 时，您需要自己的终结器的情况甚至更加罕见。

---

首先要解决您关于为什么有一个 dispose 标志的观点：如果您在终结器中运行，则您引用的其他对象可能已经被终结。您应该让它们自行清理，并且您应该只清理您直接拥有的资源。

Answer 2

以下是主要事实

1) Object.Finalize 是您的类在具有 Finalizer 时重写的内容。 ~TypeName() 析构函数方法只是“覆盖 Finalize()”等的简写

2) 如果您在最终确定之前（即从 using 块等出来时）在 Dispose 方法中处置资源，则可以调用 GC.SuppressFinalize。如果您没有 Finalizer，则无需执行此操作。如果您有 Finalizer，这可以确保将对象从 Finalization 队列中取出（因此我们不会两次处理内容，因为 Finalizer 通常也会调用 Dispose 方法）

3）您将 Finalizer 实现为“故障安全”机制。终结器保证运行（只要 CLR 没有中止），因此它们允许您确保在未调用 Dispose 方法的情况下清理代码（也许程序员忘记在“使用”中创建实例） 4) 终结器非常昂贵，

因为具有终结器的类型无法在 Generation-0 集合（最有效）中进行垃圾收集，并且通过 F-Reachable 队列上对它们的引用提升到 Generation-1，因此它们代表 GC 根。直到 GC 执行第一代收集时，终结器才会被调用，并且资源才会被释放 - 因此仅在非常重要的情况下才实现终结器 - 并确保需要终结的对象尽可能小 - 因为所有可以你的可终结对象所达到的目标也将被提升到第一代。

Answer 3

保留第一个版本，它更安全，并且是处置模式的正确实现。

1. 调用 SuppressFinalize 告诉 GC 您已经自行完成了所有销毁/处置（您的类持有的资源），并且不需要调用析构函数。

2. 您需要测试，以防使用您的类的代码已经调用了 dispose，并且您不应该告诉 GC 再次进行 dispose。

请参阅此 MSDN 文档（Dispose 方法应调用抑制最终确定）。

Answer 4

您应该始终调用 SuppressFinalize()，因为您可能拥有（或将来拥有）一个实现 Finalizer 的派生类 - 在这种情况下您需要它。

假设您有一个没有 Finalizer 的基类 - 并且您决定不调用 SuppressFinalize()。然后 3 个月后，您添加一个派生类，该类添加了 Finalizer。您可能会忘记转到基类并添加对 SuppressFinalize() 的调用。如果没有终结器，调用它并没有什么坏处。

我建议的 IDisposable 模式发布在这里： 如何正确实现处置模式

Answer 5

1.回答第一个问题

基本上，如果您的类没有 Finalize 方法（析构函数），则不必调用 SuppressFinalize 方法。我相信由于缺乏知识，即使没有 Finalize 方法，人们也会调用 SupressFinalize。

2.第二个问题的回答

Finalize方法的目的是释放非托管资源。最重要的是要理解，当对象位于终结队列中时，Finalize 方法将被调用。垃圾收集器收集所有可以销毁的对象。垃圾收集器在销毁之前将已完成的对象添加到完成队列中。还有另一个 .net 后台进程为终结队列中的对象调用 Finalize 方法。当后台进程执行 Finalize 方法时，该特定对象的其他托管引用可能已被销毁。因为最终执行时没有特定的顺序。因此，Dispose 模式希望确保 Finalize 方法不会尝试访问托管对象。这就是为什么托管对象位于“if（处置）”子句中，而 Finalize 方法无法访问该子句。