其他人已经介绍了Dispose和Finalize之间的区别(顺便说一下，Finalize方法在语言规范中仍然被称为析构函数)，所以我只补充一点Finalize方法派上用场的场景。

有些类型以一种易于在单个操作中使用和处理的方式封装一次性资源。一般用法通常是这样的:打开，读或写，关闭(Dispose)。它非常适合使用结构。

其他的稍微难一点。实例的WaitEventHandles不像这样使用，因为它们用于从一个线程发送信号到另一个线程。那么问题就变成了谁应该调用Dispose ?作为一种保护措施，这类类型实现了Finalize方法，该方法确保当应用程序不再引用实例时释放资源。

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

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

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

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

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

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

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

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

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

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

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.

完成

Finalizers should always be protected, not public or private so that the method cannot be called from the application's code directly and at the same time, it can make a call to the base.Finalize method Finalizers should release unmanaged resources only. The framework does not guarantee that a finalizer will execute at all on any given instance. Never allocate memory in finalizers or call virtual methods from finalizers. Avoid synchronization and raising unhandled exceptions in the finalizers. The execution order of finalizers is non-deterministic—in other words, you can't rely on another object still being available within your finalizer. Do not define finalizers on value types. Don't create empty destructors. In other words, you should never explicitly define a destructor unless your class needs to clean up unmanaged resources and if you do define one, it should do some work. If, later, you no longer need to clean up unmanaged resources in the destructor, remove it altogether.

拥有

Implement IDisposable on every type that has a finalizer Ensure that an object is made unusable after making a call to the Dispose method. In other words, avoid using an object after the Dispose method has been called on it. Call Dispose on all IDisposable types once you are done with them Allow Dispose to be called multiple times without raising errors. Suppress later calls to the finalizer from within the Dispose method using the GC.SuppressFinalize method Avoid creating disposable value types Avoid throwing exceptions from within Dispose methods

处理/确定模式

Microsoft recommends that you implement both Dispose and Finalize when working with unmanaged resources. The Finalize implementation would run and the resources would still be released when the object is garbage collected even if a developer neglected to call the Dispose method explicitly. Cleanup the unmanaged resources in the Finalize method as well as Dispose method. Additionally call the Dispose method for any .NET objects that you have as components inside that class(having unmanaged resources as their member) from the Dispose method.