面向对象编程
类是面向对象编程的3个主要特征---封装、继承和多态性---的基础。
封装允许隐藏细节。
继承
继承关系至少涉及两个类，其中一个类（基类）是另一个类的更泛化的版本。
为了从一个类型派生或者说从它继承，需要对那个基类型进行特化，这意味着要对基类型进行自定义，针对特定的目的调整它。
继承最关键的一点在于，所有派生类型都继承了基类型的成员。在派生类型中，
基成员的实现通常可以改动，但是不管是否修改基成员，派生类型中除了：有派生类型包含的那些
成员外，还可以包含基类型的成员。
多态性意味着一个方法或类型可以具有多种形式的实现。
对象和类
类相当于一个模块，对象是这个类的一个实例，相当于这个用这个模块创造一个产品。
使用类创建一个新对象的过程称为实例化。
实例化一个对象，需要使用new运算符指示“运行时”为一个对象分配内存，实例化对象，
并返回对实例的一个引用（整型数组）。
在堆中申请的内存（如new 申请分配)，由垃圾回收器自动回收。（运行时，会在最后一次
访问对象之后，并在应用程序结束之前的某个时候，自动地回收内在。）
实例字段（成员变量）
可以在声明时设置字段的初始值。
实例方法（成员方法）
可以访问对象上的字段。
this关键字
在类的实例成员内部可以获取当前对象的一个引用。
this在概念上是传给每个实例方法的一个隐式参数，它返回对象本身的一个实例。
访问修饰符
在面向对象编程中，封闭不仅仅是将数据和行为组合到一起，它同时还意味着隐藏一个类中的数据，
使一个类的内部工作机制是最小程度地对类的外部公共，这减少了调用者对数据进行不恰当修改的几率。
访问修饰符是用途是提供封装。
标识了所修饰成员的封装级别。
public、private、protected、internal和protected internal 总共5个。
注：如果不为类成员添加访问修饰符，那么默认使用的是private。
属性
为了实现某些字段从外部只读等的效果。一般采取的办法是将字段标记为私有，然后提供取值
和赋值方法来访问和修改数据，只读时，只提供取值方法，不提供赋值方法。
C#提供了显式的语法支持：属性。
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 string firstName = "aaaaa", middleName = "bbbbbbbbb", lastName = "cccccccc";
6 string fullName;
7 Employee e = new Employee();
8 e.FirstName = firstName;
9 e.LastName = lastName;
10 Console.WriteLine(e.FirstName + "." + e.LastName);
11 }
12 }
13 public class Employee
14 {
15 private string _FirstName;
16 public string FirstName
17 {
18 set
19 {
20 _FirstName = value;
21 }
22 get
23 {
24 return _FirstName;
25 }
26 }
27 private string _LastName;
28 public string LastName
29 {
30 set
31 {
32 _LastName = value;
33 }
34 get
35 {
36 return _LastName;
37 }
38 }
39
40 }
属性的关键点在于，它提供了从编程角度看类似于字段的API，但是事实上，并不存在这样的字段。
在大括号中，要添加具体的属性实现代码。两个可选的部分构成了一个属性的实现。
set get
自动实现的属性 C#3.0
声明一个属性时，不实际地实现任何取值或同仁方法，也不声明任何支持字段
1 public class Employee
2 {
3
4 public string Title { set; get; }
5 public Employee Manager { set; get; }
6
7 }
使用属性的好处在于，如果需要添加一个额外代码：比如在set方法中添加验证，数据的合法性。
虽然属性的声明发生了变化，但是调用属性的代码不进行任何更改。
建议使用属性，来调用字段，不建议直接调用字段。
实现只读和只写属性：
通过移除某个属性的取值方法或赋值方法部分，可以改变属性的可访问性。
为取值方法和赋值方法指定访问修饰符
1 public class Employee
2 {
3 private string _FirstName;
4 public string FirstName
5 {
6 private set
7 {
8 _FirstName = value;
9 }
10 get
11 {
12 return _FirstName;
13 }
14 }
15 private string _LastName;
16 public string LastName
17 {
18 private set
19 {
20 _LastName = value;
21 }
22 get
23 {
24 return _LastName;
25 }
26 }
27 public string Title { private set; get; }
28 public Employee Manager { private set; get; }
29
30 }
注：这个访问修饰限制性必须比应用于整个属性的访问修饰符更为严格。
属性的赋值和取值，可以是任何操作，get 必须返回一个数据类型一致的数据。
属性和方法调用不允许作为ref或out参数值使用
原因：ref和out需要将内存地址传给目标方法，但是，由于属性可能是没有支持字段的虚字段，
也有可能是只读/只写的，因此不可能传递其基础存储的地址，不过可以通过中间变量来实现。
如：
1 public string Title
2 {
3 private set;
4 get
5 {
6 return _FirstName + "." + _LastName;
7 }
8 }
构造器（构造函数）
为了定义构造器，要创建一个返回类型的方法，而且方法名必须完全和类名相同。
构造器是用来创建对象实例的方法。
new运算符返回的是被实例佛手对象的类型。
注：如果一个字段在声明时赋了初始值，且在构造函数中也赋予了初始值，那么最终生效的是构造器
内部的赋值，它会覆盖声明时的任何赋值。
所以应该避免在两个地方同时赋值。
C#编译器会自动添加一个默认构造器（无参数），且如果自定义了构造函数，不再自动添加默认构造函数。
C#3.0对象初始化器
在调用的时候使用
1 class Program
2 {
3 static void Main(string[] args)
4 {
5 string firstName = "aaaaa", middleName = "bbbbbbbbb", lastName = "cccccccc";
6 string fullName;
7 Employee e = new Employee(firstName, lastName) { Title = "MyTitle", Content="Content" };
8
9 Console.WriteLine(e.Title + ":" + e.Content + "" + ":" + e.FirstName + "." + e.LastName);
10 Console.ReadLine();
11
12
13 }
14
15
16 }
17 public class Employee
18 {
19 public Employee(string firstName, string lastName)
20 {
21
22 FirstName = firstName;
23 LastName = lastName;
24 }
25 private string _FirstName;
26 public string FirstName
27 {
28 private set
29 {
30 _FirstName = value;
31 }
32 get
33 {
34 return _FirstName;
35 }
36 }
37 private string _LastName;
38 public string LastName
39 {
40 private set
41 {
42 _LastName = value;
43 }
44 get
45 {
46 return _LastName;
47 }
48 }
49 public string Title
50 {
51 set;
52 get;
53
54 }
55 public string Content
56 {
57 set;
58 get;
59
60 }
61 public Employee Manager { set; get; }
62
63 }
终结器
终结器是在一个对象最后一次活动之后，并在程序终止之前执行，具体地说，垃圾回收器会在
一次垃圾回收过程中识别出带有终结器的对象。之后，它并不是立即回收这些对象，而是将它们添加
到一个终结列中。一个独立的线程遍历终结队列中的每一个对象，调用它们的终结器，然后把它们从队列
中删除，使它们再次可供垃圾回收器调用。
注：构造器可重载
使用this调用另一个构造器
这称为构造器链，它是用构造器初始化器来实现的。构造器初始化器会在执行当前构造器的实现之前
判断要调用另外哪一具构造器，并进行调用。
1 public Employee(string firstName, string lastName)
2 {
3
4 FirstName = firstName;
5 LastName = lastName;
6 }
7 public Employee(string Title, string firstName, string lastName)
8 : this(firstName, lastName)
9 {
10 this.Title = Title;
11 }
注：可写一个函数专门用来初始化，然后在构造器中调用。
匿名类型
在C#3.0中引入了对匿名类型的支持。它们是由器动态生成的数据，而不是通过显式的类定义来声明的。
var
编译器遇到匿名类型的语法时，就会自动生成一个CIL类，该类具有与匿名类型声明中的命名值
和数据类型对应的属性。
静态成员
使用static修饰
public static int Count = 0;
与实例字段不同，如果不对静态字段进行初始化，静态字段将自动获得相应数据类型的默认值。
另外，一个静态字段即使没有显式地赋值，也可以被访问。
在类的外部访问静态字段时，需要使用类名。
注：上下文就是作用域
静态方法
和静态字段一样，要直接在类名之后访问静态方法。
由于静态方法不是通过一个特定的实例来引用，所以this关键字在静态方法中是无效。
所以也不能直接在静态中访问类中声明的实例成员，所有实例成员必须通过一个对象引用才能访问。
静态构造器
除了静态字段和方法，C#还支持静态构造器。静态构造器用来对类进行初始化。静态构造器不是显式调用的
，运行时会在首次访问类时自动调用静态构造器。
所谓“首次访问类”，可能是调用一个普通构造器，也可能是访问类的一个静态方法或者字段。
在构造器中的赋值会覆盖声明时的初始化值。
静态属性
与实例属性一样，只是是属于类的。
使用静态属性几乎肯定要比使用公共静态字段好，因为公共静态字段在任何地方都能调用，而静态
属性则至少提供了一定程度的封装。
静态类
使用static修饰
这个类不包含任何实例成员，所以创建一个实例化的类是没有意义的。
静态类的另一个特殊在于，C#编译器会自动在CIL代码中把它标记为abstract和sealed。
这会将类指定为不可扩展，换言之，不能从它派生出其他类。
扩展方法（必须在静态类中定义）
C#3.0
引入了扩展方法(extension method）的概念。它能为一个不同的类模拟出一个实例方法。
使静态方法的第一个参数成为要扩展的类型，并在类型名称前面附加this关键字。
1 public static class DirectoryInfoExtension
2 {
3 public static string Message(this Employee e, string message1, string message2)
4 {
5 return message1 + message2;
6 }
7 }
8 string firstName = "aaaaa", middleName = "bbbbbbbbb", lastName = "cccccccc";
9 string fullName;
10 Employee e = new Employee();
11
12 Console.WriteLine(e.Title + ":" + e.Content + "" + ":" + e.FirstName + "." + e.LastName);
13
14 Console.WriteLine(e.Message(firstName,lastName));
15 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参数。
总之，分部方法使生成的代码能调用并非一要实现的方法。