我要评论本文实例讲述了.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)
{
}
}
}
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
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
{
public void dispose()
{
dispose(true);
gc.suppressfinalize(this);
}
protected virtual void dispose(bool disposing)
{
if (!m_disposed)
{
if (disposing)
{
// release managed resources
}
// release unmanaged resources
m_disposed = true;
}
}
~foo()
{
dispose(false);
}
private bool m_disposed;
}
{
public void dispose()
{
dispose(true);
gc.suppressfinalize(this);
}
protected virtual void dispose(bool disposing)
{
if (!m_disposed)
{
if (disposing)
{
// release managed resources
}
// release unmanaged resources
m_disposed = true;
}
}
~foo()
{
dispose(false);
}
private bool m_disposed;
}
在.net的对象中实际上有两个用于释放资源的函数：dispose和finalize
（1）、finalize的目的是用于释放非托管的资源，而dispose是用于释放所有资源，包括托管的和非托管的
（2）、void dispose(bool disposing)函数通过一个disposing参数来区别当前是否是被dispose()调用
如果是被dispose()调用，那么需要同时释放托管和非托管的资源。如果是被~foo()（也就是c#的finalize()）调用了，那么只需要释放非托管的资源即可。
（3)、dispose()函数是被其它代码显式调用并要求释放资源的，而finalize是被gc调用的
在gc调用的时候foo所引用的其它托管对象可能还不需要被销毁，并且即使要销毁，也会由gc来调用。因此在finalize中只需要释放非托管资源即可。另外一方面，由于在dispose()中已经释放了托管和非托管的资源，因此在对象被gc回收时再次调用finalize是没有必要的，所以在dispose()中调用gc.suppressfinalize(this)避免重复调用finalize。
然而，即使重复调用finalize和dispose也是不存在问题的，因为有变量m_disposed的存在，资源只会被释放一次，多余的调用会被忽略过去。
finalize、dispose保证了：
(1)、 finalize只释放非托管资源；
(2)、 dispose释放托管和非托管资源；
(3)、 重复调用finalize和dispose是没有问题的；
(4)、 finalize和dispose共享相同的资源释放策略，因此他们之间也是没有冲突的。
2、idisposable例子
复制代码 代码如下:
namespace 资源回收
{
class program
{
static void main(string[] args)
{
//使用using对实现idisposable的类了进行资源管理
/*拿到一个对象的时候，首先判断这个对象是否实现了idisposable接口，如果实现了，最好就用using包裹住这个对象，保证这个对象用完之后被释放掉，否则很可能出现资源泄露的问题
*/
using (telphone t1 = new telphone())
{
t1.open();
t1.speak("hello");
t1.bomb();
//t1.dispose();//如果在这里调用了dispose()方法释放资源，那么在执行t1.open()方法就出错，电话线已经被剪断了，无法再打电话了
t1.open();
t1.speak("i am back!");
}//代码执行到这里后，就会调用dispose方法来进行资源回收
console.readkey();
}
}
/// <summary>
/// telphone类实现了idisposable接口
/// </summary>
class telphone : idisposable
{
/// <summary>
/// 电话状态
/// </summary>
private telphonestate state;
/// <summary>
/// 打电话
/// </summary>
public void open()
{
if (state == telphonestate.disposed)
{
throw new exception("电话线已经被剪断，无法打开！");
}
state = telphonestate.open;
console.writeline("拿起电话");
}
/// <summary>
/// 说话
/// </summary>
/// <param name="s">说话内容</param>
public void speak(string s)
{
if (state != telphonestate.open)
{
throw new exception("没有连接");
}
console.writeline(s);
}
/// <summary>
/// 挂掉电话
/// </summary>
public void bomb()
{
state = telphonestate.close;
console.writeline("挂掉电话");
}
idisposable 成员
}
/// <summary>
/// 电话状态枚举
/// </summary>
enum telphonestate
{
open, close, disposed
}
}
{
class program
{
static void main(string[] args)
{
//使用using对实现idisposable的类了进行资源管理
/*拿到一个对象的时候，首先判断这个对象是否实现了idisposable接口，如果实现了，最好就用using包裹住这个对象，保证这个对象用完之后被释放掉，否则很可能出现资源泄露的问题
*/
using (telphone t1 = new telphone())
{
t1.open();
t1.speak("hello");
t1.bomb();
//t1.dispose();//如果在这里调用了dispose()方法释放资源，那么在执行t1.open()方法就出错，电话线已经被剪断了，无法再打电话了
t1.open();
t1.speak("i am back!");
}//代码执行到这里后，就会调用dispose方法来进行资源回收
console.readkey();
}
}
/// <summary>
/// telphone类实现了idisposable接口
/// </summary>
class telphone : idisposable
{
/// <summary>
/// 电话状态
/// </summary>
private telphonestate state;
/// <summary>
/// 打电话
/// </summary>
public void open()
{
if (state == telphonestate.disposed)
{
throw new exception("电话线已经被剪断，无法打开！");
}
state = telphonestate.open;
console.writeline("拿起电话");
}
/// <summary>
/// 说话
/// </summary>
/// <param name="s">说话内容</param>
public void speak(string s)
{
if (state != telphonestate.open)
{
throw new exception("没有连接");
}
console.writeline(s);
}
/// <summary>
/// 挂掉电话
/// </summary>
public void bomb()
{
state = telphonestate.close;
console.writeline("挂掉电话");
}
idisposable 成员
}
/// <summary>
/// 电话状态枚举
/// </summary>
enum telphonestate
{
open, close, disposed
}
}
程序运行结果如下图所示:
三、析构函数和idisposable混合调用的例子
复制代码 代码如下:
public class resourceholder : idisposable
{
private bool isdispose ＝ false;
// 显示调用的dispose方法
public void dispose()
{
dispose(true);
gc.suppressfinalize(this);
}
// 实际的清除方法
protected virtual void dispose(bool disposing)
{
if (!isdisposed)
{
if (disposing)
{
// 这里执行清除托管对象的操作.
}
// 这里执行清除非托管对象的操作
}
isdisposed=true;
}
// 析构函数
~resourceholder()
{
dispose (false);
}
}
{
private bool isdispose ＝ false;
// 显示调用的dispose方法
public void dispose()
{
dispose(true);
gc.suppressfinalize(this);
}
// 实际的清除方法
protected virtual void dispose(bool disposing)
{
if (!isdisposed)
{
if (disposing)
{
// 这里执行清除托管对象的操作.
}
// 这里执行清除非托管对象的操作
}
isdisposed=true;
}
// 析构函数
~resourceholder()
{
dispose (false);
}
}
希望本文所述对大家的asp.net程序设计有所帮助。
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论