详解C#中不同类的类型

类类型是由字段数据（成员变量）和操作字段数据的成员（属性、方法、构造函数、事件等）所构成的自定义类型。其中字段数据表示类实例（对象）的状态。

在C#中，类使用class关键字定义，例如：

public class Car{     
//Car的字段（状态）     
 private int _speed;     
 private string _name;   //Car操作字段的属性     
 public int Speed     
 {          
set {this._speed=value;}         
 get{return this._speed;}     
  }     
 public string Name     
 {        
  set { this._name=value;}        
  get{return this._name;}     
  }    
  //显式定义默认构造函数     
 public Car(){}    //自定义构造函数     
 public Car(string name,int speed)    
  {       
   this._name=name;       
   this._speed=speed;   
   }     
 //Car的功能（方法）    
   public void ShowState()    
   {Console.WriteLine("Car {0} is going {1} MPH", this._name,this. _speed);}} 

另：类的字段很少被定义为公开的，为了保护状态数据的完整性，最好把字段数据定义为私有（或者受保护的），然后通过属性对外提供受控制的访问。

使用new关键字来分配对象

对象必须使用了new关键字来分配到内存，如果不是用new，而随后尝试使用类变量的话，会收到一个编译错误。

public static void Main(string[] args){    
  //错误，忘记使用new     
 Car c;    
  c.Name="Bruce";} 

正确的例子：

public static void Main(string[] args)        {                       
   //创建Car对象。         
      Car c；//声明了指向尚未创建的Car对象的引用。        
c=new Car("bruce wong",150);//通过new把有效的引用赋给对象，这引用才会指向内存有效的对象。        
      c.ShowState();           
   Console.ReadKey(true);       
   } 

类构造函数

作用：给对象的字段（状态）赋值，它允许在创建对象时创建其状态。

构造函数是类特殊的方法，在使用new关键字创建对象时被间接调用。

注意：构造函数没有返回值（即使是void），它的名字总是和类的名字一样。

默认构造函数

C#提供一个默认的构造函数，需要时你可以重新定义，默认构造函数不接受任何参数。它把新的对象分配到内存和确保所有的字段都被设置为正确的默认值。当你对这些默认值不满意，你可以重新定义默认构造函数。如：

public Car(){     
 this._name="My Car";     
 this._speed=100;} 

那么每次使用new Car()都会创建状态_name="My Car" _speed=100的Car对象。

自定义构造函数

作用：在创建对象时可以直接初始化对象的状态。

public Car(string name,int speed)    
  {        this._name=name;       
   this._speed=speed;    
  } 

注意：一旦定义了自定义函数，自带的默认构造函数就自动从类移除（不能用默认构造函数创建对象了）。如果希望使用默认构造函数创建类对象，就必须显式定义默认构造函数。

this关键字的作用

一、提供对当前实例的访问。

可以解决传入参数的名字与类型字段名字相同时产生的作用域歧义。例如：

class Car{   
 private string name;  
  public void SetName(string name)  
 { this.name=name;}} 

表示把参数name的值赋给本对象（实例）的字段name，this表示本实例。

二、参数传递。使用this进行串联构造函数调用

使用一项名为构造函数链的技术来设计类。当类定义个了多个构造函数时，这个设计模式就会很有用。

由于构造函数通常会检验传入的参数来强制各种业务规则，所以在类的构造函数集合中经常会找到冗余的验证逻辑。

class Car{    
 public int Speed{get;set;}   
  public string Name{get;set;}   
  public Car(){}    
 public Car(int speed){if(speed>150){speed=150;}this.Speed=speed;}    
 public Car(string name){this.Name=name;}    
 public Car(int speed,string name){if(speed>150){speed=150;}this.Speed=speed;this.Name=name;}} 

串联构造函数方案：让一个接受最多参数个数的构造函数做“主构造函数”，并实现必须的验证逻辑。其余的构造函数使用this关键字把参数转给主构造函数，并提供其他必需的参数。这样，我们只关心主构造函数的逻辑，而其他构造函数体基本是空的了。

class Car{   
  public int Speed{get;set;}   
  public string Name{get;set;}   
  public Car(){}   
  public Car(int speed):this(speed,""){}   
  public Car(string name):this(0,name){}   // 主构造函数   public Car(int speed,string name)  
  {      
   if(speed>150) {speed=150;}       this.Speed=speed;        
 this.Name=name;    
 }} 

使用this关键字串联构造函数方式可以简化编程任务，类定义更加容易维护、更更加简明。但它不是强制使用的。

串联构造函数的执行顺序：

1、调用构造函数把调用者提供的参数值转发给主构造函数，并提供其他必须的初始化参数值。

2、执行主构造函数。

3、执行调用构造函数体的逻辑。

三、自定义索引器

class CarCollection:IEnumerable{     
private ArrayList arCar=new ArrayList();    
 public Car this[int index]   
  {       
 get{ return (Car)arCar[index];}      
  set{arCar.Insert(index,value);}   
  }   //...} 

static关键字

C#类（或者结构）可以使用static关键字来定义许多静态成员。这些静态成员只能从类级别而不能从对象级别上调用（调用静态成员时不需要创建实例对象）。

例如：

//错误，WriteLine是静态成员，是类级别的方法。Console c=new Console();c.WriteLine("Bruce Wong");//正确！WriteLine是类级别的方法Console.WriteLine("Bruce Wong");
注意：

一、静态成员只能操作静态数据或调用类的静态成员。而非静态成员可以操作实例数据与静态数据（成员），因为静态成员对类的所有实例都是可用的。

二、CLR把静态数据分配到内存只进行一次，改变静态数据将影响此类的所有实例。

定义静态构造函数

构造函数用于在创建类对象时设置类对象的数据值。如果使用实例级别的构造函数给静态数据赋值，你会惊奇的发现每次新建类对象时静态数据的只都会被重置。所以我们要初始化静态数据最好使用静态构造函数。

静态构造函数是特殊的构造函数，它非常适用于初始化在编译时未知的静态数据的值：

一、一个类（结构）只能定义一个静态构造函数。

二、静态构造函数不允许访问修饰符并且不能接受任何参数。

三、无论创建多少个类实例，静态函数知执行一次。

四、CLR创建类实例或首次调用类静态成员前，CLR会调用静态构造函数。

五、静态构造函数先于实例级别的其他构造函数执行。

静态类：一个类被定义为静态的（使用static关键字修饰），就不能使用new关键字来创建类实例，静态类只能包含用static标记的静态类成员或字段。

PS:项目的应用程序对象（如定义Main()方法的类）通常定义为静态类，以此来确保只包含静态成员且不能被直接创建。如：

static class Program{    
   static void Main(string[] args)     
 {       
   //...    
  }}