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

COLMAP性能优化实战:如何用GPU加速和并行计算让重建速度提升300%

本文详细介绍了如何通过GPU加速、并行计算和参数调优显著提升COLMAP的三维重建效率。从硬件资源分配到计算流程优化,再到大型数据集的分块处理策略,全面解析了将重建速度提升300%以上的实用技巧,特别适合处理无人机航拍和室内扫描等大规模三维重建项目。

weixin_29098391的博客 204

利用python爬取东方财富网股吧评论并进行情感分析(一)

利用python爬取东方财富网股吧评论(一) python-东方财富网贴吧文本数据爬取 分享一下写论文时爬数据用到的代码,有什么问题或者改善的建议的话小伙伴们一起评论区讨论。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客: 全新的界面设计 ,将会带来全新的写作体验; 在创作中心设置你喜爱的代码高亮样式,Markdown 将代码片显示选择的高亮样式 进行展示; 增加了 图片拖拽 功能,你可以将本地的图片直

YMG521000的博客 1万+

析构函数和Dispose的使用区别

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

weixin_30337251的博客 243

Unity类银河恶魔城学习记录1-10 PlayerWallJump源代码 P37

Alex教程每一P的教程原代码加上我自己的理解初步理解写的注释,可供学习Alex教程的人参考

Homura_的博客 1382

关于Dispose()的问题

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

Eric的博客 2256

芯片散热技术突破:多尺度结构与VC集成方案解析

在半导体技术快速发展的背景下,芯片散热成为制约性能提升的关键瓶颈。传统散热技术如风冷和水冷已接近物理极限,而两相浸没式液冷技术凭借其超高传热系数成为新的解决方案。通过多尺度表面结构设计与真空腔均热板(Vapor Chamber)的集成创新,可以显著提升沸腾性能,降低沸腾起始温差(ONB)并突破临界热流密度(CHF)限制。这种技术在数据中心、高性能计算(HPC)和边缘计算等高热流密度场景中具有重要应用价值,能有效提升能效比(PUE)并降低能耗。

weixin_36288992的博客 156

按照autoware.universe官方从零搭建自己的自动导航小车(三)(续)

本文介绍了在Autoware框架下完善自定义传感器套件描述包的详细过程。主要内容包括:1)创建传感器描述包tinyplc_sensor_kit_description,包含YAML标定文件和URDF模型;2)配置传感器与车辆基座的相对位姿,实现sensor_kit.xacro和sensors.xacro宏文件;3)更新sensor_kit.launch.xml文件以集成激光雷达和GNSS/IMU驱动。通过xacro验证URDF模型正确性后,下一步计划接入Helios16激光雷达数据并在Rviz2中验证点云显

qq_45335326的博客 1273

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

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

Alex's Blog 5736

HDMI2.1接口保护指南:从浪涌损坏案例看RK3588板子的ESD设计要点

本文深入探讨了HDMI2.1接口在RK3588板子上的ESD防护设计要点,通过真实案例分析了浪涌损坏的原因及解决方案。重点介绍了TMDS信号链路的四级防护体系、TVS管选型误区以及连接器与PCB的协同设计策略,帮助工程师有效避免静电放电导致的HDMI无输出故障。

weixin_29305337的博客 449

C# Finalize和Dispose的区别

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

276

PCL Fast Global Registration 快速全局配准(源码版)

Fast Global Registration(FGR)是一种经典的点云粗配准算法,已集成到Open3D和CloudCompare等软件中。本文介绍了该算法的源码实现及优化方法,包括如何通过修改源码直接读取点云进行配准,而不依赖文件中读取特征描述子。文章还提供了关键参数设置(如最大迭代次数、匹配距离等)。算法实现简单高效,未来计划发布基于纯PCL的版本。源码和论文链接已附上,供开发者参考。

点云侠的博客 383

【深度学习新浪潮】什么是system 1和system 2?

System 1(快速生成)指大模型直接基于输入生成响应,无需显式中间推理步骤。例如,GPT-4等模型在默认状态下通过Transformer直接输出结果,擅长快速回答简单问题或生成连贯文本,但在复杂逻辑任务中可能出错。这类模型的内部计算以向量形式隐式进行,难以处理符号推理等需要离散决策的任务。System 2(慢速推理)指模型通过生成中间token(如思维链、分步推导)或多次调用LLM进行复杂推理。

专注:太空算力、AI infra、异构调度、大模型成本工程 932

C# Finalize 与 Dispose

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

weixin_33949359的博客 371

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

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

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

weixin_43385465的博客 1128

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

浅谈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

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

上一篇: 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、付费专栏及课程。

余额充值