C#非托管资源释放(Finalize&Dispose)方法

在了解Finalize和Dispose之前，我们需要了解两个概念，一个是托管资源，一个非委托资源。
    a.其中托管资源一般是指被CLR控制的内存资源，这些资源的管理可以由CLR来控制，例如程序中分配的对象，作用域内的变量等。
    b.而非托管资源是CLR不能控制或者管理的部分，这些资源有很多，比如文件流，数据库的连接，系统的窗口句柄，打印机资源等等……这些资源一般情况下不存在于Heap（内存中用于存储对象实例的地方）中。
    .Net平台中，CLR为程序员提供了一种很好的内存管理机制，使得程序员在编写代码时不需要显式的去释放自己使用的内存资源（这些在先前C和C++中是需要程序员自己去显式的释放的）。这种管理机制称为GC(garbage collection)。GC的作用是很明显的，当系统内存资源匮乏时，它就会被激发，然后自动的去释放那些没有被使用的托管资源（也就是程序员没有显式释放的对象）。
    但正如上面说的，CLR的GC功能也只能释放托管资源，对于非托管资源例如窗口，文件和网络连接等，它都只能跟踪非托管资源的生存期，而不知道如何去释放它。这样就会出现当资源用尽时就不能提供资源能够提供的服务，windows的运行速度就会变慢。这样的情况会出现在数据库的连接当中，当你没有显式的释放一个数据库资源时，如果还是不断的申请数据库资源，那么到一定时候程序就会抛出一个异常。
    所以，当我们在类中封装了对非托管资源的操作时，我们就需要显式，或者是隐式的释放这些资源。而上面提到的Finalize和Dispose方法分别就是隐式和显式操作中分别使用到的方法。
    Finalize一般情况下用于基类不带close方法或者不带Dispose显式方法的类，也就是说，在Finalize过程中我们需要隐式的去实现非托管资源的释放，然后系统会在Finalize过程完成后，自己的去释放托管资源。
如果要实现Dispose方法，可以通过实现IDisposable接口，这样用户在使用这个类的同时就可以显示的执行Dispose方法，释放资源。

    以下是MSDN上提出的Finalize和Dispose方法的使用指南，如果你的类遵循这个标准的话，你写出的类在.Net平台上就是一个“良民”。

Finalize
下面的规则概括了 Finalize 方法的使用指南。

    1.仅在要求终结的对象上实现 Finalize。存在与 Finalize 方法相关的性能开销。
如果需要 Finalize 方法，应考虑实现 IDisposable，以使类的用户可以避免调用 Finalize 方法带来的开销。(juky_huang注：在实现IDisposable的类中，可以通过GC.SuppressFinalize来停止Finalize的运行，这样只要显式的调用了Dispose方法，就能给用户提供更小的开销。如果用户没有显式的调用Dispose方法，也就是没有停止Finalize的运行，这样就可以隐式的实现非托管资源的释放) 
    2.不要使 Finalize 方法更可见。它应该是 protected，而不是 public。 (juky_huang注：这个很重要，Finalize方法一般是系统调用，用户不去显式的调用它)
    [Page]3.对象的 Finalize 方法应该释放对象拥有的任何外部资源。此外，Finalize 方法应该仅释放由对象控制的资源。Finalize 方法不应该引用任何其他对象。 
    4.不要对不是对象的基类的对象直接调用 Finalize 方法。在 C# 编程语言中，这不是有效的操作。 
    5.从对象的 Finalize 方法调用 base.Finalize 方法。(juky_huang注：就是派生类调用基类的Finalize方法)
注意   基类的 Finalize 方法由 C# 和 C++ 的托管扩展的析构函数语法自动调用。

Dispose
下面的规则概括了 Dispose 方法的使用指南：

    1.在封装明确需要释放的资源的类型上实现处置设计方案。用户可以通过调用公共 Dispose 方法释放外部资源。
    2.在通常包含控制资源的派生类型的基类型上实现处置设计方案，即使基类型并不需要。如果基类型有 close 方法，这通常指示需要实现 Dispose。在这类情况下，不要在基类型上实现 Finalize 方法。应该在任何引入需要清理的资源的派生类型中实现 Finalize。 
    3.使用类型的 Dispose 方法释放类型所拥有的任何可处置资源。 
    4.对实例调用了 Dispose 后，禁止 Finalize 方法通过调用 GC.SuppressFinalize 方法运行。此规则的例外情况是当必须用 Finalize 完成 Dispose 没有覆盖的工作时，但这种情况很少见。 
    5.如果基类实现 IDisposable，则调用基类的 Dispose 方法。 
    6.不要假定 Dispose 将被调用。如果 Dispose 未被调用，也应该使用 Finalize 方法释放类型所拥有的非托管资源。 
    7.处置了资源之后，在该类型（非 Dispose）上从实例方法引发一个 ObjectDisposedException。该规则不适用于 Dispose 方法，因为在不引发异常的情况下，该方法应该可以被多次调用。 
    8.通过基类型的层次结构将调用传播到 Dispose。Dispose 方法应释放此对象控制的所有资源和此对象所拥有的任何对象。例如，可以创建一个 类似 TextReader 的对象来控制 Stream 和 Encoding，两者均在用户不知道的情况下由 TextReader 创建。另外，Stream 和 Encoding 都可以获取外部资源。当对 TextReader 调用Dispose 方法时，它应该依次对 Stream 和 Encoding 调用 Dispose，使它们释放它们的外部资源。 
    9.应考虑在调用了对象的 Dispose 方法后不允许使用对象。重新创建已处置的对象是难以实现的方案。 
    10.允许 Dispose 方法被调用多次而不引发异常。此方法在首次调用后应该什么也不做。

    有了以上的基础后，我们看一段代码，这段代码是Dispose的一个实现，这个代码如果仔细的去考虑的话，非常的有趣，在这里我们又会看到C#中一个非常常用的技术，多态性，如果你看过我在前面写的一篇关于虚拟方法的文章的话，你可以从中理解下面代码的精要之处。

public class BaseResource: IDisposable
{
 // Pointer to an external unmanaged resource.[Page]
 // 非托管资源
 private IntPtr handle;
 // Other managed resource this class uses.
 // 托管资源
 private Component Components;
 // Track whether Dispose has been called.
 // 是否已经释放资源的标志
 private bool disposed = false;

 // Constructor for the BaseResource object.
 public BaseResource()
 {
  // Insert appropriate constructor code here.
 }

 // Implement IDisposable.
 // Do not make this method virtual.
 // A derived class should not be able to override this method.
 // 提供给外部用户显示调用的方法，实际操作是在类的带参数的虚函数Dispose(bool disposing)中实现
 public void Dispose()
 {
  // 表示用户显示调用
  Dispose(true);
  // Take yourself off the Finalization queue
  // to prevent finalization code for this object
  // from executing a second time.
  // 由于用户是显示调用，所以资源释放不再由GC来完成
  GC.SuppressFinalize(this);
 }

 // Dispose(bool disposing) executes in two distinct scenarios.
 // If disposing equals true, the method has been called directly
 // or indirectly by a user\'s code. Managed and unmanaged resources
 // can be disposed.
 // If disposing equals false, the method has been called by the
 // runtime from inside the finalizer and you should not reference
 // other objects. Only unmanaged resources can be disposed.
 protected virtual void Dispose(bool disposing)
 {
  // Check to see if Dispose has already been called.
  // 如果已经释放，不做再次的操作，出现在用户多次调用的情况下
  if(!this.disposed)
  {
   // If disposing equals true, dispose all managed
   // and unmanaged resources.
   if(disposing)
   {
    // Dispose managed resources.
    // 用户是显示调用的话，我们就要手工的操作托管资源
    Components.Dispose();
   }
   // Release unmanaged resources. If disposing is false,
   // only the following code is executed.
   CloseHandle(handle);
   handle = IntPtr.Zero;
   // Note that this is not thread safe.
   // Another thread could start disposing the object
   // after the managed resources are disposed,
   // but before the disposed flag is set to true.
   // If thread safety is necessary, it must be[Page]
   // implemented by the client.

  }
  disposed = true;        
 }

 // Use C# destructor syntax for finalization code.
 // This destructor will run only if the Dispose method
 // does not get called.
 // It gives your base class the opportunity to finalize.
 // Do not provide destructors in types derived from this class.
 // 析构函数
 ~BaseResource()     
 {
  // Do not re-create Dispose clean-up code here.
  // Calling Dispose(false) is optimal in terms of
  // readability and maintainability.
  // 表示本次调用是隐式调用，由Finalize方法调用，即托管资源释放由GC来完成
  Dispose(false);
 }

 // Allow your Dispose method to be called multiple times,
 // but throw an exception if the object has been disposed.
 // Whenever you do something with this class,
 // check to see if it has been disposed.
 public void DoSomething()
 {
  if(this.disposed)
  {
   throw new ObjectDisposedException();

  }
 }
}
// Design pattern for a derived class.
// Note that this derived class inherently implements the
// IDisposable interface because it is implemented in the base class.
public class MyResourceWrapper: BaseResource
{
 // A managed resource that you add in this derived class.
 private ManagedResource addedManaged;
 // A native unmanaged resource that you add in this derived class.
 private NativeResource addedNative;
 private bool disposed = false;

 // Constructor for this object.
 public MyResourceWrapper()
 {
  // Insert appropriate constructor code here.
 }
  // 重写Dispose方法，释放派生类自己的资源，并且调用基类的Dispose方法
 protected override void Dispose(bool disposing)
 {
  if(!this.disposed)
  {
   try
   {
    if(disposing)
    {
     // Release the managed resources you added in
     // this derived class here.
     addedManaged.Dispose();        
    }
    // Release the native unmanaged resources you added
    // in this derived class here.
    CloseHandle(addedNative);
    this.disposed = true;[Page]
   }
   finally
   {
    // Call Dispose on your base class.
    base.Dispose(disposing);
   }
  }
 }
}
// 在这里，派生类没有实现~MyResourceWrapper和public Dispose方法，应为他们已经继承了基类的这些特性，这也是我说本示例代码精要之处，他使用到了多态性原理，下面我会简单分析
// This derived class does not have a Finalize method
// or a Dispose method without parameters because it inherits
// them from the base class.

本示例中有两个类一个是基类BaseResource,一个是派生类MyResourceWrapper,首先我们必须理解一下几点：
1.类型的 Dispose 方法应该释放它拥有的所有资源。它还应该通过调用其父类型的 Dispose 方法释放其基类型拥有的所有资源。该父类型的Dispose 方法应该释放它拥有的所有资源并同样也调用其父类型的 Dispose 方法，从而在整个基类型层次结构中传播该模式。
2.如果显式的调用了Dispose方法，我们就在Dispose方法中实现托管资源和非托管资源的释放，使用 GC.SuppressFinalize 方法来停止Finalize方法。因为如果用户调用了Dispose方法，那么我们就不必隐式的完成资源的释放，应为Finalizes会大大的减损性能。(Finalize一般只用于用户没有显式的调用Dispose方法，需要我们隐式完成时才使用)
3.要确保始终正确地清理资源，Dispose 方法应该可以被多次调用而不引发任何异常

示例中最主要的一个方法就是带参数的Dispose方法，本例中所有的具体操作都是放到这里来做的，它是一个受保护的虚函数，可以被派生类重写，并且如果派生类自己有对非托管资源的调用，那么派生类就要按照上面提到的要求，首先释放自己的资源，然后调用base.Dispose来实现基类的资源释放。（juky_huang注:这就是我们所谓的传播特性）
带参数的Dispose方法通过所带的参数disposing来判断，本次的Dispose操作是由Finalize发起还是由用户显式的调用公共Dispose方法发起的。如果为true则表示由公共的Dispose方法发起，如果为false表示是在GC调用Finalize方法时候发起。所以当为true时，我们就需要释放托管资源和非托管资源，并且禁止GC的Finalize操作，因为用户可以直接通过显示调用来减小性能开销。如果为false时，表示我们只需要释放非托管资源，因为本次调用是由GC的Finalize引起的，所以托管资源的释放可以让GC来完成。
示例中还有一个值得注意的地方，就是在多次显示调用Dispose时，如果资源已经处置，那么我们就要忽略本次操作，而不抛出异常。这个特性由disposed来决定。 好了，现在我们来看看这个程序的一个精要之处，那就是在派生类中，没有公共的Dispose方法，和Finalize方法（就是析构函数），那如果我们调用派生类对象时，是怎么实现资源释放的呢，刚开始我也不是很了解，后来仔细一看，突然发现其实很简单，它使用到了类的多态性来完成。
因为在派生类中使用了方法重写，所以在派生类中的Dispose(bool disposing)方法的派生度最大。由于基类中的Finalize和公共Dispose方法[Page]都是调用的是Dispose(bool disposing)方法，所以最终调用的是派生度最大的哪个函数，也就派生类中的Finalize和公共Dispose方法都是调用派生类自己的Dispose(bool disposing)方法。

 

 

例如，现在我们有一个派生类实例A，如果我们显示调用A.Dispose()方法，它会去调用基础中的public Dispose方法这是由于继承的原因，在public Dispose方法中调用的又是Dispose(bool disposing)方法，由于这个方法已经被重写，所以它实际调用的不是基类中的Dispose(bool disposing)方法，而是A自己的Dispose(bool disposing)方法。这是根据运行时类型来定的。所以最终还是实现了，先调用A中的资源释放，然后才调用base.Dispose方法来完成基类的资源释放。
如果用户没有显示调用Dispose方法，那么Finalize方法就会有效，过程和上面是类似的。

从上面可以看出，对于非托管资源的释放，有一个很好的规则，只要我们按照这个规则来做，你写的代码就是.Net中的“良民”。 

 

来源：https://www.cnblogs.com/lzhdim/archive/2009/11/04/1595845.html

 

C# Finalize和Dispose的区别

一：总结

　

Finalize自动释放资源，Dispose()用于手动释放资源。

 

1、Finalize方法（C#中是析构函数，以下称析构函数）是用于释放非托管资源的，而托管资源会由GC自动回收。所以，我们也可以这样来区分 托管和非托管资源。所有会由GC自动回收的资源，就是托管的资源，而不能由GC自动回收的资源，就是非托管资源。在我们的类中直接使用非托管资源的情况很 少，所以基本上不用我们写析构函数。

2、大部分的非托管资源会给系统带来很多负面影响，例如数据库连接不被释放就可能导致连接池中的可用数据库连接用尽。文件不关闭会导致其它进程无法读写这个文件等等。

实现模型：
1、由于大多数的非托管资源都要求可以手动释放，所以，我们应该专门为释放非托管资源公开一个方法。实现IDispose接口的Dispose方法是最好的模型，因为C#支持using语句快，可以在离开语句块时自动调用Dispose方法。

2、虽然可以手动释放非托管资源，我们仍然要在析构函数中释放非托管资源，这样才是安全的应用程序。否则如果因为程序员的疏忽忘记了手动释放非托管资源， 那么就会带来灾难性的后果。所以说在析构函数中释放非托管资源，是一种补救的措施，至少对于大多数类来说是如此。

3、由于析构函数的调用将导致GC对对象回收的效率降低，所以如果已经完成了析构函数该干的事情（例如释放非托管资源），就应当使用SuppressFinalize方法告诉GC不需要再执行某个对象的析构函数。

4、析构函数中只能释放非托管资源而不能对任何托管的对象/资源进行操作。因为你无法预测析构函数的运行时机，所以，当析构函数被执行的时候，也许你进行操作的托管资源已经被释放了。这样将导致严重的后果。

5、（这是一个规则）如果一个类拥有一个实现了IDispose接口类型的成员，并创建（注意是创建，而不是接收，必须是由类自己创建）它的实例对象，则 这个类也应该实现IDispose接口，并在Dispose方法中调用所有实现了IDispose接口的成员的Dispose方法。
只有这样的才能保证所有实现了IDispose接口的类的对象的Dispose方法能够被调用到，确保可以手动释放任何需要释放的资源。

 

二：实现 Finalize 和 Dispose 以清理非托管资源

http://msdn.microsoft.com/zh-cn/library/b1yfkh5e(VS.80).aspx

 

http://www.sudu.cn/info/index.php?op=article&id=12170

三：维护内部非托管资源的托管类的手段：Finalize()--终结和Dispose()--处置

非托管资源：原始的操作系统文件句柄，原始的非托管数据库连接，非托管内存或其他非托管资源。

Finalize()特性:

• 重写Finalize()的唯一原因是，c#类通过PInvoke或复杂的COM互操作性任务使用了非托管资源（典型的情况是通过System.Runtime.InteropServices.Marshal类型定义的各成员）注：PInvoke是平台调用服务。
• object中有finalize方法，但创建的类不能重写此方法，若Overide会报错，只能通过析构函数来达到同样的效果。
• Finalize方法的作用是保证.NET对象能在垃圾回收时清除非托管资源。
• 在CLR在托管堆上分配对象时，运行库自动确定该对象是否提供一个自定义的Finalize方法。如果是这样，对象会被标记为可终结的，同时一个指向这个对象的指针被保存在名为终结队列的内部队列中。终结队列是一个由垃圾回收器维护的表，它指向每一个在从堆上删除之前必须被终结的对象。
• 注意：Finalize虽然看似手动清除非托管资源，其实还是由垃圾回收器维护，它的最大作用是确保非托管资源一定被释放。
• 在结构上重写Finalize是不合法的，因为结构是值类型，不在堆上，Finalize是垃圾回收器调用来清理托管堆的，而结构不在堆上。

Dispose()特性:

• 为了更快更具操作性进行释放，而非让垃圾回收器（即不可预知）来进行，可以使用Dispose，即实现IDispose接口.
• 结构和类类型都可以实现IDispose（与重写Finalize不同，Finalize只适用于类类型），因为不是垃圾回收器来调用Dispose方法，而是对象本身释放非托管资源，如Car.Dispose().如果编码时没有调用Dispose方法，以为着非托管资源永远得不到释放。
• 如果对象支持IDisposable,总是要对任何直接创建的对象调用Dispose()，即有实现IDisposable接口的类对象都必须调用Dispose方法。应该认为，如果类设计者选择支持Dispose方法，这个类型就需要执行清除工作。记住一点，如果类型实现了IDisposable接口，调用Dispose方法总是正确的。
• .net基类库中许多类型都实现IDisposable接口，并使用了Dispose的别名，其中一个别名如IO中的Close方法，等等别名。使得看起来更自然。
• using关键字，实际内部也是实现IDisposable方法，用ildasm.exe查看使用了using的代码的CIL，会发现是用try/finally去包含using中的代码，并且在finally中调用dispose方法。

个人总结：

相同点：

• 都是为了确保非托管资源得到释放。

不同点：

• finalize由垃圾回收器调用；dispose由对象调用。
• finalize无需担心因为没有调用finalize而使非托管资源得不到释放，而dispose必须手动调用。
• finalize虽然无需担心因为没有调用finalize而使非托管资源得不到释放，但因为由垃圾回收器管理，不能保证立即释放非托管资源；而dispose一调用便释放非托管资源。
• 只有类类型才能重写finalize，而结构不能；类和结构都能实现IDispose.原因请看Finalize()特性。

https://www.cnblogs.com/zoro-zero/p/13490336.html