在 C# 中，类中的析构函数和 Finalize 方法有什么区别？

In C# what is the difference between a destructor and a Finalize method in a class?

提问by Jeff Leonard

What is the difference, if there is one, between a destructor and a Finalize method in a class?

类中的析构函数和 Finalize 方法之间有什么区别（如果有）？

I recently discovered that Visual Studio 2008 considers a destructor synonymous with a Finalize method, meaning that Visual Studio won't let you simultaneously define both methods in a class.

我最近发现 Visual Studio 2008 将析构函数视为 Finalize 方法的同义词，这意味着 Visual Studio 不会让您在一个类中同时定义这两种方法。

For example, the following code fragment:

例如，以下代码片段：

class TestFinalize
{
    ~TestFinalize()
    {
        Finalize();
    }

    public bool Finalize()
    {
        return true;
    }
}

Gives the following error on the call to Finalize in the destructor:

在析构函数中调用 Finalize 时出现以下错误：

The call is ambiguous between the following methods or properties: 'TestFinalize.~TestFinalize()' and 'TestFinalize.Finalize()'

以下方法或属性之间的调用不明确：“TestFinalize.~TestFinalize()”和“TestFinalize.Finalize()”

And if the call to Finalize is commented out, it gives the following error:

如果对 Finalize 的调用被注释掉，则会出现以下错误：

Type 'ManagementConcepts.Service.TestFinalize' already defines a member called 'Finalize' with the same parameter types

类型 'ManagementConcepts.Service.TestFinalize' 已经定义了一个名为 'Finalize' 的成员，具有相同的参数类型

采纳答案by Mehrdad Afshari

A destructor in C# overrides System.Object.Finalizemethod. You have touse destructor syntax to do so. Manually overriding Finalizewill give you an error message.

C# 中的析构函数覆盖System.Object.Finalize方法。您必须使用析构函数语法来做到这一点。手动覆盖Finalize会给你一个错误信息。

Basically what you are trying to do with your Finalizemethod declaration is hidingthe method of the base class. It will cause the compiler to issue a warning which can be silenced using the newmodifier (if it was going to work). The important thing to note here is that you can'tboth overrideand declare a newmember with identical name at the same time so having both a destructor and a Finalizemethod will result in an error (but you can, although not recommended, declare a public new void Finalize()method if you're not declaring a destructor).

基本上，您要对Finalize方法声明进行的操作是隐藏基类的方法。它会导致编译器发出警告，可以使用new修饰符将其静音（如果它可以工作）。这里要注意的重要一点是，您不能同时override声明一个new具有相同名称的成员，因此同时具有析构函数和Finalize方法将导致错误（但您可以，虽然不推荐，但public new void Finalize()如果你不是在声明一个析构函数）。

回答by Andrew Siemer

Found here: http://sanjaysainitech.blogspot.com/2007/06/difference-between-destructor-dispose.html

在这里找到：http://sanjaysainitech.blogspot.com/2007/06/difference-between-destructor-dispose.html

1. Destructor

   They are special methods that contains clean up code for the object. You can not call them explicitly in your code as they are called implicitly by GC. In C# they have same name as the class name preceded by the ~sign. Like-

   Class MyClass
   {
   
   ~MyClass()
   {
   .....
   }
   }
   

   In VB.NET, destructors are implemented by overriding the Finalize method of the System.Object class.

2. Dispose

   These are just like any other methods in the class and can be called explicitly but they have a special purpose of cleaning up the object. In the dispose method we write clean up code for the object. It is important that we freed up all the unmanaged recources in the dispose method like database connection, files etc. The class implementing dispose method should implement IDisposable interface.A Dispose method should call the GC.SuppressFinalize method for the object it is disposing if the class has desturctor because it has already done the work to clean up the object, then it is not necessary for the garbage collector to call the object's Finalize method. Reference: http://msdn2.microsoft.com/en-us/library/aa720161(VS.71).aspx

3. Finalize

   A Finalize method acts as a safeguard to clean up resources in the event that your Dispose method is not called. You should only implement a Finalize method to clean up unmanaged resources. You should not implement a Finalize method for managed objects, because the garbage collector cleans up managed resources automatically. Finalize method is called by the GC implicitly therefore you can not call it from your code.

   Note:In C#, Finalize method can not be override, so you have to use destructor whose internal implementation will override the Finalize method in MSIL.But in the VB.NET, Finalize method can be override because it does support destructor method.

1. 析构函数

   它们是包含对象清理代码的特殊方法。您不能在代码中显式调用它们，因为它们被 GC 隐式调用。在 C# 中，它们与带~符号的类名具有相同的名称。喜欢-

   Class MyClass
   {
   
   ~MyClass()
   {
   .....
   }
   }
   

   在 VB.NET 中，析构函数是通过覆盖 System.Object 类的 Finalize 方法实现的。

2. 处置

   这些就像类中的任何其他方法一样，可以显式调用，但它们具有清理对象的特殊目的。在 dispose 方法中，我们为对象编写清理代码。重要的是，我们释放了 dispose 方法中的所有非托管资源，如数据库连接、文件等。实现 dispose 方法的类应该实现 IDisposable 接口。如果class有desturctor，因为它已经完成了清理对象的工作，那么垃圾收集器就没有必要调用对象的Finalize方法了。参考：http: //msdn2.microsoft.com/en-us/library/aa720161(VS.71).aspx

3. 敲定

   在您的 Dispose 方法未被调用的情况下，Finalize 方法充当清理资源的保护措施。您应该只实现 Finalize 方法来清理非托管资源。您不应为托管对象实现 Finalize 方法，因为垃圾收集器会自动清理托管资源。Finalize 方法由 GC 隐式调用，因此您无法从代码中调用它。

   注意：在C#中，Finalize方法不能被覆盖，所以必须使用析构函数，其内部实现会覆盖MSIL中的Finalize方法。但在VB.NET中，Finalize方法可以被覆盖，因为它确实支持析构函数方法。

Update:Interesting semi-related thread here.

更新：这里有趣的半相关线程。

回答by Kenzi

Wikipedia has some good discussion on the difference between a finalizer and a destructorin the finalizerarticle.

维基百科在终结器文章中对终结器和析构器之间的区别进行了一些很好的讨论。

C# really doesn't have a "true" destructor. The syntax resembles a C++ destructor, but it really is a finalizer. You wrote it correctly in the first part of your example:

C# 真的没有“真正的”析构函数。语法类似于 C++ 析构函数，但它实际上是一个终结器。您在示例的第一部分中正确编写了它：

~ClassName() { }

The above is syntactic sugar for a Finalizefunction. It ensures that the finalizers in the base are guaranteed to run, but is otherwise identical to overriding the Finalizefunction. This means that when you write the destructor syntax, you're really writing the finalizer.

以上是Finalize函数的语法糖。它确保基础中的终结器保证运行，但在其他方面与覆盖Finalize函数相同。这意味着当您编写析构函数语法时，您实际上是在编写终结器。

According to Microsoft, the finalizer refers to the function that the garbage collector calls when it collects (Finalize), while the destructor is your bit of code that executes as a result (the syntactic sugar that becomes Finalize). They are so close to being the same thing that Microsoft should have never made the distinction.

根据微软的说法，终结器是指垃圾收集器在收集 ( Finalize)时调用的函数，而析构函数是你作为结果执行的代码（变成 的语法糖Finalize）。它们非常接近于 Microsoft 不应该区分的同一事物。

Microsoft's use of the C++'s "destructor" term is misleading, because in C++ it is executed on the same thread as soon as the object is deleted or popped off the stack, while in C# it is executed on a separate thread at another time.

Microsoft 使用 C++ 的“析构函数”术语具有误导性，因为在 C++ 中，一旦对象被删除或从堆栈中弹出，它就会在同一线程上执行，而在 C# 中，它会在另一个时间在单独的线程上执行。