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

https://www.360docs.net/doc/2f10553446.html,/s/blog_5aeeb8200100bl ua.html

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

(2008-12-24 13:23:03)

转载

标签：

杂谈

https://www.360docs.net/doc/2f10553446.html,/html/20070802/25631.html

苦

在了解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)方法。对于虚拟方法，可以参看我写的一篇文章地址是:

https://www.360docs.net/doc/2f10553446.html,/juky_huang/archive/2005/10/26/517069.aspx

例如，现在我们有一个派生类实例A，如果我们显示调用A.Dispose()方法，它会去调用基础中的public Dispose方法这是由于继承的原因，在public Dispose方法中调用的又是Dispose(bool disposing)方法，由于这个方法已经被重写，所以它实际调用的不是基类中的Dispose(bool disposing)方法，而是A自己的Dispose(bool disposing)方法。这是根据运行时类型来定的。所以最终还是实现了，先调用A中的资源释放，

然后才调用base.Dispose方法来完成基类的资源释放。

如果用户没有显示调用Dispose方法，那么Finalize方法就会有效，过程和上面是类似的。

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