析构函数的主体部分如何写

Question

我知道析构函数是为了帮助系统及时回收资源，在调用GC.Collect()命令或用using（）后马上执行对象的销毁与回收工作。析构函数的写法是
~<类名>
｛
 //析构函数的主体
 ｝
我的问题是这个析构函数的主体一般怎么来写呢？

Answer 1

public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
//實現接口IDisposable
protected virtual void Dispose(bool disposing)
{
if (!isDisposed)
{
if (disposing)
{
// Cleanup managed objects by calling their
// Dispose() methods.
}
// Cleanup unmanaged objects
}
isDisposed = true;
}
~TypeName()
{
Dispose (false);
}

Answer 2

cn.close()
da.dispose()
cm.dispose()------------前提是，存在以上对象．
其实现在之语言而言，基本不需要手动写了．系统会自动处理地．

Answer 3

是的，有数据库存取和文件存取这样的非托管资源，
再问一下cjnet:
// Cleanup managed objects by calling their
// Dispose() methods.
如何cleanup managed objects？这里应该只需要调用dispose方法
// Cleanup unmanaged objects
如何cleanup unmanaged objects？这里也是调用dispose方法吗？

Answer 4

managed objects没有Dispose方法也不需要...

Answer 5

瞎说。不要把它跟Dispose搞混了。

Answer 6

不要滥用cleanup这个词。dispose跟释放对象没有关系。照你的思路，那么每当使用完一个对象都应该执行一次 GC.Collect() 过程了，那么设计 GC 这种延迟回收内存的机制不就自相矛盾了嘛？学c++走火入魔了吧！套用c++的析构概念，你就无法更好地理解.net。

Answer 7

dispose根本不是cleanup对象，所以你绕不出来了，因为纠缠cleanup这个词。根本不释放对象，而只是执行dispose方法而已。当执行了dispose，如果是使用“弱引用”变量来关联到对象的，会发现对象还是存在一段时间的，直到GC真正释放它。

Answer 8

析构函数当应用程序封装窗口、文件和网络连接这类非托管资源时，应当使用析构函数释放这些资源。  
析构函数用于析构类的实例。 
析构函数本质上是一个方法
protected void Finalize()
        {
        }
析构函数也可以被显式调用

Answer 9

通常不需要写，除非你明确地知道如果不写就会造成什么内存泄漏问题（例如你调用了c的dll之类的，并且必须再此时去通知它，例如你的代码本身就是一个传递给它的回调）。
根本不需要写。所以也不用考虑“主体一般怎么来写”。真因为此，才有了SuppressFinalize这个方法告诉GC根本不需要调用析构函数。许多高效的托管代码都调用这个，因为析构根本什么都不做，何必要调用一次？

Answer 10

不要看一点c++的析构函数文档就套用到.net托管代码上面来。统计对象的大小、释放对象所占用的内存，根本不用你去些什么析构函数。既然个根本不用套用c++的析构函数的概念，你还想知道什么“主体”呢？

Answer 11

析构练习：
using System;
class StaticConstructor:IDisposable      //继承IDisposable接口
{
     private bool disposed = false;
     public void Dispose()    //实现IDisposable接口中的Dispose方法
     {
          Dispose(true);
     }
     public void Close()       //Close方法
     {
          Dispose(true);
     }
     ~StaticConstructor()      //析构函数
     {
          Dispose(false);
     }
    
     public void Dispose(bool disposing)
     {
          if(!this.disposed)
          {
               if(disposing)
               {
                    Console.WriteLine("调用引用类的Dispose（）方法");       //Dispose方法先调用引用类的Dispose（）方法释放它们的托管资源
               }
               Console.WriteLine("调用本身类的Dispose（）方法");         
               disposed = true;
               if(disposing)
               {
                    GC.SuppressFinalize(this);          //Dispose方法阻止finalize方法
               }
          }
     }
}
class Test
{
     public static void Main()
     {
          //第一种方式：直接调用
          //StaticConstructor sc = new StaticConstructor();
          //sc.Dispose();
          //sc.Close();
         
          //第二种方式：放在try-finally语句块中
//          StaticConstructor sc = new StaticConstructor();
//          try
//          {
//               Console.WriteLine("用sc去做一些事情");
//          }
//          finally
//          {
//               sc.Dispose();
//          }         
         
          //使用using语句
          using(StaticConstructor sc = new StaticConstructor())
          {
               Console.WriteLine("用sc去做一些事情");
          }
     }
}

Answer 12

我觉得SP1234说的很有道理，只有非托管代码才需要析构函数，.NET貌似有自己的垃圾回收机制不需要你操心，是这样吧SP1234?

Answer 13

理解完全错误...非托管代码和非托管资源是两码事，托管代码也能访问非托管资源，托管代码用的不好也会造成内存泄漏...在.NET中，析构函数只是最后一道防线...就是说析构函数并不是为了让你有了它就可以撒手不管了...相反它提醒你应该小心使用非托管资源，它只应该在程序员犯错或调用Dispose方法显式释放失败的时候起作用，以便GC不得已才去擦屁股...换句话说，析构函数只是道保险，如果你的代码够健壮就不需要它...依赖析构函数不但无益反而会造成性能问题...这和C++是本质不同的...

Answer 14

析构函数一般用写，请参见MSDN，C#析构函数：
http://msdn.microsoft.com/zh-cn/library/66x5fx1b(v=VS.100).aspx