五、C# 类

面向对象编程

类是面向对象编程的3个主要特征---封装、继承和多态性---的基础。

 

封装允许隐藏细节。

 

继承

继承关系至少涉及两个类，其中一个类（基类）是另一个类的更泛化的版本。

 

为了从一个类型派生或者说从它继承，需要对那个基类型进行特化，这意味着要对基类型进行自定义，针对特定的目的调整它。

继承最关键的一点在于，所有派生类型都继承了基类型的成员。在派生类型中，

基成员的实现通常可以改动，但是不管是否修改基成员，派生类型中除了：有派生类型包含的那些

成员外，还可以包含基类型的成员。

 

 

多态性意味着一个方法或类型可以具有多种形式的实现。

 

对象和类

 

类相当于一个模块，对象是这个类的一个实例，相当于这个用这个模块创造一个产品。

使用类创建一个新对象的过程称为实例化。

 

实例化一个对象，需要使用new运算符指示“运行时”为一个对象分配内存，实例化对象，

并返回对实例的一个引用（整型数组）。

 

在堆中申请的内存（如new 申请分配)，由垃圾回收器自动回收。（运行时，会在最后一次

访问对象之后，并在应用程序结束之前的某个时候，自动地回收内在。）

 

实例字段（成员变量）

可以在声明时设置字段的初始值。

 

实例方法（成员方法）

可以访问对象上的字段。

 

this关键字

在类的实例成员内部可以获取当前对象的一个引用。

this在概念上是传给每个实例方法的一个隐式参数，它返回对象本身的一个实例。

 

 

访问修饰符

 

在面向对象编程中，封闭不仅仅是将数据和行为组合到一起，它同时还意味着隐藏一个类中的数据，

使一个类的内部工作机制是最小程度地对类的外部公共，这减少了调用者对数据进行不恰当修改的几率。

 

访问修饰符是用途是提供封装。

标识了所修饰成员的封装级别。

public、private、protected、internal和protected internal 总共5个。

注：如果不为类成员添加访问修饰符，那么默认使用的是private。

 

属性

为了实现某些字段从外部只读等的效果。一般采取的办法是将字段标记为私有，然后提供取值

和赋值方法来访问和修改数据，只读时，只提供取值方法，不提供赋值方法。

C#提供了显式的语法支持：属性。

 class Program
     {
         static void Main(string[] args)
         {
             string firstName = "aaaaa", middleName = "bbbbbbbbb", lastName = "cccccccc";
             string fullName;
             Employee e = new Employee();
             e.FirstName = firstName;
             e.LastName = lastName;
             Console.WriteLine(e.FirstName + "." + e.LastName);
         }
     }
    public class Employee
     {
         private string _FirstName;
         public string FirstName
         {
             set
             {
                 _FirstName = value;
             }
             get
             {
                 return _FirstName;
             }
         }
         private string _LastName;
         public string LastName
         {
             set
             {
                 _LastName = value;
             }
             get
             {
                 return _LastName;
             }
         }

     }

 

属性的关键点在于，它提供了从编程角度看类似于字段的API，但是事实上，并不存在这样的字段。

在大括号中，要添加具体的属性实现代码。两个可选的部分构成了一个属性的实现。

set get

自动实现的属性 C#3.0

声明一个属性时，不实际地实现任何取值或同仁方法，也不声明任何支持字段

   public class Employee
     {

         public string Title { set; get; }
         public Employee Manager { set; get; }

     }

使用属性的好处在于，如果需要添加一个额外代码：比如在set方法中添加验证，数据的合法性。

虽然属性的声明发生了变化，但是调用属性的代码不进行任何更改。

 

建议使用属性，来调用字段，不建议直接调用字段。

 

实现只读和只写属性：

通过移除某个属性的取值方法或赋值方法部分，可以改变属性的可访问性。

 

为取值方法和赋值方法指定访问修饰符

 

 public class Employee
     {
         private string _FirstName;
         public string FirstName
         {
             private set
             {
                 _FirstName = value;
             }
             get
             {
                 return _FirstName;
             }
         }
         private string _LastName;
         public string LastName
         {
             private set
             {
                 _LastName = value;
             }
             get
             {
                 return _LastName;
             }
         }
         public string Title { private set; get; }
         public Employee Manager { private set; get; }

     }

注：这个访问修饰限制性必须比应用于整个属性的访问修饰符更为严格。

 

属性的赋值和取值，可以是任何操作，get 必须返回一个数据类型一致的数据。

 

属性和方法调用不允许作为ref或out参数值使用

 

原因：ref和out需要将内存地址传给目标方法，但是，由于属性可能是没有支持字段的虚字段，

也有可能是只读/只写的，因此不可能传递其基础存储的地址，不过可以通过中间变量来实现。

 

 如：

          public string Title
         {
             private set;
             get
             {
                 return _FirstName + "." + _LastName;
             }
         }    

 

构造器（构造函数）

为了定义构造器，要创建一个返回类型的方法，而且方法名必须完全和类名相同。

构造器是用来创建对象实例的方法。

 

new运算符返回的是被实例佛手对象的类型。

注：如果一个字段在声明时赋了初始值，且在构造函数中也赋予了初始值，那么最终生效的是构造器

内部的赋值，它会覆盖声明时的任何赋值。

所以应该避免在两个地方同时赋值。

 

C#编译器会自动添加一个默认构造器（无参数），且如果自定义了构造函数，不再自动添加默认构造函数。

 

C#3.0对象初始化器

在调用的时候使用

 class Program
     {
         static void Main(string[] args)
         {
             string firstName = "aaaaa", middleName = "bbbbbbbbb", lastName = "cccccccc";
             string fullName;
             Employee e = new Employee(firstName, lastName) { Title = "MyTitle", Content="Content" };

             Console.WriteLine(e.Title + ":" + e.Content + "" + ":" + e.FirstName + "." + e.LastName);
             Console.ReadLine();

         }

     }
     public class Employee
     {
         public Employee(string firstName, string lastName)
         {

             FirstName = firstName;
             LastName = lastName;
         }
         private string _FirstName;
         public string FirstName
         {
             private set
             {
                 _FirstName = value;
             }
             get
             {
                 return _FirstName;
             }
         }
         private string _LastName;
         public string LastName
         {
             private set
             {
                 _LastName = value;
             }
             get
             {
                 return _LastName;
             }
         }
         public string Title
         {
             set;
             get;

         }
         public string Content
         {
             set;
             get;

         }
         public Employee Manager { set; get; }

     }

 

终结器

终结器是在一个对象最后一次活动之后，并在程序终止之前执行，具体地说，垃圾回收器会在

一次垃圾回收过程中识别出带有终结器的对象。之后，它并不是立即回收这些对象，而是将它们添加

到一个终结列中。一个独立的线程遍历终结队列中的每一个对象，调用它们的终结器，然后把它们从队列

中删除，使它们再次可供垃圾回收器调用。

 

注：构造器可重载

 

使用this调用另一个构造器

这称为构造器链，它是用构造器初始化器来实现的。构造器初始化器会在执行当前构造器的实现之前

判断要调用另外哪一具构造器，并进行调用。

　　

         public Employee(string firstName, string lastName)
         {

             FirstName = firstName;
             LastName = lastName;
         }
         public Employee(string Title, string firstName, string lastName)
             : this(firstName, lastName)
         {
             this.Title = Title;
         }

 

注：可写一个函数专门用来初始化，然后在构造器中调用。

 

匿名类型

在C#3.0中引入了对匿名类型的支持。它们是由器动态生成的数据，而不是通过显式的类定义来声明的。

 

var 

 

编译器遇到匿名类型的语法时，就会自动生成一个CIL类，该类具有与匿名类型声明中的命名值

和数据类型对应的属性。

 

静态成员 

 

使用static修饰

 public static int Count = 0;

 

与实例字段不同，如果不对静态字段进行初始化，静态字段将自动获得相应数据类型的默认值。

另外，一个静态字段即使没有显式地赋值，也可以被访问。

在类的外部访问静态字段时，需要使用类名。

 

注：上下文就是作用域

 

静态方法

和静态字段一样，要直接在类名之后访问静态方法。

由于静态方法不是通过一个特定的实例来引用，所以this关键字在静态方法中是无效。

所以也不能直接在静态中访问类中声明的实例成员，所有实例成员必须通过一个对象引用才能访问。

 

 

静态构造器

除了静态字段和方法，C#还支持静态构造器。静态构造器用来对类进行初始化。静态构造器不是显式调用的

，运行时会在首次访问类时自动调用静态构造器。

所谓“首次访问类”，可能是调用一个普通构造器，也可能是访问类的一个静态方法或者字段。

在构造器中的赋值会覆盖声明时的初始化值。

 

 

静态属性

 

与实例属性一样，只是是属于类的。

使用静态属性几乎肯定要比使用公共静态字段好，因为公共静态字段在任何地方都能调用，而静态

属性则至少提供了一定程度的封装。

 

 

静态类

使用static修饰

这个类不包含任何实例成员，所以创建一个实例化的类是没有意义的。

静态类的另一个特殊在于，C#编译器会自动在CIL代码中把它标记为abstract和sealed。

这会将类指定为不可扩展，换言之，不能从它派生出其他类。

 

 

 

扩展方法（必须在静态类中定义）

C#3.0

引入了扩展方法(extension method）的概念。它能为一个不同的类模拟出一个实例方法。

使静态方法的第一个参数成为要扩展的类型，并在类型名称前面附加this关键字。

   public static class DirectoryInfoExtension
           {
                 public static string Message(this Employee e, string message1, string message2)
                 {
                     return message1 + message2;
                 }
             }
            string firstName = "aaaaa", middleName = "bbbbbbbbb", lastName = "cccccccc";
             string fullName;
             Employee e = new Employee();

             Console.WriteLine(e.Title + ":" + e.Content + "" + ":" + e.FirstName + "." + e.LastName);

              Console.WriteLine(e.Message(firstName,lastName));
              Console.ReadLine();

C#通过这一处小小的改进，就使我们能为任何类添加实例方法，即使是那些不在同一个程序集中的类。然后，根据最终生成的CIL代码，你会发现扩展方法和一个普通的静态方法的代码是完全一样的。

 

扩展方法的要求如下：

1、第一个参数是要扩展或者操作的类型，这称为"被扩展的类型"

2、为了指定扩展方法，要在扩展的类型名称前面附加this修饰符

3、要将方法作为一个扩展方法来访问，要用using指令导入扩展类型的命名空间，或者

使扩展类和调用代码在同一个命名空间中。

注：如果扩展方法的签名已经和扩展类型中的一个签名匹配，扩展方法永远不会得到调用，除非是作为

一个普通的静态方法。

 

应该尽量少用扩展方法，而使用继承来扩展。

 

封装数据 

两个特殊的字段修饰符，const、readonly

1、const

和const局部变量一样，const字段（常量字段）包含的是在编译时确定的一个值，它不可以在运行时改变。

 

常量字段自动成员静态字段，因为不需要为每个对象实例都生成一个新的字段实例。

但是，假如将一个常量字段显式地声明为static，会造成一个编译错误。

 

public 常量应该是恒定值，否则，如果对它进行了修改，那么在使用它的程序集中，不一定能反映出

这个修饰。需要重新编译。

将来可能改变的值应该指定为readonly，不要指定为常量。

 

2、readonly

和const不同，readonly修饰符只能用于字段(不能用于局部变量)，它指出字段值只能从构造器

中更改，或者直接在声明时指定。

每个实例的readonly字段都可以是不同的，除此之外,readonly字段即可以是实例字段，也可以是静态

字段。另一个关键区别在于，可以在执行时为readonly字段赋值，而非只能在编译时赋值。

 

嵌套类

 

在类中除了定义方法和字段，还可以定义另一个类。这样的类称为嵌套类

嵌套类中的this成员指的是嵌套类的一个实例，而不是包容类。

嵌套类的另一个有趣的特点是它能够访问包容类的任何成员，其中包括私有成员。但反之则不然，包容类不能访问嵌套类的私有成员。

 

分部类

C#2.0新增的另一个语言特性是分部类(partial class)。

使用partial修饰

分部类是一个类的多个部分，这些部分可以合并成一个完整的类。

使用上下文关键字partial来声明一个分部类。

 

可以放在不同的文件当中。

分部类不允许对编译好的类（其他程序集中的类）进行扩展。只能利用分部类在同一个程序集

中将一个类的实现分解到多个文件中。

 

分部方法

C#3.0

使用partial修饰

分部方法只能存在于分部类中。另外和分部类相似，其主旨是为代码的生成提供方便。

分部方法允许声明一个方法而不需要一个实现。

然后，如果包含了可选的实现，这个实现就可以放到某个姊妹分部类定义中。

也就是声明和定义分别放在分部类的不同地方。

 

注：分部方法必须返回void，如果不是返回null，同时没有提供实现，那么调用一个未实现的方法。

返回什么才合理呢。所以只允许方法返回void，out参数在分部方法中是不允许的。如果

需要一个返回值，可以使用ref参数。

 

总之，分部方法使生成的代码能调用并非一要实现的方法。