.net非托管资源的回收方法

本文实例讲述了.net非托管资源的回收方法，分享给大家供大家参考。具体分析如下：

释放未托管的资源有两种方法
 
1、析构函数

2、实现System.IDisposable接口
 
一、析构函数 
构造函数可以指定必须在创建类的实例时进行的某些操作，在垃圾收集器删除对象时，也可以调用析构函数。析构函数初看起来似乎是放置释放未托管资源、执行一般清理操作的代码的最佳地方。但是，事情并不是如此简单。由于垃圾回收器的运行规则决定了，不能在析构函数中放置需要在某一时刻运行的代码，如果对象占用了宝贵而重要的资源，应尽可能快地释放这些资源，此时就不能等待垃圾收集器来释放了． 
实例

代码如下:using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MemRelease
{
    class Program
    {
        ~Program()
        {
            // Orders.
        }
        static void Main(string[] args)
        {
        }
    }
}
 
在IL DASM中，你会发现并没有这个析构的方法。C#编译器在编译析构函数时，会隐式地把析构函数的代码编译为Finalize()方法的对应代码，确保执行父类的Finalize()方法 看下这段代码中对于析构函数的编译：

代码如下:.method family hidebysig virtual instance void
        Finalize() cil managed
{
  // Code size       14 (0xe)
  .maxstack  1
  .try
  {
    IL_0000:  nop
    IL_0001:  nop
    IL_0002:  leave.s    IL_000c
  }  // end .try
  finally
  {
    IL_0004:  ldarg.0
    IL_0005:  call       instance void [mscorlib]System.Object::Finalize()
    IL_000a:  nop
    IL_000b:  endfinally
  }  // end handler
  IL_000c:  nop
  IL_000d:  ret
} // end of method Program::Finalize
 
使用析构函数来释放资源有几个问题：
 
1、与C++析构函数相比，C#析构函数的问题是他们的不确定性。在删除C++对象时，其析构函数会立即执行，但是由于垃圾收集器的工作方式，无法确定C#对象的析构函数何时执行。
2、C#析构函数的执行会延迟对象最终从内存中删除的时间。有析构函数的对象需要2次处理才能删除：第一次调用析构函数时，没有删除对象，第二次调用才真正删除对象。
 
二、IDisposable接口

IDisposable接口定义了一个模式，为释放未托管的资源提供了确定的机制，并避免产生析构函数固有的与垃圾函数器相关的问题。IDisposable接口声明了一个方法Dispose()，它不带参数，返回void。
 
1、MSDN建议按照下面的模式实现IDisposable接口
 

代码如下:

public class Foo: IDisposable<br>
 {<br>
     public void Dispose()<br>
     {<br>
        Dispose(true);<br>
        GC.SuppressFinalize(this);<br>
     }<br>
     protected virtual void Dispose(bool disposing)<br>
     {<br>
        if (!m_disposed)<br>
        {<br>
            if (disposing)<br>
            {<br>
               // Release managed resources<br>
            }<br>
            // Release unmanaged resources<br>
            m_disposed = true;<br>
        }<br>
     }<br>
     ~Foo()<br>
     {<br>
        Dispose(false);<br>
     }<br>
     private bool m_disposed;<br>
 }<br>
 <br>
在.NET的对象中实际上有两个用于释放资源的函数：Dispose和Finalize<br>
 <br>
（1）、Finalize的目的是用于释放非托管的资源，而Dispose是用于释放所有资源，包括托管的和非托管的<br>
 <br>
（2）、void Dispose(bool disposing)函数通过一个disposing参数来区别当前是否是被Dispose()调用<br>
如果是被Dispose()调用，那么需要同时释放托管和非托管的资源。如果是被~Foo()（也就是C#的Finalize()）调用了，那么只需要释放非托管的资源即可。<br>
 <br>
（3)、Dispose()函数是被其它代码显式调用并要求释放资源的，而Finalize是被GC调用的<br>
在GC调用的时候Foo所引用的其它托管对象可能还不需要被销毁，并且即使要销毁，也会由GC来调用。因此在Finalize中只需要释放非托管资源即可。另外一方面，由于在Dispose()中已经释放了托管和非托管的资源，因此在对象被GC回收时再次调用Finalize是没有必要的，所以在Dispose()中调用GC.SuppressFinalize(this)避免重复调用Finalize。<br>
 <br>
然而，即使重复调用Finalize和Dispose也是不存在问题的，因为有变量m_disposed的存在，资源只会被释放一次，多余的调用会被忽略过去。<br>
 <br>
Finalize、Dispose保证了：<br>
 <br>
(1)、 Finalize只释放非托管资源；<br>
(2)、 Dispose释放托管和非托管资源；<br>
(3)、 重复调用Finalize和Dispose是没有问题的；<br>
(4)、 Finalize和Dispose共享相同的资源释放策略，因此他们之间也是没有冲突的。<br>
 <br>
2、IDisposable例子<p></p>
<p><span><u></u></span> 代码如下:namespace 资源回收<br>
{<br>
    class Program<br>
    {<br>
        static void Main(string[] args)<br>
        {<br>
            //使用using对实现IDisposable的类了进行资源管理<br>
/*拿到一个对象的时候，首先判断这个对象是否实现了IDisposable接口，如果实现了，最好就用using包裹住这个对象，保证这个对象用完之后被释放掉，否则很可能出现资源泄露的问题<br>
*/<br>
            using (Telphone t1 = new Telphone())<br>
            {<br>
                t1.Open();<br>
                t1.Speak("hello");<br>
                t1.Bomb();<br>
                //t1.Dispose();//如果在这里调用了Dispose()方法释放资源，那么在执行t1.Open()方法就出错，电话线已经被剪断了，无法再打电话了<br>
                t1.Open();<br>
                t1.Speak("I am back!");<br>
            }//代码执行到这里后，就会调用Dispose方法来进行资源回收<br>
            Console.ReadKey();<br>
        }<br>
    }<br>
    /// <summary><br>
    /// Telphone类实现了IDisposable接口<br>
    /// </summary><br>
    class Telphone : IDisposable<br>
    {<br>
        /// <summary><br>
        /// 电话状态<br>
        /// </summary><br>
        private TelphoneState state;<br>
        /// <summary><br>
        /// 打电话<br>
        /// </summary><br>
        public void Open()<br>
        {<br>
            if (state == TelphoneState.Disposed)<br>
            {<br>
                throw new Exception("电话线已经被剪断，无法打开！");<br>
            }<br>
            state = TelphoneState.Open;<br>
            Console.WriteLine("拿起电话");<br>
        }<br>
        /// <summary><br>
        /// 说话<br>
        /// </summary><br>
        /// <param name="s">说话内容</param><br>
        public void Speak(string s)<br>
        {<br>
            if (state != TelphoneState.Open)<br>
            {<br>
                throw new Exception("没有连接");<br>
            }<br>
            Console.WriteLine(s);<br>
        }<br>
        /// <summary><br>
        /// 挂掉电话<br>
        /// </summary><br>
        public void Bomb()<br>
        {<br>
            state = TelphoneState.Close;<br>
            Console.WriteLine("挂掉电话");<br>
        }<br>
        IDisposable 成员<br>
    }<br>
    /// <summary><br>
    /// 电话状态枚举<br>
    /// </summary><br>
    enum TelphoneState<br>
    {<br>
        Open, Close, Disposed<br>
    }<br>
}<br>
 <br>
程序运行结果如下图所示:<br>
 <br>
<img src="https://img.gxlcms.com//Uploads-s/new/2019-09-19-201919/20141023101716751.png" alt=""> <br>
 <br>
三、析构函数和IDisposable混合调用的例子</p>
<p><span><u></u></span> 代码如下:public class ResourceHolder : IDisposable<br>
{<br>
      private bool isDispose ＝ false;<br>
      // 显示调用的Dispose方法<br>
　 public void Dispose() <br>
      {<br>
           Dispose(true);<br>
          GC.SuppressFinalize(this); <br>
       }<br>
       // 实际的清除方法<br>
　 protected virtual void Dispose(bool disposing) <br>
      {<br>
            if (!isDisposed)<br>
           {<br>
      　       if (disposing) <br>
　　         { <br>
                      // 这里执行清除托管对象的操作.<br>
                  }<br>
                  // 这里执行清除非托管对象的操作<br>
            }<br>
　        isDisposed=true;<br>
      }<br>
      // 析构函数 <br>
      ~ResourceHolder()<br>
      {<br>
            Dispose (false);<br>
      }<br>
}</p>
<p>希望本文所述对大家的asp.net程序设计有所帮助。</p>