1．类的声明
       类是用户自定义的引用类型
class Pair
{
    public int X, Y; //公有变量名单词的首字母大写（PascalCase规则）
}
class Pair
{
    private int x, y; //非公有变量名第一个单词的首字母小写（camelCase规则）
}
class Pair
{
    int x, y; //缺省的访问修饰符是private
};//可以有结尾分号
你可以使用关键字class来声明类这一用户自定义的引用类型。类的语法和结构的非常类似。它提供函数、字段、构造函数、操作符和访问控制。类成员的缺省访问权限是private。当你定义类的成员名时，不要忘了对公有成员使用PascalCase规则，而对非公有成员使用camelCase规则。
类的声明中虽然可以使用结尾分号，但建议你不要使用，这只不过是为了照顾C++程序员的习惯。
2.对象的产生
        一个类的局部变量存在于栈（stack）中
       不是被预先赋值的
       可以被初始化为null或调用构造函数进行初始化
(下面的例子中Pair类的声明请看前面，右边显示的是内存中的情况，@表示指向)
  栈          堆
static void Main()                
{
    Pair p;                          p ?
}
static void Main()              
{
    Pair p = null;                 p null
}
static void Main()
{
    Pair p = new Pair();         p @               0  .X
}                                                      0  .Y
 
虽然类的声明和结构的声明非常类似，但类与结构是两个不同的类型。结构是值类型，而类是引用类型。无论类的实例多大，类的局部变量只是这个类实例的一个引用。
上面例子中的最上面的那段程序定义了一个Pair类的局部变量p。不管Pair类包含什么成员，p只是存在存在于栈中的一个引用。因为p没有被初始化，所以这个引用没有被赋值，p也就不能被使用。
上面例子中的中间的那段程序定义了一个Pair类的局部变量p。p被初始化为null，所以p没有指向任何对象。p已经被赋值，所以p也就能被使用。
上面例子中的最下面的那段程序定义了一个Pair类的局部变量p。由new新生成一Pair类对象，这个新产生的对象产生在堆(heap)中，然后p通过赋值指向这一堆中的对象，而p是被定义为存在于栈中。p已经被赋值，所以p也就能被使用。
new对于类来说是产生一堆中的对象，而对于结构来说是在栈中产生一个值，这可能需要一段时间的适应。
3.对象的构造函数
       类的构造函数!＝结构的构造函数
       编译器声明缺省构造函数
       你可以声明缺省构造函数
       如果你声明构造函数，那么编译器不会声明构造函数
class Pair
{
}
//编译器声明一缺省构造函数
class Pair
{
    public Pair()
    { ... }
}
//正确，可以自己声明缺省构造函数
class Pair
{
    public Pair(int x, int y)
    { ... }
}
//正确，但编译器声明的缺省构造函数不存在，不存在缺省构造函数
类的缺省构造函数的规则与结构的缺省构造函数的规则是不同的。你可以回忆一下，结构总有一编译器声明的公有的缺省构造函数。不管你有没有声明构造函数，编译器声明的公有的缺省构造函数总是存在的。所以你不能定义缺省构造函数，这样会出现两个缺省构造函数，这是不允许的。
但这只适合于结构，对于类是不适用的。如果你没有声明任何构造函数，那编译器会产生缺省构造函数。但如果你定义了一个构造函数，那么编译器就不会产生缺省构造函数。这也意味着如果你声明了一个或多个构造函数，那么你能拥有缺省构造函数的唯一途径是你声明的构造函数中必须有一个是缺省构造函数。这样的结果是如果你只定义了一非缺省构造函数，而你又要使用缺省构造函数的话，那你只有重载这个构造函数。如果你必须手动初始化类中的每一个字段（就像在结构中一样），那将是非常麻烦的。但幸运的是你可以不必这么做，你将在下面看到这一点。
4.:this(…)
        一个构造函数可以调用另一构造函数
sealed class Pair
{
    public Pair(int x, int y)
        : this(x, y, Colour.Red)
    {
    }
 
    public Pair(int x, int y, Colour c)
    {
        ...
    } 
    ...
    private int x, y;
    private Colour c;
}
5.实例字段
        实例字段...
        在所有的构造函数中被初始化为缺省值（0/false/null）
        可以在一构造函数中显式初始化
        可以在它们声明时初始化
sealed class Pair
{
    public Pair(int x, int y)
    {
        this.x = x;
        y = y;
    } 
    ...
    private int x;
    private int y = 42;
}
回忆一下：在结构的自定义构造函数必须显式初始化类中的所有实例字段。结构的实例字段只能在构造函数中进行初始化，而不能使用赋值的方法。
而类则比结构方便的多。
类中的所有字段都缺省初始化为缺省值。
在类的构造函数中，你可以在字段声明时进行初始化。
在上面的例子中，构造函数的参数y用字段y来赋值。编译器通过的原因是字段y已经被赋初值。其实，如果没有对字段y进行初始化，编译器仍然会通过，困为字段y已有缺省值0，所以在构造函数中没有显式初始化字段y是不会发生错误的。
6.静态字段
       静态字段...
       被缺省初始化为0/false/null
       可以在声明时初始化
       只能通过类名访问
class Pair
{
    public Pair(int x, int y)
    {
        ...
    }
    private static Pair origin = new Pair(0,0);
    ...
private int x, y;
｝
Pair p = new Pair();
...
Method(p.origin);    //错误，只能通过类名访问
Method(Pair.origin); //正确
由static修饰符声明的字段称为静态变量。当类的声明装载时，静态变量就开始存在，直到程序结束时才消失。
静态变量的初值：
         整型变量为0（包括枚举）
         实型变量为0.0
         bool型变量为false
         引用型变量为null
7.只读字段
       只读字段...
       不能被赋值
        不能被用作ref/out 型参数
class Pair
{
    public static readonly Pair Origin = new Pair(0,0);
    public Pair(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
    public void Reset()
    {
        x = 0; //错误
        Origin.x = 0; //错误
    }
    private readonly int x, y;
}
8.常量字段
        常量字段...
       隐含为static
       必须在声明时初始化
       必须被初始化为编译时常量值
       只有简单类型，枚举，字符串才可以是常量
class Pair
{
    public Pair(int x, int y)
    {
        // ???
    }
    ...
    private const int x = 0, y = 0;
}
在C#中，常量字段隐含为static，但你不能显式声明一个常量字段是static：
                     static const int x = 0;//错误
常量必须被初始化，并且只能在声明时初始化：
                     const int x;//错误
常量必须被初始化为编译时常量值：
                     const int x = Method();//错误
只有简单类型，枚举，字符串才能被声明为常量：
                     const Pair p = new Pair();//错误
9.静态构造函数
       静态构造函数初始化类
       可以初始化static 字段而不是const 字段
       当类被装载时由.net调用
       不能被调用：没有参数，没有访问修饰符
class Pair
{
   public static readonly Pair Origin;
   public Pair(int x, int y)
   {
        this.x = x;
        this.y = y;
   }
   static Pair()
   {
        Origin = new Pair(0, 0);
   }
   private int x, y;
}
静态构造函数只能由.net调用，而不能由程序员调用。这保证它会被调用，只被调用一次，并且在恰当的时候被调用（在任何类或类被使用前）。因为程序员不能调用静态构造函数，所以静态构造函数没有参数。出于同样的原因，静态构造函数不能有访问修饰符。
静态构造函数不能被用来初始化常量字段，即使常量字段隐式为静态的。因为前面说过，常量字段必须被初始化，而且只能在它声明的时候初始化。