c#中的非托管资源释放 (Finalize和Dispose)

c# 非托管资源的释放(析构函数、Dispose) 调用了Dispose方法。每一个类库固然能够提供各自释放资源的方法,好比close()、release()、clear()等等。使用using 语句语句,在一定的范围内有效,除了这个范围时,自动调用IDisposable的。所以在自定义的类,并且继承IDisposable接口的时候,重写虚函数Dispose,并且还为实现了IDispose接口的类提供了using释放资源的语法糖。调用的是微软类库或者第三方类库,通常类库会提供释放的方法,即约定为。并且新建带参数的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方法一般是系统调用,用户不去显式的调用它)
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.
//
非托管资源
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
    // 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;
    }
    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方法都是调用的是Dispose(bool disposing)方法,所以最终调用的是派生度最大的哪个函数,也就派生类中的Finalize和公共Dispose方法都是调用派生类自己的Dispose(bool disposing)方法。对于虚拟方法,可以参看我写的一篇文章地址是:

http://blog.youkuaiyun.com/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中的“良民”。

 

浅谈C#内存回收与Finalize, Dispose, Close方法(二) hauj.NET Framework 提供Object.Finalize方法,它允许对象在垃圾回收器回收该对象使用的内存时适当清理其非托管资源。 默认情况下,Finalize 方法不执行任何操作。 如果您要让垃圾回收器在回收对象的内存之前对对象执行清理操作,您必须在类中重写Finalize 方法。 若要在 C# 中实现 Finalize 方法,您必须间接使用析构函数语法。也就是C#的 ~Cl 阅读详情

相关推荐

C#中标准的IDispose模式代码详解

C#实现IDispose接口 .net的GC机制有两个问题:首先GC并不能释放所有资源,它更不能释放非托管资源。其次,GC也不是实时的,所有GC存在不确定性。 为了解决这个问题donet提供了析构函数 public class TestClass : System.IDisposable { //供程序员显式调用的Dispose方法 public void Dispose() { //调用带参数的Dispose方法,释放托管和非托管资源 Dispose(true); //手动调用了Dispose释放资源,那么析构函数就是不必要的了,这里阻止GC调用析构

C# 中的Dispose()用法

Dispose()    在向大家详细介绍C#调用Dispose()方法之前,首先让大家了解下Dispose()方法,然后全面介绍C#调用Dispose()方法。 我们已经知道了处置那些占用非受控(unmanaged)资源的对象的重要性,现在应该编写资源管理代码来处置那些包含非内存资源的类型了。整个.NET 框架组件都使用一个标准的模式来处理非内存资源。使用你建立的类型的用户也希望你遵循这个标准

JohnWang的专栏 2万+

C#中IDispose接口的实现及为何这么实现详解

前言 我原本认为对于IDispose的实现方法,只要在里面释放非托管资源就行了,但是通过网上资料,看到很多实现方法并不是仅仅做释放非托管资源,非常迷惑,关键是这些资料也没详细的告诉你为什么这么做?之后通过StackOverflow了解到这一步一步的原因,说的十分详细,结合自己的认识,翻译后分享给大家: 一、IDispose的实现方法 具体的实现方法,你可以直接查看这个软件开发网网站的教程: //www.jb51.net/article/54899.htm 如果你能看懂,并且很清楚为什么那么做。那么以下的文章你就可以略去不看。如果不清楚为什么那么做,请带着你的迷惑往下看: 二、为什么那样实现 英

C# 托管资源和非托管资源(Dispose、析构函数)

https://www.cnblogs.com/herenzhiming/articles/9691524.html 资源分类: 托管资源指的是.NET可以自动进行回收的资源,主要是指托管堆上分配的内存资源。托管资源的回收工作是不需要人工干预的,有.NET运行库在合适调用垃圾回收器进行回收。 非托管资源指的是.NET不知道如何回收的资源,最常见的一类非托管资源是包装操作系统资源的对象,例如文件,窗口,网络连接,数据库连接,画刷,图标等。这类资源,垃圾回收器在清理的时候会调用Object.Finaliz

u013238956的博客 1200

#1机器学习(西瓜书)自学记录

《机器学习 》 Datawhale 组队学习, 吃瓜自学笔记。

qq_74168740的博客 1149

射频接收机本振相噪指标计算:从倒易混频到GSM实战

在射频接收机设计中,相位噪声是衡量本振信号频谱纯度、影响系统灵敏度的关键指标。其核心影响机制源于倒易混频原理:当不纯净的本振信号与强带外阻塞信号混频时,本振的噪声边带会被转换到中频通带内,从而抬升接收机噪声基底。这一过程直接决定了接收机在阻塞测试等场景下的性能极限。从技术价值看,精确计算本振相噪要求,是进行系统噪声预算、实现成本与性能权衡的核心依据。尤其在手机、基站等对灵敏度要求极高的应用中,它指导着锁相环和压控振荡器的选型与设计。本文以经典的GSM DCS1800标准为例,通过详细的公式推导与变量分析,演

weixin_30368405的博客 331

析构函数和Dispose的使用区别

老生常谈的问题了,MSDN也有非常详细的说明但看起来不是很系统。也曾经做过分析,但没有总结下来又忘了,这次整理一下MSDN和网上搜集的一些资料,以备不时只需。 下面是MSDN对这两个函数的建议使用方法 MSDN建议 1 // Design pattern for a base class. 2 public class Base : IDisposable ...

weixin_30337251的博客 243

Power BI常见问题篇1:无法打开文档

Power BI常见问题篇1:无法打开文档

weixin_48273257的博客 3309

关于Dispose()的问题

        当我怀着美好的心情翻阅dotNET文档的时候,Dispose令人厌恶的进入了我的视线。        首先,我意识到文档里面所说的,某些对象必须手工调用Dispose,并不是一句玩笑话。文档里面提到的这个要求是严肃的认真的。比如SqlConnection,虽然你不手工调用Dispose或者Close在某些情况下也可以,因为系统会在某些情况下自动调用那些;但是在另外一些情况下,不调用

Eric的博客 2256

面向边缘计算的YOLOv12模型剪枝-蒸馏联合优化实战教程**

这套剪枝-蒸馏联合方案的优势在于其系统性和可靠性。它不是单一的技巧,而是一套完整的工程流程,确保了从研发到部署的无缝衔接。

FJN110的博客 160

【24届数字IC秋招总结】笔试面试篇——投递公司及时间节点汇总

从实习、提前批到秋招投递的有进展的公司进行汇总,关于各个公司的笔试和面试经历详见其他帖子。

qq_42135020的博客 1924

C#中的非托管资源释放(Finalize&Dispose)

在了解Finalize和Dispose之前,我们需要了解两个概念,一个是托管资源,一个非委托资源。a.其中托管资源一般是指被CLR控制的内存资源,这些资源的管理可以由CLR来控制,例如程序中分配的对象,作用域内的变量等。b.而非托管资源是CLR不能控制或者管理的部分,这些资源有很多,比如文件流,数据库的连接,系统的窗口句柄,打印机资源等等……这些资源一般情况下不存在于Heap(内存中用于存储对象实

Alex's Blog 5736

S7-200 SMART PLC 子程序功能块(阀门控制)

由于S7-200 SMARTPLC的子程序种种功能、容量限制,有时想实现多次调用的子程序可能并不是太容易,这篇博客还是给出一些推荐写法,供大家参看。

RXXW_Dor的博客 8072

C# Finalize和Dispose的区别

一:总结 1、Finalize方法(C#中是析构函数,以下称析构函数)是用于释放非托管资源的,而托管资源会由GC自动回收。所以,我们也可以这样来区分 托管和非托管资源。所有会由GC自动回收的资源,就是托管的资源,而不能由GC自动回收的资源,就是非托管资源。在我们的类中直接使用非托管资源的情况很 少,所以基本上不用我们写析构函数。 2、大部分的非托管资源会给系统带来很多负面影响,例如数据...

276

【WRF湿度调整策略】WRF/ERA5湿度数据对比

【WRF湿度调整策略】WRF/ERA5湿度数据对比

WW、forever的博客 121

Android Input——输入事件ANR执行(十六)

上一篇文章我们介绍了输入事件 ANR 的触发流程,这里我们再来看一下输入事件 ANR的执行流程。

小旭的专栏 946

C# Finalize 与 Dispose

1、使用场景:      Finalize:Finalize 是 Object的方法,C# 类中使用了非托管资源,重写Finalize ,在方法内部释放非托管资源。从而保证了当前类被释放的同时,也释放了内部使用的非托管资源。这里的重写不能使用override,而是使用析构函数来达到同样效果。      Dispose:Dispose是 接口IDisposable的方法,实现Dispose方法,...

weixin_33949359的博客 371

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

托管与非托管资源介绍及 资源的释放

托管与非托管资源介绍及 资源的释放 托管资源与非委托资源 1、托管资源:一般是指被CLR控制的内存资源,这些资源的管理可以由CLR来控制,例如程序中分配(new)的对象,作用域内的变量等。 2、非托管资源:是CLR不能控制或者管理的部分,这些资源有很多,比如文件流,数据库的连接,系统的窗口句柄(Window内核对象(句柄))、字体、刷子、dc打印机资源等等……这些资源一般情况下不存在于Heap(内存中用于存储对象实例的地方)中。 C#的垃圾回收器 CLR为程序员提供的内存管理机制,使得程序员在编写代码时不需

weixin_43385465的博客 1128

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

浅谈C#内存回收与Dispose﹐Close﹐Finalize方法[转]

转自:http://blog.youkuaiyun.com/xykwgjyygy/archive/2008/01/11/2037741.aspx.net内存回收与Dispose﹐Close﹐Finalize方法一. net的对象使用一般分为三种情况﹕1.创建对象2.使用对象3.释放对象二.创建对象1.创建对象实际分为两个步骤﹕变量类型宣告和初始化对象2.变量类型宣告(declare),如﹕FileStream fs这行代码会在当前的变量作用域空间(栈或堆)里建立一个叫做fs的变量﹐至少四个字节吧(因为要存一个对象的地址

学而不思则罔,思而不学则殆。 2937
上一篇: outer和left outer join有什么区别??
下一篇: sealed关键字学习
布丁oo
博客等级 码龄19年 18粉丝 14原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值