C#之构造函数与析构函数

一．构造函数与析构函数的原理

　　做为比C更先进的语言，C#提供了更好的机制来加强程序的安全性。

　　C#编译器具备严格的类型安全检查功能，它几乎能找出程序中全部的语法问题，这的确帮了程序员的大忙。

　　可是程序经过了编译检查并不表示错误已经不存在了，

　　在“错误”的你们庭里，“语法错误”的地位只能算是冰山一角。级别高的错误一般隐藏得很深，不容易发现。

　　根据经验，很多难以察觉的程序错误是因为变量没有被正确初始化或清除形成的，

　　而初始化和清除工做很容易被人遗忘。

　　微软利用面向对象的概念在设计C#语言时充分考虑了这个问题并很好地予以解决：

　　把对象的初始化工做放在构造函数中，把清除工做放在析构函数中。当对象被建立时，构造函数被自动执行。

　　当对象消亡时，析构函数被自动执行。这样就不用担忧忘记对象的初始化和清除工做。

　　二．构造函数在C#中的运用

　　构造函数的名字不能随便起，必须让编译器认得出才能够被自动执行。

　　它的命名方法既简单又合理：让构造函数与类同名。

　　除了名字外，构造函数的另外一个特别之处是没有返回值类型，这与返回值类型为void的函数不一样。

　　若是它有返回值类型，那么编译器将不知所措。

　　在你能够访问一个类的方法、属性或任何其它东西以前， 第一条执行的语句是包含有相应类的构造函数。

　　甚至你本身不写一个构造函数，也会有一个缺省构造函数提供给你。

class TestClass

{

　public TestClass(): base() {} // 由CLR提供

}  

　　下面列举了几种类型的构造函数

　　1）缺省构造函数

class TestClass

{

　public TestClass(): base() {} 

} 

　　上面已介绍，它由系统（CLR）提供。

　　2）实例构造函数

　　实例构造函数是实现对类中实例进行初始化的方法成员。如：

using System;

class Point

{

　public double x, y;

　public Point() 

　{

　　this.x = 0;

　　this.y = 0;

　}

　public Point(double x, double y)

　{

　　this.x = x;

　　this.y = y;

　}

　…

}

class Test

{

　static void Main() 

　{                          

　　Point a = new Point();

　　Point b = new Point(3, 4); // 用构造函数初始化对象

　　…

　}

} 

　　声明了一个类Point，它提供了两个构造函数。它们是重载的。

　　一个是没有参数的Point构造函数和一个是有两个double参数的Point构造函数。

　　若是类中没有提供这些构造函数，那么会CLR会自动提供一个缺省构造函数的。

　　但一旦类中提供了自定义的构造函数，如Point()和Point(double x, double y)，

　　则缺省构造函数将不会被提供，这一点要注意。

　　3） 静态构造函数

　　静态构造函数是实现对一个类进行初始化的方法成员。它通常用于对静态数据的初始化。

　　静态构造函数不能有参数，不能有修饰符并且不能被调用，当类被加载时，类的静态构造函数自动被调用。

　　如：

using System.Data;

class Employee

{

　private static DataSet ds;

　static Employee()

　{

　　ds = new DataSet(...);

　}

　...

} 

　　声明了一个有静态构造函数的类Employee。

　　注意静态构造函数只能对静态数据成员进行初始化，而不能对非静态数据成员进行初始化。

　　可是，非静态构造函数既能够对静态数据成员赋值，也能够对非静态数据成员进行初始化。

　　若是类仅包含静态成员，你能够建立一个private的构造函数：private TestClass() {…}，

　　可是private意味着从类的外面不可能访问该构造函数。

　　因此，它不能被调用，且没有对象能够被该类定义实例化。

　　以上是几种类型构造函数的简单运用，

　　下面将重点介绍一下在类的层次结构中（即继承结构中）基类和派生类的构造函数的使用方式。

　　派生类对象的初始化由基类和派生类共同完成：

　　基类的成员由基类的构造函数初始化，派生类的成员由派生类的构造函数初始化。

　　当建立派生类的对象时，系统将会调用基类的构造函数和派生类的构造函数，

　　构 造函数的执行次序是：先执行基类的构造函数，再执行派生类的构造函数。

　　若是派生类又有对象成员，则，先执行基类的构造函数，再执行成员对象类的构造函数，

　　最后执行派生类的构造函数。

　　至于执行基类的什么构造函数，缺省状况下是执行基类的无参构造函数，

　　若是要执行基类的有参构造函数，则必须在派生类构造函数的成员初始化表中指出。

　　如：

class A

{ private int x;

　public A( ) { x = 0; }

　public A( int i ) { x = i; }

};

class B : A

{ private int y;

　public B( ) { y = 0; }

　public B( int i ) { y = i; }

　public B( int i, int j ):A(i) { y = j; }

};

B b1 = new B(); //执行基类A的构造函数A()，再执行派生类的构造函数B()

B b2 = new B(1); //执行基类A的构造函数A()，再执行派生类的构造函数B(int)

B b3 = new B(0,1); //执行执行基类A的构造函数A(int) ，再执行派生类的  

　　构造函数B(int,int) 

　　在这里构造函数的执行次序是必定要分析清楚的。

　　另外，若是基类A中没有提供无参构造函数public A( ) { x = 0; }，

　　则在派生类的全部构造函数成员初始化表中必须指出基类A的有参构造函数A(i)，

　　以下所示：

class A

{ private int x;

　public A( int i ) { x = i; }

};

class B : A

{ private int y;

　public B():A(i) { y = 0; }

　public B(int i):A(i) { y = i; }

　public B(int i, int j):A(i) { y = j; }

}; 

　　三．析构函数和垃圾回收器在C#中的运用

　　析构函数是实现销毁一个类的实例的方法成员。

　　析构函数不能有参数，不能任何修饰符并且不能被调用。

　　因为析构函数的目的与构造函数的相反，就加前缀‘~’以示区别。

　　虽然C#（更确切的说是CLR）提供了一种新的内存管理机制---自动内存管理机制（Automatic memory management），

　　资源的释放是能够经过“垃圾回收器” 自动完成的，通常不须要用户干预，

　　但在有些特殊状况下仍是须要用到析构函数的，如在C#中非托管资源的释放。

　　资源的释放通常是经过"垃圾回收器"自动完成的,但具体来讲,仍有些须要注意的地方：

　　1. 值类型和引用类型的引用实际上是不须要什么"垃圾回收器"来释放内存的,

　　由于当它们出了做用域后会自动释放所占内存，由于它们都保存在栈(Stack)中;

　　2. 只有引用类型的引用所指向的对象实例才保存在堆(Heap)中,而堆由于是一个自由存储空间,

　　因此它并无像"栈"那样有生存期("栈"的元素弹出后就表明生存期结束,也就表明释放了内存),

　　而且要注意的是,"垃圾回收器"只对这块区域起做用;

　　然而,有些状况下，当须要释放非托管资源时,就必须经过写代码的方式来解决。

　　一般是使用析构函数释放非托管资源，将用户本身编写的释放非托管资源的代码段放在析构函数中便可。

　　须要注意的是,若是一个类中没有使用到非托管资源,那么必定不要定义析构函数,

　　这是由于对象执行了析构函数,那么"垃圾回收器"在释放托管资源以前要先调用析构函数，

　　而后第二次才真正释放托管资源，这样一来，两次删除动做的花销比一次大多的。

　　下面使用一段代码来示析构函数是如何使用的：

public class ResourceHolder 

{

…

~ResourceHolder()

{

　// 这里是清理非托管资源的用户代码段

}

} 

　　四．小结

　　构造函数与析构函数虽然是一个类中形式上较简单的函数，

　　但它们的使用决非看上去那么简单，

　　所以灵活而正确的使用构造函数与析构函数可以帮你更好的理解CLR的内存管理机制，

　　以及更好的管理系统中的资源。