C#学习笔记-进阶篇

一、类

1.1、面向对象（Object-Oriented Programming，简称OOP）

1.1.1、面向对象的理解

面向对象编程（OOP）是一种编程范式，它使用“对象”来设计软件和应用程序，当然，此“对象”非彼“对象”。大家都知道，编程的目的归根结底是为现实世界服务，而面向对象就是将现实世界中的事物抽象成一个个对象，通过对象模拟现实世界中事物的种种行为和客观规律来组成我们的软件。C#语言是一种面向对象的语言，C语言是一种面向过程的语言。除此之外，面向对象的语言还有C++、Java等。（*觉得理解不了的朋友可以去看看刘铁猛老师的视频，讲得很通俗易懂）

1.1.2、面向对象编程的优点

1. 提高代码的可重用性：通过将对象抽象为类和接口，可以在不同的项目中重复使用这些类和接口，减少代码的重复编写。
2. 提高代码的可维护性：面向对象编程使得代码结构更加清晰，易于理解和维护。通过封装和抽象，可以隐藏对象的内部实现细节，只暴露必要的接口，使得代码更加模块化。
3. 提高开发效率：通过模拟现实世界中的行为和规律，可以快速地设计和构建软件应用程序，缩短开发周期。同时，通过使用现有的类库和框架，可以快速地构建功能强大的应用程序。
4. 提高软件质量：面向对象编程提供了一种更加符合人类思维模式的编程范式，使得软件更加易于测试、调试和使用。同时，通过使用设计模式等最佳实践，可以提高软件的可扩展性和可维护性。

1.2、类的概述

类是一个能够存储数据并执行代码的数据结构，例如，人类可以看成是一个类，人有身高体重名字等（存储代码），人能说话、写字、走路（执行代码）。而刘德华是人类中的一个人，则可以看作是类的一个实例。所以说，类的方方面面在现实生活中都是有迹可循的。

*一个运行中的C#程序可以看成是一组相互作用的类型对象，他们大部分都是类的实例

1.3、类的声明

// 定义一个名为“Person”的类  
public class Person  
{  
    // 定义类的属性  
    public string Name { get; set; }  
    public int Age { get; set; }  
  
    // 定义类的构造函数  
    public Person(string name, int age)  
    {  
        Name = name;  
        Age = age;  
    }  
  
    // 定义类的方法  
    public void Greet()  
    {  
        Console.WriteLine("Hello, my name is " + Name);  
    }  
}

这个示例中，我们定义了一个名为“Person”的类，它具有两个属性（Name和Age），一个构造函数和一个方法（Greet）。构造函数用于初始化对象的属性值，方法用于实现特定的功能。

要使用这个类，可以创建它的实例并调用其方法：

// 创建Person类的实例  
Person person = new Person("Alice", 30);  
  
// 调用Greet方法输出问候信息  
person.Greet();//输出结果：Hello, my name is Alice

1.4、类的成员

类的成员包括数据成员和函数成员。数据成员可以是字段、常量或事件。函数成员包括方法、属性、构造函数、析构函数、运算符和索引器。

1.4.1、字段（Fields）

字段是类的数据成员，用于存储类实例的状态。根据作用域，字段可以分为两种类型：实例字段和静态字段。

实例字段：

每个类的对象实例都有其自己的实例字段副本。当我们创建类的实例时，这些实例字段会随着对象的创建而初始化。实例字段只能在其所属的类内部被访问，并且通过对象实例来访问。

public class Person  
{  
    public string Name; // 公共实例字段  
    private int Age;     // 私有实例字段  
}

静态字段：

静态字段属于类本身，而不是类的任何特定实例。这意味着所有实例共享同一个静态字段。它们通常用于存储与类相关而不是与对象实例相关的数据。静态字段可以在类的外部直接通过类名来访问。

public class Person  
{  
    public static int TotalPersons; // 公共静态字段  
}

自动实现的属性：

从C# 3.0开始，可以使用自动实现的属性来简化对字段的封装和访问。这种方法不需要显式地声明私有字段，编译器会自动为我们处理。当一个属性被自动实现时，编译器会在后台为该属性创建一个私有字段。属性的访问器（get和set）会自动生成，用于访问或修改该字段的值。

public class Person  
{  
    public int AgeInYears { get; set; } // 自动实现的属性  
}

注意事项：

• 字段应该谨慎使用，尤其是在面向对象编程中。封装是面向对象编程的重要原则之一，而字段的封装通常是通过属性来实现的。直接使用字段可能会破坏对象的封装性，因此应优先考虑使用属性。
• 静态字段常用于计数、记录类实例的数量等场景，因为它们不属于任何特定实例，而是属于整个类。
• 实例字段通常用于存储与对象状态相关的数据，如人的姓名、年龄等。

1.4.2、常量

用于存储不会改变的值。常量是类的一种特殊字段，其值在编译时被设定并且不能修改。这意味着常量一旦在程序中被定义，它的值就永远保持不变。常量主要用于表示在程序的生命周期内不会更改的值，如数学常数π、e，或者是一些固定配置的参数等。

定义常量：

常量的声明与字段的声明非常相似，但需要使用const关键字。同时，必须在声明时给常量赋值。

public class MathConstants  
{  
    public const double Pi = 3.141592653589793; // 定义π的常量值  
    public const double E = 2.718281828459045;  // 定义e的常量值  
}

使用常量：

常量是静态的，这意味着它们属于类本身而不是类的任何特定实例。因此，可以直接通过类名来访问常量，而无需创建类的实例。

double radius = 5.0;  
double circumference = 2 * MathConstants.Pi * radius; // 使用π常量计算圆的周长

常量的特性：

• 常量必须在声明时初始化。你不能在声明之后为它赋值，因为它是只读的。
• 常量的名称通常采用大写字母来表示，多个单词之间用下划线分隔（即采用驼峰命名法）。
• 常量只能是内置值类型（如int、double、char等），不能是引用类型（如string）。但C#中的string有一个特殊性，它虽然是引用类型，但因为字符串的不变性，所以允许作为常量使用。
• 由于常量在编译时就确定了其值，所以它们的值不能依赖于运行时才能确定的信息。
• 常量可以参与表达式的计算，但它们的值不能被修改。

使用场景：

• 常量通常用于定义那些程序逻辑中不会改变的值，比如物理常数、数学常数、或者程序中需要固定的值（比如缓冲区的大小）。
• 常量还可以用于定义枚举类型的底层值。
• 在跨多个类或程序集中共享值时，可以使用常量来确保所有引用点都使用相同的值。

注意事项：

• 过度使用常量可能会使代码难以维护。如果预计某个值可能会在未来发生变化，考虑使用变量或配置文件来管理这些值。
• 常量应该谨慎使用，确保它们真正代表“不变”的值。如果某个值有可能改变，即使这种改变很少发生，也不应该使用常量来表示。

1.4.3、属性（Properties）

属性是用于封装字段的一种机制，它提供了一种安全的方式来读取、写入或计算字段的值。通过属性，我们可以控制对字段的访问，确保数据完整性，并可以在访问字段时添加额外的逻辑。可以说，属性是对字段的扩展。

定义属性：

属性由get和set访问器组成。get访问器用于读取字段的值，而set访问器用于写入字段的值。可以使用自动实现的属性来简化属性的定义，编译器会自动为我们生成私有字段和访问器。

public class Person  
{  
    private string name;  
  
    public string Name  
    {  
        get { return name; } // get访问器  
        set { name = value; } // set访问器  
    }  
}

自动实现的属性：

从C# 3.0开始，可以使用自动实现的属性来简化属性的定义。编译器会自动为我们生成私有字段，并且属性的访问器会自动实现。

public class Person  
{  
    public string Name { get; set; } // 自动实现的属性  //vs生成属性快捷键：输入prop后按下tab键
}

属性的特性：

• 属性实际上是一种特殊的成员方法，但它们具有特殊的语法，使我们能够更容易地访问或修改类的内部数据。
• 属性不具有显式的访问修饰符，因为它们会根据是否只读或可写而自动决定其访问修饰符。默认情况下，如果只有get访问器，则属性是只读的；如果只有set访问器，则属性是只写的；如果两者都有，则属性是可读写的。
• 属性可以具有与它们关联的私有字段，但并非必需的。如果没有显式定义私有字段，编译器会自动为我们生成一个。这是自动实现的属性的工作方式。
• 属性可以包含复杂的逻辑，例如验证、触发事件等。这使得属性不仅仅是简单的数据存储器。
• 属性可以用于接口中，作为接口成员的契约的一部分。接口中的属性必须是公共的，因为接口不包含实现细节。
• 属性可以用于抽象类中，作为抽象成员的实现细节的一部分。抽象类中的属性可以是公共的或受保护的，因为抽象类可以有具体的实现细节。
• 属性可以在其他程序集中使用相同的名称和签名来共享数据。这使得跨程序集的数据共享变得更容易。
• 属性可以用于在运行时动态地改变对象的行为或状态。例如，可以根据属性的值来改变对象的渲染效果或行为模式等。

属性的作用

对外：暴露数据，数据可以是存储在字段里的，也可以是动态计算出来的。

对外：保护字段不被非法值 污染。

1.4.4、方法（Methods）

定义类可以执行的操作。用于表示类的行为与功能。是类中用于执行特定操作或实现特定功能的成员函数。

1.4.4.1 方法的参数传递

**值传递：**默认情况下，参数是通过值传递的。这意味着当我们将一个值类型的变量作为参数传递给方法时，实际上是传递了该变量的一个副本，而不是原始变量本身。对副本的任何修改都不会影响原始变量。

public void MyMethods(int value)  
{  
    value = value * 2; // 修改副本的值，原始变量不受影响  
}

**引用传递（ref）：**对于引用类型的变量，例如类实例、数组和用户定义的类型等，参数是通过引用传递的。这意味着当我们将引用类型的变量作为参数传递给方法时，实际上是传递了该变量的地址或引用，而不是变量的副本。对引用的任何修改都会影响原始变量。

public void ModifyObject(MyClass obj)  
{  
    obj.Property = "New Value"; // 修改原始对象的属性  
}

**输出参数（out）：**输出参数是一种特殊类型的参数，用于将方法的返回值通过引用传递。通过使用out关键字声明参数，我们可以将输出参数初始化为方法内部的某个值，并将其返回给调用者。

public void GetSquareRoot(double number, out double result)  
{  
    result = Math.Sqrt(number); // 将结果赋值给输出参数  
}

可选参数（Optional Parameters）

可选参数允许为方法的某个参数提供默认值，这样调用者就可以选择是否提供该参数的值。通过在参数名后面添加等号和默认值来定义可选参数。

public void MyMethod(int a, int b = 0) // b 是一个可选参数，默认值为0  
{  
    // 方法体...  
}

1.4.4.2 方法的返回值

方法的返回值是方法执行后返回给调用者的数据。在C#中，方法的返回值可以是任何数据类型，包括基本数据类型、引用类型和自定义类型。方法的返回值通过return关键字进行返回。一个方法可以有多个返回语句，但只会执行其中的一个。

public int Add(int a, int b) // 返回整数类型的值  
{  
    return a + b; // 返回两个整数的和作为返回值  
}

1.4.5、构造函数（Constructors）

构造函数是一种特殊的方法，用于在创建对象时初始化对象的内部状态。它与类同名，并且没有返回类型。当创建一个类的新实例时，构造函数会自动调用。

定义构造函数：

构造函数可以有不同的访问修饰符，包括public、protected、private和internal。默认情况下，如果没有指定访问修饰符，构造函数是public的。

public class Person  
{  
    public string Name { get; set; }  
    public int Age { get; set; }  
  
    // 公共构造函数  
    public Person(string name, int age)  
    {  
        Name = name;  
        Age = age;  
    }  
}

构造函数的特性：

• 构造函数与类同名，并且没有返回类型。
• 构造函数可以有一个或多个参数，用于初始化对象的属性。这些参数被称为构造函数参数。
• 一个类可以有多个构造函数，称为重载的构造函数。它们通过参数的数量、类型或顺序来区分彼此。
• 构造函数在创建类的对象时自动调用。
• 如果没有提供构造函数，编译器会自动提供一个默认的无参构造函数。但是，如果类中定义了任何构造函数，编译器就不会提供默认的构造函数。
• 构造函数不能被直接调用，它们在创建对象时自动执行。
• 构造函数不能被继承或重写，因为它们不是虚拟的或抽象的。
• 构造函数可以在其他程序集中使用相同的名称和签名来共享数据。这有助于促进代码的重用和模块化。
• 构造函数可以在运行时根据需要调用其他方法来执行额外的初始化逻辑。例如，一个构造函数可能会调用另一个构造函数来共享初始化逻辑。这称为委托构造函数或构造器的链式调用。
• 构造函数可以用于实现依赖注入和工厂模式等设计模式，以控制对象的创建和初始化过程。
• 构造函数可以用于实现单例模式或原型模式等设计模式，以控制对象的实例化过程。
• 构造函数可以用于在对象创建时执行一些额外的验证逻辑，例如检查参数的有效性或确保对象的状态是有效的。这有助于提高代码的健壮性和安全性。

1.4.6、析构函数（Destructors）

析构函数（也称为终结器）是在.NET环境中，对象生命周期结束时调用的特殊方法。它的主要用途是释放类所持有的非托管资源，执行清理操作，或者执行任何其他必要的后处理工作。

定义析构函数：

析构函数使用~符号进行标记，并且没有返回类型和参数。它与类的构造函数类似，但析构函数不能被直接调用，它们在对象的生命周期结束时自动执行。

public class ResourceHolder  
{  
    private IntPtr handle; // 非托管资源  
    public ResourceHolder()  
    {  
        handle = Marshal.AllocHGlobal(100); // 分配非托管内存  
    }  
    // 析构函数，释放非托管资源  
    ~ResourceHolder()  
    {  
        Dispose();  
    }  
    // 显式实现Dispose方法以释放资源  
    public void Dispose()  
    {  
        if (handle != IntPtr.Zero)  
        {  
            Marshal.FreeHGlobal(handle); // 释放非托管内存  
            handle = IntPtr.Zero;  
        }  
    }  
}

析构函数的特性：

• 析构函数是以类的名称前加上波浪线(~)来标记的。
• 析构函数不能被直接调用，它们在对象的生命周期结束时自动执行。当垃圾回收器确定没有任何引用指向对象时，就会调用析构函数。
• 析构函数主要用于释放非托管资源，如文件句柄、数据库连接和内存块等。对于托管资源，.NET运行时会负责垃圾回收和资源释放。
• 除了使用析构函数，还可以通过实现IDisposable接口来提供Dispose方法，以便显式地释放资源。这种做法更加灵活，因为它允许更细粒度的控制和资源的多次释放。在上面的示例中，我们显式地实现了Dispose方法来释放非托管资源。
• 析构函数的执行顺序是按照它们在代码中出现的顺序。如果有多个析构函数需要执行，它们会按照顺序一个接一个地调用。在上面的示例中，Dispose方法被调用时，会触发自动调用析构函数。
• 如果类中定义了析构函数，那么在创建类的实例时会自动调用构造函数来初始化对象。如果类中没有定义析构函数，则会自动创建一个默认的构造函数（如果有定义任何其他构造函数）。如果没有显式定义构造函数或析构函数，编译器会提供默认的构造函数和析构函数。
• 在使用完对象后显式调用Dispose方法可以帮助尽早释放资源，而不是等待垃圾回收器自动释放它们。这有助于提高应用程序的性能和响应性。

1.4.7、索引器（Indexers）

索引器是C#中类的一个特殊成员，它使我们能够为集合类型（如数组、列表、字典等）提供类似数组的索引访问方式。它允许我们为类定义一个类似于数组的索引方式，使得我们可以使用类似于obj[index]的方式来访问和修改对象的集合或数组类型的成员。

定义：

在C#中，索引器是通过在类定义中添加一个名为this的特殊属性来定义的。该属性后面跟随着参数列表，以指定如何访问集合中的元素。

public class MyCollection  
{  
    private int[] items = new int[10];  
  
    // 定义一个索引器，使用int类型的键访问items数组中的元素  
    public int this[int index]  
    {  
        get { return items[index]; } // 读取元素的值  
        set { items[index] = value; } // 修改元素的值  
    }  
}

特征：

• 语法简洁：使用索引器可以简化代码，使集合的访问和操作更加直观和简洁。
• 参数化：索引器可以接受一个或多个参数，以实现更灵活的访问方式。例如，可以定义一个接受键和值的参数的索引器，以实现类似obj[key, value]的访问方式。
• 类型安全：由于索引器可以定义参数的类型，因此它具有类型安全性，可以避免运行时错误。
• 数据绑定：索引器可以在UI组件中用于数据绑定，以实现动态更新和双向绑定。
• 可重载：索引器可以重载，允许定义多个具有不同参数的索引器，以适应不同的访问需求。
• 封装性：通过索引器，我们可以隐藏集合的内部实现细节，提供一种更符合面向对象设计原则的方式来操作集合。

使用：

• 访问元素：使用索引器可以像操作数组一样访问集合中的元素。例如，假设我们有一个名为myCollection的MyCollection类实例，可以使用myCollection[0]来访问第一个元素的值。
• 修改元素：除了读取元素之外，索引器还可以用于修改集合中的元素。例如，myCollection[1] = newValue将修改第二个元素的值。
• 链式调用：通过返回集合中的元素，我们可以实现链式调用。例如，假设MyCollection类中的索引器返回一个对象，可以使用以下代码：myCollection[0].AnotherProperty = newValue。
• 参数化访问：如果索引器具有多个参数，可以使用这些参数来访问特定位置的元素。例如，假设有一个接受两个参数的索引器，可以使用以下代码：myCollection[index1, index2]来访问特定位置的元素。

1.4.8、运算符重载

运算符重载是一种强大的特性，它允许我们为自定义类型定义现有的运算符的行为。这意味着我们可以为自定义类型提供类似于内置类型的操作方式。通过运算符重载，我们可以使代码更加简洁、直观，并提高开发效率。

定义：

运算符重载是通过在类中定义特殊的方法来实现的。这些方法必须使用static关键字和operator关键字进行声明，并且必须遵循特定的签名约定。

public class ComplexNumber  
{  
    public double Real { get; set; }  
    public double Imaginary { get; set; }  
  
    // 运算符重载示例：加法运算符  
    public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b)  
    {  
        return new ComplexNumber { Real = a.Real + b.Real, Imaginary = a.Imaginary + b.Imaginary };  
    }  
}

特征：

• 静态方法：运算符重载是通过静态方法实现的，这意味着该方法不能访问类的非静态成员。
• 限定符：运算符重载的方法必须使用static和operator关键字来声明。
• 返回类型：运算符重载方法的返回类型取决于被重载的运算符。例如，加法运算符应该返回一个新的对象或一个适当的值类型。
• 参数类型：运算符重载方法的参数类型取决于被重载的运算符的操作数。例如，对于二元运算符，方法应该接受两个参数。
• 优先级和结合性：运算符重载方法的优先级和结合性应该与被重载的运算符保持一致。
• 重载限制：某些运算符不能被重载，如赋值运算符、点运算符和索引器等。
• 行为一致性：运算符重载应该遵循其原始语义，以保持一致的行为。
• 遵循语法规则：运算符重载必须遵循C#语法规则和规范，以确保正确的使用和语义。

适用场景：

• 自定义类型操作：当我们需要为自定义类型提供类似于内置类型的操作时，可以使用运算符重载。例如，在数学库中为复数类型重载加法、减法、乘法和除法等运算符。
• 简化代码：通过使用运算符重载，我们可以使代码更加简洁和直观。例如，使用重载的加法运算符可以避免显式的函数调用或方法调用，使代码更易于阅读和理解。
• 扩展性：通过为现有类添加新的运算符重载，我们可以扩展类的功能而无需修改类的实现。这有助于提高代码的灵活性和可扩展性。
• 提高性能：在某些情况下，通过重载运算符可以在运行时直接调用高效的底层操作，从而提高性能。这在某些低级领域如科学计算和游戏开发中可能非常重要。

1.4.9、静态成员（Static Members）

属于类本身而不是类的实例的成员，可以直接通过类名访问。使用 static 修饰符可声明属于类型本身而不是属于特定对象的静态成员。

*static修饰符不能用于索引器或终结器

1.4.9.1 静态类

使用静态类的意义

（1）防止程序员写代码时实例化该静态类。

（2）防止在类的内部声明任何实例字段或方法。

使用静态类的要求

（1）静态类的成员都是静态的。

（2）静态类不能实例化

（3）C#编译器会自动把静态类标记为sealed。

1.4.9.2 静态成员

若使用static关键字修饰类成员，则该成员为静态成员。（索引器和终结器不能被static修饰）

使用静态成员的要求

（1）无论对一个类创建多少个实例，它的静态成员都只有一个副本。

（2）静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员。

（3）静态方法和属性不能访问其包含类型中的非静态字段和事件，并且不能访问任何对象的实例变量。

（4）在字段中，static不能与const同用，因为 const 字段的行为在本质上是静态的。这样的字段属于类。

1.4.9.3 静态构造函数

用于初始化类中的静态成员

（1）静态类可以有静态构造函数，静态构造函数不可继承。

（2）静态构造函数可以用于静态类，也可用于非静态类。

（3）静态构造函数无访问修饰符、无参数，只有一个 static 标志。

（4）静态构造函数不可被直接调用，在创建第一个实例或引用任何静态成员之前，CLR（公共语言运行时）都将自动调用静态构造函数，静态构造函数将被自动执行，并且只执行一次。

1.4.10、事件（Events）

允许类通知其他对象某些事情发生了。详见第十点。

1.5、类的实例化

这几种方法可以了解一下，本人之前面试有问过实例化类有几种方式。

1.5.1、new关键字

这是最直接的方法，通过new关键字和类名来创建类的实例。

MyClass myObject = new MyClass();

1.5.2、反射（Reflection）

反射允许在运行时动态地创建和操作类型，通过反射API可以实例化一个类。

Type type = typeof(MyClass);  
object instance = Activator.CreateInstance(type);

1.5.3、工厂模式

在工厂模式中，通常会有一个工厂类来负责创建其他类的实例，这可以隐藏对象的创建逻辑，并使代码更加模块化。

object factory = new MyFactory();  
MyClass myObject = factory.CreateMyClass();

1.5.4、依赖注入（Dependency Injection）

在依赖注入中，对象的依赖关系通常由外部容器或框架来管理。对象的实例化不由直接调用new来完成，而是由依赖注入框架来处理。

// 假设有一个IDependency interface 和它的实现类 MyDependency  
IDependency myDependency = new MyDependency();

1.5.5、序列化与反序列化

通过将对象序列化为字节流（例如JSON或XML）或将字节流反序列化为对象，可以在不同的应用程序或系统中共享对象状态。

// 序列化对象为JSON字符串  
string json = JsonConvert.SerializeObject(myObject);  
  
// 从JSON字符串反序列化为对象  
MyClass myDeserializedObject = JsonConvert.DeserializeObject<MyClass>(json);

1.5.6、克隆或复制构造函数

可以通过定义额外的构造函数或克隆方法来创建现有对象的一个副本。

public class MyClass   
{  
    public MyClass Clone()   
    {  
        return new MyClass(this); // 假设有一个复制构造函数的实现  
    }  
}

二、封装

封装是指将数据（属性）与操作数据的函数（方法）捆绑到一个称为“对象”的单一实体中。通过封装，对象的内部状态变得不可见，只能通过定义好的公开方法来访问或修改其状态。

2.1、目的：

1. 隐藏实现细节：通过封装，类的使用者无需关心类内部如何实现细节，只需要知道提供的公共接口即可。
2. 安全性：隐藏内部状态使得外部代码不能随意修改对象的内部数据，从而增加了数据的安全性。
3. 代码重用：封装有助于将相关的数据和操作组织在一起，使得代码更易于理解和重用。

2.2、重要性：

1. 信息隐藏和数据保密：封装有助于限制对对象内部状态的访问，防止外部代码随意修改或破坏对象的状态。
2. 提高软件的可维护性和可扩展性：由于封装限制了对对象内部细节的直接访问，当对象内部实现发生改变时，对外部代码的影响最小化。这有助于降低软件维护的难度，提高软件的可维护性。同时，通过封装可以将功能模块化，方便添加新的功能或行为，提高软件的可扩展性。
3. 支持继承和多态：封装是支持面向对象编程的其他特性如继承和多态的基础。

2.3、好处：

1. 提高代码的安全性和可靠性：由于封装限制了对内部状态的直接访问，可以减少错误操作导致的数据损坏或程序崩溃。
2. 简化编程模型：封装使得开发者可以专注于使用对象提供的公开接口，而不必关心其内部实现的细节，降低了编程的复杂性。
3. 促进代码重用：封装使得数据和操作数据的逻辑紧密结合在一起，方便创建可重用的组件。
4. 增强软件的可维护性和可扩展性：如上文所述，由于封装降低了对内部细节的依赖，当软件需要修改或扩展时，工作量得以降低。
5. 支持更好的模块化：通过封装，可以更好地将相关的数据和操作组织在一起，形成独立的、可复用的模块。

2.4、访问修饰符

访问修饰符用于控制对类、属性、方法、事件等的可见性。通过访问修饰符，我们可以定义哪些代码可以访问某个成员，以及从哪个作用域可以访问它。

2.4.1、public

公共访问修饰符表示成员可以从任何其他类或方法中访问。这是最宽泛的访问级别。

public class MyClass  
{  
    public int PublicProperty { get; set; }  
    public void PublicMethod() { }  
}

2.4.2、private

私有访问修饰符表示成员只能在包含它的类内部访问。这是默认的访问级别，如果没有指定访问修饰符，则默认为私有访问。

class MyClass  
{  
    private int PrivateProperty { get; set; }  
    private void PrivateMethod() { }  
}

2.4.3、protected

保护访问修饰符表示成员可以在包含它的类以及派生自该类的任何子类中访问。

public class MyBaseClass  
{  
    protected int ProtectedProperty { get; set; }  
    protected virtual void ProtectedMethod() { }  
}

2.4.4、internal

内部访问修饰符表示成员只能在包含它的程序集内部访问。这通常用于那些不应该从其他程序集中公开的类或成员。

internal class InternalClass  
{  
    internal int InternalProperty { get; set; }  
    internal void InternalMethod() { }  
}

2.4.5、protected internal

保护内部访问修饰符表示成员可以在包含它的程序集或派生自该类的子类中访问。这相当于同时使用protected和internal修饰符。

public class MyBaseClass  
{  
    protected internal int ProtectedInternalProperty { get; set; }  
    protected internal virtual void ProtectedInternalMethod() { }  
}

2.4.6、private protected

私有保护访问修饰符表示成员可以在包含它的类以及任何从那个类派生的外部子类中访问。这相当于同时使用private和protected修饰符。

public class MyBaseClass  
{  
    private protected int PrivateProtectedProperty { get; set; }  
    private protected virtual void PrivateProtectedMethod() { }  
}

2.4.7、override

当一个成员在基类中定义为protected或public，并且被标记为virtual或abstract时，子类可以通过使用override关键字来提供自己的实现。这是面向对象编程中的多态性的一种表现。

public class MyBaseClass   
{   
    protected virtual void MyMethod() { }   
}   
  
public class MyDerivedClass : MyBaseClass   
{   
    public override void MyMethod() { }   
}

三、继承

继承是面向对象编程中的一个核心概念，它允许一个类继承另一个类的属性和方法。继承在C#中为代码重用、多态和实现软件开发生命周期中的代码复用提供了强大的支持。通过合理地使用继承，可以提高代码的可维护性、可读性和可扩展性，有助于构建健壮、灵活和可重用的软件系统。

3.1、概念

继承是一个类（派生类或子类）获取另一个类（基类或父类）的成员（属性、方法、事件等）的过程。通过继承，子类可以拥有父类的所有非私有成员，并且可以添加自己的新成员或覆盖父类的成员。

3.2、优势

1. 代码重用：通过继承，子类可以复用父类的代码，避免了重复编写相同的功能代码，提高了代码的复用性和维护性。
2. 多态性支持：继承是实现多态的基础。通过覆盖父类的方法，子类可以提供不同的实现，使得在运行时能够根据对象的实际类型来调用相应的方法。
3. 逻辑组织：通过将具有共同特性的类组织在一起，形成一个层次结构，有助于理解和维护代码。
4. 扩展性：通过继承，可以很容易地扩展现有类的功能而无需修改原始类。这为软件开发生命周期中的扩展性设计提供了可能。

3.3、应用场景

1. 层次结构定义：当需要定义一个类与其他类之间的层次关系时，可以使用继承。例如，动物是一个基类，哺乳动物和鸟类是动物的子类，它们继承了动物的属性和方法。
2. 分类与子分类关系：当一个类别包含另一个类别时，可以使用继承来表示这种关系。例如，汽车是一个类别，轿车和卡车是汽车的不同子类别。轿车和卡车可以继承汽车类的属性和方法。
3. 模板方法实现：当需要实现一个通用的算法或流程，但某些步骤需要根据子类的特性进行定制时，可以使用继承。通过在父类中定义算法的框架，子类可以提供定制的实现部分。
4. 组件化开发：在大型软件项目中，使用继承可以将复杂的系统分解为更小、更易于管理的组件。每个组件可以定义为一个类，并使用继承来构建更高级别的组件或系统。
5. 接口实现与抽象类的使用：当需要定义一组方法签名但不提供具体实现时，可以使用抽象类或接口。其他类可以继承这些抽象类或实现这些接口来提供具体的实现。
6. 设计模式中的结构与行为复用：在设计模式中，如工厂模式、策略模式、观察者模式等，继承常常被用来复用已有的结构或行为，同时提供定制化的扩展点。

四、多态

多态是面向对象编程的三大特性之一，它允许一个接口以多种形式出现。多态的存在增加了程序的灵活性和扩展性，是构建强大软件系统的关键。

4.1、概念

多态是指一个接口在多种情况下有不同的表现形式。在C#中，多态允许子类对象以父类引用的形式存在，从而在运行时根据对象的实际类型来调用相应的方法。

4.2、特点

1. 动态绑定：多态允许在运行时根据对象的实际类型来确定要调用哪个方法，而不是在编译时确定。
2. 接口一致性：通过多态，可以使用父类引用或接口引用来调用方法，而不需要关心实际对象的类型。
3. 方法覆盖与重载：多态通过方法覆盖（也称为重写）和方法重载来实现。

4.3、方法重写（Method Overriding）

当子类继承了父类的一个方法，并且想要提供一个新的实现时，可以使用方法重写。在子类中定义一个与父类方法签名完全相同的方法，并为其提供新的实现。这样，当通过父类引用调用该方法时，将执行子类中的实现。

class Animal   
{  
    public virtual void MakeSound()   
    {  
        Console.WriteLine("The animal makes a sound");  
    }  
}  
  
class Cat : Animal   
{  
    public override void MakeSound()   
    {  
        Console.WriteLine("Meow");  
    }  
}

4.4、方法重载（Method Overloading）

方法重载是指在同一个类中定义多个同名方法，但它们的参数列表（参数类型、数量或顺序）不同。通过方法重载，可以实现同一个方法名在不同情况下执行不同的操作。

class Calculator   
{  
    public int Add(int a, int b)   
    {  
        return a + b;  
    }  
      
    public double Add(double a, double b)   
    {  
        return a + b;  
    }  
}

五、抽象类（abstract）

5.1、概念

抽象类是一种特殊的类，通常用于定义一个通用的、共享的基类，它可以包含抽象方法，具体方法，字段和属性等成员，而抽象方法的具体实现则由它的派生类来实现，使用Abstract修饰符修饰的类是抽象类，它不能被实例化。

5.2、特点

1. 抽象类不能被直接实例化。也就是说，你不能直接创建抽象类的对象。如果你尝试这样做，编译器会报错。
2. 抽象类可以包含抽象成员。抽象成员是没有实现的成员，必须由派生类提供具体实现。抽象成员可以有访问修饰符，但通常它们都是公开的，因为派生类需要能够访问它们。
3. 抽象类可以包含具体成员。这些成员在抽象类中提供了具体的实现，派生类可以选择覆盖这些实现或者使用基类的实现。
4. 抽象类可以包含非公开的成员（例如私有字段、私有方法等）。这是与接口的一个主要区别，因为接口中的所有成员都是公共的。
5. 抽象类可以包含事件、索引器、属性、方法等成员。这些成员必须在派生类中被实现。
6. 派生类必须实现所有的抽象成员。如果一个派生类不实现所有的抽象成员，那么它也必须声明为抽象类。
7. 抽象类可以继承自其他类或接口。这允许将多个继承层次结构合并到一个单独的继承层次结构中。
8. 抽象类和普通类一样可以有字段、属性、事件和方法。
9. 抽象类可以有构造函数，允许在创建派生类对象时进行一些初始化操作。

5.3、定义

public abstract class Vehicle
{
    public int MyProperty { get; set; }
    public abstract void Drive();
    public void Run()
    {
        Console.WriteLine("交通工具在运动！");
    }
}
public class Car : Vehicle
{
    public override void Drive()
    {
        Run();
        Console.WriteLine("我开着汽车！");
    }
}

5.4、应用场景

1. 代码复用：抽象类可以提供一组通用的属性和方法，这些属性和方法将被派生类继承并实现。通过这种方式，抽象类可以减少代码重复，提高代码复用性。
2. 行为规范：抽象类可以定义一组公共的成员（例如方法、属性、事件和索引器），强制要求派生类实现这些成员。通过这种方式，抽象类可以强制要求派生类遵循特定的行为规范。
3. 组件设计：在设计组件时，抽象类可以充当接口的角色。与接口不同的是，抽象类可以包含非公共的成员（例如私有字段和私有方法），而接口中的所有成员都是公共的。通过抽象类，可以更好地控制组件的行为和实现细节。
4. 大型应用开发：在开发大型应用程序时，往往需要定义一个类，随着功能的增加，可能需要添加一个新的类。如果发现新添加的类与原先定义的类有很多相似之处，就可以考虑使用抽象类来泛化这些相似之处，让子类继承抽象类，复用代码的同时也提升了应用后期的可维护性。
5. 设计模式：抽象类在许多设计模式中都有应用，例如模板方法模式、策略模式等。在这些模式中，抽象类通常用于定义一个通用的算法框架或行为规范，具体的实现细节由派生类来完成。
6. 兼容性和扩展性：抽象类可以为派生类提供兼容性和扩展性。通过在抽象类中定义一组公共的属性和方法，可以确保派生类在实现这些属性和方法时保持兼容性。同时，如果需要添加新的功能或行为，可以通过添加新的抽象成员来实现，而不需要修改现有的派生类代码。

六、接口（interface）

6.1、概念

接口用于定义一组方法的契约，但不包含这些方法的实现。接口可以包含方法、属性、事件和索引器。其派生类必须提供接口中所有成员的具体实现。

6.2、特点

1. 接口不能被实例化。接口只是定义了一组行为规范，具体的实现由实现接口的类或结构提供。
2. 接口可以继承自其他接口，实现多重继承。一个类或结构可以实现多个接口，通过这些实现的接口被索引。
3. 接口中的成员默认是public的，不能包含字段、构造函数和析构函数。
4. 实现接口的类或结构必须严格遵守接口中定义的行为规范，即必须实现接口中的所有方法。

6.3、定义

1. 接口名后接一对大括号，大括号内包含方法、属性、事件和索引器的定义。
2. 方法、属性、事件和索引器的修饰符必须为public。
3. 接口名称一般以I为开头

public interface IMyInterface  
{  
    string MyProperty { get; set; }  
    void MyMethod();  
}

6.4、应用场景

1. 解耦：通过定义接口，可以分离具体的实现细节和抽象的行为规范，使得程序的结构更加清晰和灵活。使用接口可以使得程序更容易应对变化，因为具体的实现可以随时替换而不影响使用接口的其他代码。
2. 多重继承：通过实现多个接口，类可以实现多重继承的效果。这使得一个类可以同时拥有多个基类的行为，提高了代码的复用性和扩展性。
3. 设计模式：接口在许多设计模式中都有应用，例如工厂模式、观察者模式等。在这些模式中，接口用于定义一组通用的行为规范，具体的实现由实现接口的类来完成。这使得代码更加模块化和可维护。

七、五大基本原则

7.1、单一职责原则（SRP: Single Resposibility Principle）

一个类只做好一件事情。它是面向对象编程中的一个重要原则，它要求一个类应该只有一个职责，或者说一个类只有一个改变的原因。这个原则的目的是提高代码的可维护性和可读性，降低类的复杂度，减少类之间的耦合度。

7.1.1、单一职责原则的使用

1. 职责明确：一个类应该只负责一项功能或业务逻辑，它的职责应该是单一的。如果一个类承担了过多的职责，就可能导致代码的耦合度过高，增加维护的难度。
2. 分离关注点：将不同的职责分散到不同的类中，每个类只关注自己的职责。这样可以让代码更加清晰，更容易理解和维护。
3. 降低耦合度：通过将不同的职责分散到不同的类中，可以降低类之间的耦合度，使得代码更加模块化，提高了代码的可重用性和可维护性。
4. 提高可读性：单一职责原则使得代码更加简洁明了，每个类都有明确的职责和功能，提高了代码的可读性。

7.1.2、注意事项

使用单一职责原则时，需要注意不要过度分解类。将一个大型类拆分成多个小型类并不一定就是好的设计，需要综合考虑类的职责、功能和耦合度等因素。同时，也需要考虑类的命名和注释，使得代码更加易于理解和维护。

7.2、开放封闭原则（OCP: Open Closed Principle）

对扩展开放，对修改封闭。它是面向对象编程中的一个重要原则，它要求软件实体（类、模块、函数等）对于扩展是开放的，但对于修改是封闭的。这意味着一个实体是允许在不改变它的源代码的前提下变更它的行为。

7.2.1、开放封闭原则的使用

1. 对扩展开放：当软件需要添加新的功能或行为时，可以通过添加新的类或模块来实现，而不是修改现有的代码。这样可以使得现有代码保持不变，降低了修改的风险和维护的成本。
2. 对修改封闭：一旦设计完成并经过测试的类或模块，不应该被修改。如果需要修改，应该通过扩展来添加新的行为，而不是直接修改现有代码。这样可以保证现有代码的稳定性和可维护性。

使用开放封闭原则时，可以通过抽象和继承来实现。通过定义抽象类或接口，可以定义一组通用的属性和方法，然后通过继承和实现来添加新的行为。这样可以使得代码更加模块化，提高了代码的可重用性和可维护性。

7.3、里氏替换原则（LSP: Liskov Substituion Principle）

子类可以替换父类并出现在父类能够出现的任何地方。里氏替换原则是由美国计算机科学家Barbara Liskov提出的。这个原则是说，如果一个程序使用了一个基类的对象，那么使用该基类的任何子类的对象来替换它，程序的行为应该保持不变。

7.3.1、里氏替换原则的使用

1. 子类必须能够替换其基类：这意味着子类必须实现与基类相同的功能和行为，并且子类的对象可以在任何使用基类对象的地方使用，而不会破坏程序的原有逻辑。
2. 子类可以对基类进行扩展，但不能对基类进行限制：这意味着子类可以添加新的行为和属性，但不能改变基类的原有行为或属性。
3. 子类方法的异常应该和基类方法的异常一致或者更少：在方法抛出的异常方面，子类应该至少与基类一样安全，或者更安全。

7.4、依赖倒置原则（DIP: Dependecy Inversion Principle）

依赖于抽象，即高层模块不依赖于底层模块，二者都依赖于抽象。它要求高层模块不应该依赖于低层模块，而是应该依赖于抽象。换句话说，具体实现应该依赖于抽象，而不是抽象依赖于具体实现。这样可以降低模块间的耦合度，提高系统的可维护性和可扩展性。

7.4.1、依赖反转原则的使用

1. 依赖抽象而非具体实现：高层模块不应该依赖于低层模块的具体实现，而是应该依赖于抽象。这样，当低层模块的实现发生改变时，高层模块不需要随之改变。
2. 模块间的解耦：通过将依赖关系反转，高层模块和低层模块之间的耦合度降低，使得模块间的解耦成为可能。这样，当某个模块发生变化时，其他模块不会受到影响，降低了系统的复杂性。
3. 提高可维护性和可扩展性：由于模块间的耦合度降低，系统的可维护性和可扩展性得到了提高。当需要添加新功能或修改现有功能时，只需要修改某个模块，而不会影响到其他模块。

7.5、接口分离原则（ISP: Interface Segregation Principle）

使用多个小的专门接口，而不要使用一个大的总接口。它要求将大接口拆分成小接口，每个接口负责单一职责。这样可以降低类之间的耦合度，提高系统的可维护性和可扩展性。

7.5.1、接口分离原则的使用

1. 单一职责原则：每个接口应该只负责一个功能或业务逻辑，这样可以使接口更加清晰、职责单一。
2. 高内聚、低耦合：将大接口拆分成小接口，可以降低类之间的耦合度，提高系统的内聚性。这样可以使每个接口更加独立，便于维护和扩展。
3. 松耦合：通过将大接口拆分成小接口，可以使系统中的模块或组件之间的依赖关系变得更加松散，从而降低模块之间的耦合度。
4. 灵活性：接口分离原则可以提高系统的灵活性，使系统更加易于扩展和维护。通过将大接口拆分成小接口，可以方便地添加新功能或修改现有功能，而不会对整个系统造成影响。

八、异常处理

8.1、System.Exception

是所有异常类的基类，它包含了异常的基本信息，如消息、堆栈跟踪等。它有两个主要的派生类：

8.1.1、 System.SystemException

它是系统定义的异常类的基类，通常由系统抛出。

8.1.2 、System.ApplicationException

它是用户定义的异常类的基类，通常由应用程序抛出。

8.2、派生自System.SystemException的一些常见异常类

8.2.1 、System.NullReferenceException

当尝试访问空对象的成员时抛出的异常。

8.2.2、 System.IndexOutOfRangeException

当尝试访问数组或集合中不存在的索引时抛出的异常。

8.2.3、 System.DividedByZeroException

当除数为零时抛出的异常。

8.2.4 、System.ArithmeticException

算术运算异常的基类。

8.3、派生自System.ApplicationException的用户自定义异常类

用户可以根据自己的需求，派生自System.ApplicationException类来定义自己的异常类型，以便更好地区分不同类型的异常情况。

8.4、try-catch 块

try 块：包含可能引发异常的代码。

catch 块：用于捕获 try 块中抛出的异常，并执行相应的错误处理代码。

8.5、throw语句

throw语句用于引发（即重新抛出）异常。通常，当你在catch块中处理一个异常时，你可能需要将该异常传递给更高级别的代码，以便进一步处理或记录。使用throw语句可以重新引发该异常，使异常的处理流程得以继续。

try  
{  
    // 一些可能抛出异常的代码  
}  
catch (Exception ex)  
{  
    // 处理异常的代码  
    // ...  
    throw; // 重新引发异常  
}

8.6、finally块

无论是否发生异常，都会执行此块中的代码。通常用于资源清理操作。

try  
{  
    // 可能抛出异常的代码  
    int result = 10 / 0; // 除以零的异常  
}  
catch (DivideByZeroException ex)  
{  
    // 处理除以零异常的代码  
    Console.WriteLine("发生除以零异常: " + ex.Message);  
}  
catch (Exception ex)  
{  
    // 处理其他异常的代码  
    Console.WriteLine("发生其他异常: " + ex.Message);  
}  
finally  
{  
    // 清理资源的代码，无论是否发生异常都会执行  
    Console.WriteLine("执行finally块中的代码。");  
}

8.7、基本异常类型

8.7.1 、System.Exception

这是所有异常类型的基类。通常情况下，我们不会直接捕获该异常，而是使用它的子类来捕获特定类型的异常。

8.7.2、 System.ArithmeticException

表示算术运算异常，例如除以零。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            int dividend = 10;  
            int divisor = 0;  
            int quotient = dividend / divisor; // 这将引发ArithmeticException  
        }  
        catch (System.ArithmeticException ex)  
        {  
            Console.WriteLine("发生算术异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.3 、System.IndexOutOfRangeException

表示数组索引超出范围异常。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            int[] array = new int[5]; // 创建一个长度为5的数组  
            int index = 10; // 设置一个超出数组范围的索引值  
            array[index] = 100; // 这将引发IndexOutOfRangeException  
        }  
        catch (System.IndexOutOfRangeException ex)  
        {  
            Console.WriteLine("发生索引越界异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.4 、System.NullReferenceException

表示空引用异常，当尝试访问空引用对象的成员时抛出。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            var obj = null; // 创建一个空引用对象  
            var result = obj.ToString(); // 这将引发NullReferenceException  
        }  
        catch (System.NullReferenceException ex)  
        {  
            Console.WriteLine("发生空引用异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.5 、System.OutOfMemoryException

表示内存不足异常，当无法分配所需内存时抛出。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            var array = new byte[int.MaxValue]; // 尝试分配超出可用内存的字节数组  
        }  
        catch (System.OutOfMemoryException ex)  
        {  
            Console.WriteLine("发生内存溢出异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.6 、System.DivideByZeroException

表示除以零异常，当除法或模运算的分母为零时抛出。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            int dividend = 10;  
            int divisor = 0; // 定义一个零除数  
            int quotient = dividend / divisor; // 这将引发DivideByZeroException  
        }  
        catch (System.DivideByZeroException ex)  
        {  
            Console.WriteLine("发生除以零异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.7、 System.StackOverflowException

表示堆栈溢出异常，通常发生在递归调用过程中。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            Recursion(); // 无限递归调用，导致栈溢出  
        }  
        catch (System.StackOverflowException ex)  
        {  
            Console.WriteLine("发生栈溢出异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
  
    static void Recursion()  
    {  
        Recursion(); // 无限递归调用  
    }  
}

8.7.8 、System.IO.IOException

表示输入输出异常，用于处理文件和流的读写操作中的错误。

using System;  
using System.IO;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            string path = "nonexistentfile.txt"; // 指定一个不存在的文件路径  
            string content = File.ReadAllText(path); // 这将引发IOException  
        }  
        catch (System.IO.IOException ex)  
        {  
            Console.WriteLine("发生输入/输出异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.9、 System.FormatException

表示格式化异常，通常在字符串转换为其他类型时发生。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            string numberString = "invalidNumber"; // 一个格式不正确的数字字符串  
            int number = int.Parse(numberString); // 这将引发FormatException  
        }  
        catch (System.FormatException ex)  
        {  
            Console.WriteLine("发生格式异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.10、 System.ArgumentException

表示参数异常，通常在传递无效的参数值时抛出。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            string emptyString = ""; // 创建一个空字符串  
            int length = int.Parse(emptyString); // 这将引发ArgumentException，因为空字符串不能转换为整数  
        }  
        catch (System.ArgumentException ex)  
        {  
            Console.WriteLine("发生参数异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

8.7.11 、System.NotSupportedException

表示不支持的操作异常，当调用不支持的方法或功能时抛出。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        try  
        {  
            // 假设我们有一个不支持旋转的图形对象  
            Graphics graphics = new Graphics();  
            graphics.RotateTransform(45); // 这将引发NotSupportedException  
        }  
        catch (System.NotSupportedException ex)  
        {  
            Console.WriteLine("发生不受支持的异常: " + ex.Message);  
        }  
        catch (Exception ex)  
        {  
            Console.WriteLine("发生未知异常: " + ex.Message);  
        }  
        finally  
        {  
            Console.WriteLine("finally块被执行。");  
        }  
    }  
}

九、委托

9.1、委托的概念和基本使用

委托是一种特殊的类型，它代表了一个具有特定参数列表和返回类型的可调用方法。委托可以被视为一个类型安全的函数指针，允许将方法作为参数传递给其他方法，或者赋值给变量。委托可以链接一系列方法调用，形成一个链式调用。委托的声明需要指定委托的返回类型和参数列表。委托的定义可以包含在类中，也可以作为独立类型定义。一旦定义了委托，就可以将任何具有匹配签名的方法赋值给该委托变量。简单来说，委托就是C#中的“函数指针”，它实现了对方法的间接调用。

9.1.1 、委托的定义

委托的定义使用delegate关键字，后跟返回类型和委托的名称，以及方法的参数列表。以下是委托定义的基本语法：

public delegate void MyDelegate(int param1, string param2);

在这个例子中，MyDelegate是委托类型的名称，它表示一个具有一个整数参数和一个字符串参数，并且没有返回值的方法。

一旦定义了委托类型，就可以创建委托实例并将其指向一个或多个具有匹配签名的方法。委托实例可以使用+=运算符链接多个方法，形成多播委托（Multicast Delegate），也可以使用-=运算符从委托链中移除方法。

using System;  
  
// 定义一个具有两个整数参数和返回值类型为void的委托  
public delegate void MyDelegate(int a, int b);  
  
class Program  
{  
    static void Main()  
    {  
        // 创建委托实例并指向一个方法  
        MyDelegate myDel = new MyDelegate(AddNumbers);  
        myDel(10, 20); // 调用AddNumbers方法并输出结果30  
    }  
  
    // 与MyDelegate签名匹配的方法  
    public static void AddNumbers(int a, int b)  
    {  
        Console.WriteLine(a + b);  
    }  
}

需要注意的是，委托类型是引用类型，因此当委托作为参数传递或赋值时，实际上传递的是对方法的引用，而不是方法的副本。这使得委托在事件处理、回调函数和异步编程等方面非常有用。

9.1.2、 委托的特点

1. 类型安全：委托是类型安全的，类似于C++函数指针，但它们是类型安全的。委托允许将方法作为参数进行传递，但方法不必与委托签名完全匹配（委托中的协变和逆变）。
2. 间接调用：委托提供了一种间接调用方法的方式。通过委托变量，可以将一个方法作为参数传递给另一个方法，或者保存起来稍后再调用。
3. 链接方法调用：委托可以链接在一起，对一个事件调用多个方法。调用委托的时候，委托包含的所有方法将被执行。
4. 多播：委托支持多播功能，可以在一个委托中注册多个方法。使用加号运算符或减号运算符可以实现添加或撤销方法。
5. 可取消：通过使用 -=运算符，可以从委托链中移除方法，从而实现委托调用的取消。
6. 匿名方法与Lambda表达式：C# 2.0后引入了匿名方法，允许将代码块作为参数传递，以代替单独定义的方法。Lambda表达式进一步简化了委托的定义和使用。
7. 事件：委托在C#中常用于定义事件，事件可以被视为委托类型的成员，当事件发生时，所有注册到该事件的方法都会被调用。
8. 回调：委托可用于回调机制，允许一个对象将其内部状态或数据更新通知给其他对象。
9. 异步编程：委托在异步编程中也非常有用，可以用来处理异步操作的结果。
10. 扩展性：由于委托是类型安全的，并且可以与扩展方法一起使用，因此可以扩展现有类型的方法集。

9.1.3、多播委托和委托链

多播委托（MulticastDelegate）是包含多个方法的委托类型。当通过委托调用一个方法时，所有注册到该委托的方法都会被调用。多播委托允许将多个方法链接在一起，形成一个委托链。

委托链实际上是指将多个委托链接在一起，形成一个委托链。委托链的作用是将多个委托链接在一起，当调用委托链时，会依次调用委托链中的每个委托。每个委托可以是一个方法，当调用委托链时，会依次调用这些方法。

委托链的创建可以通过使用 + 运算符将多个委托分配到一个委托实例中来实现。一旦创建了委托链，就可以使用 + 或 - 运算符向链中添加或删除委托。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        // 定义一个委托类型  
        public delegate void MyDelegate(int a, int b);  
  
        // 创建委托实例  
        MyDelegate myDel = null;  
        myDel += Method1; // 将Method1添加到委托链中  
        myDel += Method2; // 将Method2添加到委托链中  
        myDel -= Method1; // 从委托链中移除Method1  
  
        // 调用委托链中的方法  
        myDel(10, 20); // 输出 "30"（Method2的结果）  
    }  
  
    // 定义一个匹配委托签名的静态方法  
    public static void Method1(int a, int b)  
    {  
        Console.WriteLine(a + b); // 输出 "15"  
    }  
  
    // 定义一个匹配委托签名的实例方法  
    public void Method2(int a, int b)  
    {  
        Console.WriteLine(a + b); // 输出 "30"  
    }  
}

9.1.4、常用委托

9.1.4.1、Fun委托

Func 委托用于封装返回值的方法。它定义了一个返回值类型，并可以接受0到16个输入参数。

Func<TResult>  
Func<TResult, TArg1>  
Func<TResult, TArg1, TArg2>  
...  
Func<TResult, TArg1, TArg2, ..., TArgN>

Func<int, int, int> add = (x, y) => x + y;  
int result = add(5, 3); // result = 8

9.1.4.2、Action委托

Action 委托用于封装没有返回值的方法。它也可以接受0到16个输入参数。

Action  
Action<TArg1>  
Action<TArg1, TArg2>  
...  
Action<TArg1, TArg2, ..., TArgN>

Action sayHello = () => Console.WriteLine("Hello!");  
sayHello(); // 输出 "Hello!"

9.2、委托的应用场景

9.2.1 、回调函数

回调函数是指一个由方法签名的指针，它可以在运行时被调用。通过将一个方法作为参数传递给另一个方法，并在适当的时候调用该方法，可以实现回调。通过委托的机制，可以将一个函数作为参数传递给另一个函数，使得后者在适当的时机调用传入的函数。这种机制在需要异步操作、事件处理、用户交互等情况下非常有用。

using System;  
  
class Program  
{  
    static void Main()  
    {  
        // 定义一个委托类型，表示具有两个整数参数且没有返回值的方法  
        public delegate void MyDelegate(int a, int b);  
  
        // 创建委托实例并将其赋值为一个方法  
        MyDelegate myDel = null;  
        myDel += Method1; // 将Method1添加到委托链中  
        myDel += Method2; // 将Method2添加到委托链中  
  
        // 调用回调函数，传入委托实例和参数  
        PerformCallback(myDel, 10, 20);  
    }  
  
    // 定义一个匹配委托签名的静态方法作为回调函数  
    public static void Method1(int a, int b)  
    {  
        Console.WriteLine($"Method1: {a} + {b} = {a + b}"); // 输出 "Method1: 10 + 20 = 30"  
    }  
  
    // 定义另一个匹配委托签名的实例方法作为回调函数  
    public void Method2(int a, int b)  
    {  
        Console.WriteLine($"Method2: {a} + {b} = {a + b}"); // 输出 "Method2: 10 + 20 = 30"  
    }  
  
    // 定义一个接受委托和参数的方法，用于执行回调函数  
    public static void PerformCallback(MyDelegate del, int x, int y)  
    {  
        // 检查委托是否为空，防止空引用异常  
        if (del != null)  
        {  
            del(x, y); // 调用委托链中的方法  
        }  
    }  
}

9.2.2 、事件处理

事件处理是响应特定事件的过程，比如用户点击按钮、文本框输入等。通过使用委托，可以将多个方法与同一事件关联起来，以便在事件发生时调用这些方法。

using System;  
  
class Program  
{  
    // 定义一个委托类型，表示具有一个字符串参数的方法  
    public delegate void MyEventHandler(string message);  
  
    static void Main()  
    {  
        // 创建委托实例  
        MyEventHandler handler = null;  
        handler += HandleMessage1; // 将HandleMessage1方法添加到委托链中  
        handler += HandleMessage2; // 将HandleMessage2方法添加到委托链中  
  
        // 触发事件，传递字符串参数  
        handler("Hello, World!");  
    }  
  
    // 定义一个匹配委托签名的静态方法作为事件处理程序  
    public static void HandleMessage1(string message)  
    {  
        Console.WriteLine($"Message1: {message}"); // 输出 "Message1: Hello, World!"  
    }  
  
    // 定义另一个匹配委托签名的实例方法作为事件处理程序  
    public void HandleMessage2(string message)  
    {  
        Console.WriteLine($"Message2: {message}"); // 输出 "Message2: Hello, World!"  
    }  
}

通过使用委托，可以将多个方法与同一事件关联起来，并在事件发生时自动调用这些方法。这种机制使得事件处理更加灵活和可扩展。

9.2.3 、异步编程

委托在C#中也可以用于异步编程，以方便地实现异步操作。异步编程是一种编程模式，允许程序在等待某些操作完成时继续执行其他代码。通过使用委托，可以将异步操作封装为一个方法，并在需要时调用该方法。

以下是使用委托实现异步编程的示例：

using System;  
using System.Threading;  
  
class Program  
{  
    // 定义一个委托类型，表示具有无返回值的方法  
    public delegate void AsyncDelegate();  
    static void Main()  
    {  
        // 创建委托实例  
        AsyncDelegate asyncDel = null;  
        asyncDel += PerformAsyncOperation; // 将PerformAsyncOperation方法添加到委托链中  
        // 启动异步操作  
        asyncDel.BeginInvoke(ar =>  
        {  
            // 异步操作完成后的回调函数  
            Console.WriteLine("Async operation completed.");  
            Console.ReadLine(); // 暂停程序执行，以便查看输出结果  
        }, null);  
        // 主线程继续执行其他任务  
        Console.WriteLine("Main thread is running."); 
    }  
    // 定义一个匹配委托签名的异步方法  
    public static void PerformAsyncOperation()  
    {  
        // 模拟异步操作，例如网络请求或文件I/O等  
        Thread.Sleep(5000); // 等待5秒钟  
    }  
}

在这个例子中，我们定义了一个名为 AsyncDelegate 的委托类型，表示一个没有返回值的方法。然后我们创建了一个名为 asyncDel 的 AsyncDelegate 类型的实例，并将 PerformAsyncOperation 方法添加到委托链中。接下来，我们使用 BeginInvoke 方法启动异步操作。该方法接受一个回调函数作为参数，该回调函数将在异步操作完成后被调用。在回调函数中，我们输出一条消息表示异步操作已完成。最后，我们继续执行主线程的其他任务。

通过使用委托和异步编程模式，可以方便地实现异步操作，并在操作完成后执行特定的回调函数。这使得程序更加高效和响应，并允许主线程继续执行其他任务。

十、事件

10.1、初步了解事件

10.1.1、 事件的概念

事件是一种特殊的成员，用于在类或结构的实例上通知外部代码发生了某些情况。事件可以看作是一种观察者模式，其中类可以通知其他类或对象它所发生的更改或状态变化。

事件的概念基于委托，委托是一种类型安全的函数指针，可以指向具有相同签名的方法。事件就是一种特殊的委托，用于在特定情况下触发一系列方法。

事件通过使用 event 关键字进行定义，并且必须与一个委托类型匹配。事件可以有零个或多个订阅者，这些订阅者是在类外部定义的方法，它们与事件关联并被调用当事件被触发。

事件的使用允许类与类之间以松耦合的方式进行通信，即类之间不需要知道彼此的内部实现细节。当事件发生时，订阅了该事件的任何方法都会被自动调用，从而实现响应机制。

使用事件可以使代码更加灵活和可扩展，因为类可以添加或删除事件处理器而无需修改源代码。这有助于构建响应不同事件的自定义行为和插件系统。

10.1.2 、事件的角色

事件是指能够使对象或类具备通知能力的成员。如把手机看成一个类，响铃使手机具备了通知的功能，则响铃就可以看成是事件。

10.1.3 、事件是干什么的

事件主要用于实现对象之间的松耦合通信。当一个对象的状态发生变化或发生某些动作时，它可以触发一个事件，而其他对象可以订阅这个事件，以便在事件发生时得到通知并作出响应。

通过使用事件，可以实现以下目的：

1. 通知机制：一个类可以在内部发生某些动作或状态变化时触发一个事件，通知其他类或对象。这样，外部代码可以响应这些动作或变化，而不需要直接与内部逻辑交互。
2. 解耦：事件允许类或对象之间保持低耦合度。这意味着类或对象的实现细节可以自由变化，只要事件签名保持不变，外部代码就不需要修改。这有助于提高代码的可维护性和可扩展性。
3. 响应机制：事件可以用于构建响应各种外部事件的机制。例如，在GUI应用程序中，按钮的点击事件被触发时，相关的处理方法被调用，从而响应用户的操作。
4. 插件架构：通过定义一组事件，主程序可以构建一个插件架构，允许第三方开发者为这些事件编写自定义的处理逻辑。这种架构允许程序在运行时动态加载和卸载插件，而不需要修改主程序的源代码。
5. 异步编程：事件也常用于异步编程模型中。例如，在文件I/O或网络通信操作中，触发一个事件可以表示操作已完成或出现错误。通过异步编程模式和事件，应用程序可以在等待操作完成时继续执行其他任务，从而提高性能和响应能力。

简而言之，事件就是用来通知的，现实世界中的闹铃，车站广播等都可以抽象成事件。

10.1.4 、事件的原理（事件响应机制的两个五）

10.1.4.1 、五个部分：

事件拥有者（Event Source，对象）：事件不会自己发生，它必须由一个对象触发。这个对象通常被称为事件源或事件拥有者。

事件（Event，成员）：事件是一种特殊的成员，用于让类或对象具备通知能力。它是事件源的一部分，但不会主动发生，而是由事件源的某些内部逻辑触发。

事件响应者（Event Subscriber，对象）：事件响应者是订阅了特定事件的类或对象。当事件被触发时，这些订阅者会收到通知并执行相应的操作。

事件处理器（Event Handler，方法成员或者委托）：事件处理器本质上是一个回调方法，用于处理事件的逻辑。当事件被触发时，处理器方法会被调用。

事件订阅（Event Subscription）：通过事件订阅，事件处理器与事件关联在一起。订阅过程本质上是将一个方法与特定事件关联起来，这样当事件发生时，该方法会被自动调用。

例如：闹钟响了我起床，他的五个部分分别为：闹钟-事件的拥有者，响了-事件，我-事件响应者，起床-事件处理器，我订的闹钟-事件的订阅。那么，别人的闹钟响了我为什么不起床呢？因为我没有订阅这个闹钟。

10.1.4.2、 五个动作：

1. 拥有事件：事件拥有者拥有一个事件。
2. 订阅事件：事件响应者订阅了这个事件。
3. 触发事件：事件拥有者触发了事件。
4. 通知响应者：事件响应者会被依次通知到（按照订阅的顺序）。
5. 处理事件：事件响应者根据拿到的事件参数对事件进行处理。

10.2、 事件的应用

10.2.1 、事件模型的五个组成部分

事件拥有者（Event Source，对象）：事件不会自己发生，它必须由一个对象触发。这个对象通常被称为事件源或事件拥有者。

事件（Event，成员）：事件是一种特殊的成员，用于让类或对象具备通知能力。它是事件源的一部分，但不会主动发生，而是由事件源的某些内部逻辑触发。

事件响应者（Event Subscriber，对象）：事件响应者是订阅了特定事件的类或对象。当事件被触发时，这些订阅者会收到通知并执行相应的操作。

事件处理器（Event Handler，方法成员或者委托）：事件处理器本质上是一个回调方法，用于处理事件的逻辑。当事件被触发时，处理器方法会被调用。

事件订阅（Event Subscription）：通过事件订阅，事件处理器与事件关联在一起。订阅过程本质上是将一个方法与特定事件关联起来，这样当事件发生时，该方法会被自动调用。

例如：闹钟响了我起床，他的五个部分分别为：闹钟-事件的拥有者，响了-事件，我-事件响应者，起床-事件处理器，我订的闹钟-事件的订阅。那么，别人的闹钟响了我为什么不起床呢？因为我没有订阅这个闹钟。

10.2.2 、事件模型的四种关联模式

1. 事件拥有者与事件响应者的关联：事件拥有者拥有一个或多个事件，而事件响应者通过订阅这些事件来接收通知。
2. 事件与事件处理器的关联：事件处理器是与特定事件相关联的方法。通过订阅事件，可以将事件处理器与事件关联起来。
3. 事件处理器与事件响应者的关联：事件处理器是事件响应者中的方法成员，用于处理事件的逻辑。通过订阅事件，将事件处理器与事件关联，同时确定了事件的响应者。
4. 事件响应者与事件的关联：通过订阅操作，事件响应者与特定事件建立关联，从而成为事件的接收者和处理者。

10.2.3、事件的使用场景

1. GUI应用程序：在GUI应用程序中，事件用于响应用户的交互操作，如按钮点击、鼠标移动和键盘输入等。事件驱动机制使得程序能够响应用户的实时操作，提供良好的用户体验。
2. 异步编程：在异步编程中，事件用于处理异步任务，例如文件I/O、网络通信和定时器等。通过事件，可以方便地处理异步任务的结果，避免阻塞主线程和提高程序的响应性能。
3. 发布-订阅模式：发布-订阅模式是一种常用的消息传递模式，其中事件扮演着重要的角色。在这种模式中，发布者发布事件，而订阅者订阅感兴趣的事件。当事件发生时，发布者通知所有订阅了该事件的订阅者，从而实现消息的传递和共享。
4. 自定义控件：在自定义控件的开发中，事件用于实现控件的交互功能。例如，在Windows窗体应用程序中，可以定义控件的事件来响应用户的操作，如按钮点击、文本框内容变化等。
5. 多线程编程：在多线程编程中，事件用于线程间的通信和协调。通过事件，一个线程可以通知另一个线程某个动作或状态的变化，从而实现线程间的协作和同步。
6. 日志记录和监控：事件可以用于实现日志记录和系统监控功能。当某个特定事件发生时，可以触发一个事件处理器来记录日志或执行相应的操作，例如发送警报或触发某个流程。
7. 游戏开发：在游戏开发中，事件用于处理用户的输入和游戏逻辑的更新。通过事件，游戏可以响应用户的操作并实时更新游戏状态。

10.3、事件的声明

10.3.1、 完整声明

using System;  
  
public class Bus  
{  
    // 声明一个名为"BusAlarm"的事件  
    public event EventHandler BusAlarm;  
  
    // 一个模拟公交广播的方法  
    public void AnnounceBusArrival()  
    {  
        Console.WriteLine("乘车广播响起: 公交车即将到达！");  
        OnBusAlarm(); // 触发事件  
    }  
  
    // 触发事件的私有方法，通常用于内部逻辑  
    private void OnBusAlarm()  
    {  
        // 检查是否有订阅者（事件处理器）  
        if (BusAlarm != null)  
        {  
            // 如果有订阅者，则触发事件  
            BusAlarm(this, EventArgs.Empty);  
        }  
    }  
}  
  
public class Passenger  
{  
    public void QueueUp()  
    {  
        Console.WriteLine("听到广播后，我去排队等候上车。");  
    }  
}  
  
class Program  
{  
    static void Main(string[] args)  
    {  
        Bus bus = new Bus(); // 创建一个公交车对象  
        Passenger passenger = new Passenger(); // 创建一个乘客对象  
  
        // 订阅公交车的事件，当"乘车广播响起"时，执行乘客的QueueUp方法  
        bus.BusAlarm += passenger.QueueUp;  
  
        // 模拟公交车广播响起的情况  
        bus.AnnounceBusArrival();  
    }  
}

在上面的代码中，我们创建了一个Bus类和一个Passenger类。Bus类有一个名为BusAlarm的事件，当调用AnnounceBusArrival方法时，它会触发这个事件。Passenger类有一个QueueUp方法，当它被添加为BusAlarm事件的订阅者时，这个方法会在事件被触发时自动执行。在Main方法中，我们创建了一个公交车对象和一个乘客对象，并让乘客对象订阅公交车的事件。最后，我们模拟公交车广播响起的情况，这将触发事件并执行乘客的QueueUp方法。

10.3.2、 简略声明

public class Car  
{  
    // 简略声明事件  
    public event EventHandler<string> Alarm;  
  
    // 触发事件的方法  
    public void TriggerAlarm()  
    {  
        // 触发事件，传递一个字符串参数  
        Alarm?.Invoke(this, "汽车警报响起！");  
    }  
}  
  
class Program  
{  
    static void Main(string[] args)  
    {  
        Car car = new Car(); // 创建一个汽车对象  
        // 订阅汽车的事件，当"汽车警报响起"时，执行Console.WriteLine方法  
        car.Alarm += (sender, e) => Console.WriteLine(e); ;  
        // 触发汽车警报事件  
        car.TriggerAlarm();  
    }  
}

在上面的代码中，我们创建了一个Car类，它有一个简略声明的事件Alarm。当调用TriggerAlarm方法时，它会触发这个事件。我们使用?操作符来检查是否有订阅者（事件处理器）订阅了该事件，如果有，则通过Invoke方法触发事件并传递一个字符串参数。在Main方法中，我们创建了一个汽车对象，并订阅了汽车的事件。当事件被触发时，它会执行一个Lambda表达式，将事件参数打印到控制台。

10.3.3、 为什么需要事件

1. 实现松耦合通信：事件允许程序组件以松耦合的方式进行通信。这意味着一个组件（发布者）可以发布事件，而另一个组件（订阅者）可以订阅这些事件，而不必知道发布者是如何实现的。这样可以提高代码的可维护性和可重用性。
2. 提供实时响应：事件在需要实时响应的情况下非常有用，例如在GUI应用程序中响应用户的点击或移动操作，或在网络应用程序中处理接收到的数据包。通过事件，程序可以及时地响应用户输入或其他外部动作。
3. 通知机制：事件是一种通知机制，允许一个组件通知其他组件某个动作或状态已经发生或改变。例如，当文件被成功保存时，可以触发一个事件来通知其他组件。
4. 消息传递：事件可以用于实现消息传递系统，其中组件可以发布和订阅消息。这与发布-订阅模式类似，其中发布者发布事件，而订阅者订阅感兴趣的事件。
5. 异步编程：在异步编程中，事件用于处理异步任务的结果。例如，在文件I/O或网络通信中，可以使用事件来处理异步操作完成后的回调。
6. 跨线程通信：在多线程编程中，事件可以用于线程间的通信和同步。通过事件，一个线程可以通知另一个线程某个动作或状态的变化。
7. 自定义控件开发：在Windows窗体应用程序或WPF应用程序中，自定义控件常常使用事件来响应用户的交互操作，如按钮点击、文本框内容变化等。

10.3.4、 事件的命名规范

1. 使用动词或动词短语：事件名称通常以动词或动词短语开始，因为事件表示一个动作或状态的变化。例如，Click、Load、MouseDown等。
2. 使用PascalCasing：事件名称应使用PascalCasing（每个单词首字母大写）的命名约定。这是C#的常规命名规范。
3. 避免使用下划线：在C#中，下划线在事件命名中不是常见的约定。相反，通常使用驼峰式命名法（camelCase）来拼接多个单词。
4. 前缀或后缀：避免在事件名称前添加“On”前缀或后缀，除非存在历史或重载原因。现在推荐使用动词或动词短语来明确表示事件的触发。
5. 避免使用“Before”和“After”：避免使用“Before”和“After”前缀和后缀来表示事件之前或之后发生的情况。相反，应使用动词时态来表示事件的时间顺序，如Loading、Loaded等。
6. 复合词：当需要描述一个事件的更多详细信息时，可以使用复合词来形成新的名称。例如，DocumentOpen、UserLoginFailed等。
7. 保持一致性：在同一个项目中，应保持事件命名的统一性。遵循相同的命名规范有助于代码的可读性和维护性。
8. 避免使用数字和特殊字符：避免在事件名称中使用数字和特殊字符，除非有特定的技术需求或API要求。
9. 考虑缩写：在某些情况下，为了简洁性，可以考虑使用事件的缩写名称。但要确保缩写是众所周知的，并且不会引起混淆。
10. 遵循类型命名规范：如果事件属于某个类或接口的一部分，应遵循该类或接口的命名规范。例如，如果类名以名词开头，则事件名称也应当以动词开头。

10.4、事件与委托的关系

1. 委托是事件的基础：事件本质上是委托类型的一个成员，用于封装一个或多个方法作为事件处理器。委托是一种类型安全的变量，可以用来存储方法的引用，并且可以调用这些方法。事件成员本质上是一个私有委托字段和两个用于添加和移除事件处理器的公有方法。
2. 事件的内部实现：事件的内部实现使用了委托。当一个事件被触发时，与该事件关联的所有委托（即事件处理器）会被依次调用。通过使用委托，事件能够实现松耦合的通信，使得事件的发送者和接收者之间不需要显式地相互引用。
3. 订阅关系：事件通过订阅关系将事件的拥有者和事件的响应者关联起来。订阅关系通过将一个方法（即事件处理器）与特定事件关联起来实现。通过使用 += 运算符来订阅事件，将事件处理器添加到事件的调用列表中。同样地，使用 -= 运算符来取消订阅事件，从事件的调用列表中移除事件处理器。
4. 多播委托：委托是C#中的多播委托类型，这意味着一个委托可以代表多个方法。事件作为委托的成员，也支持多播特性。这意味着一个事件可以有多个关联的事件处理器，当事件被触发时，所有注册的事件处理器都会被依次调用。

十一、泛型

11.1、泛型概述

泛型是C#中一个强大的特性，它允许开发者在类、结构、接口和方法中定义类型参数化，以便创建更加灵活和可重用的代码。泛型的主要目的是提高代码的重用性、类型安全性和性能。

11.1.1、泛型的定义

泛型是一种编程技术，它允许在定义类、接口或方时使用类型参数。这些类型参数在实例化泛型类型时被具体的类型替换。通过这种方式，可以创建适用于任何数据类型的可重用代码。

11.1.2、泛型的目的

1. 提高代码重用性：通过使用泛型，你可以编写适用于多种数据类型的代码，而无需为每种数据类型编写特定的实现。这大大减少了重复的代码，并提高了开发效率。
2. 增加类型安全性：使用泛型可以避免运行时错误，因为编译器可以在编译时捕获许多常见的类型不匹配问题。此外，由于泛型在编译时检查类型，因此可以提供更好的性能和内存使用。
3. 减少冗余代码：通过编写泛型代码，你可以避免编写重复的逻辑，只需编写一次代码就可以应用于多种类型。这使得代码更简洁、易于维护。
4. 提供更好的性能：泛型可以通过在编译时生成特定类型的代码来提高性能。这避免了运行时的装箱和拆箱操作，从而提高了性能。
5. 支持协变和逆变：通过使用泛型，你可以定义协变和逆变关系，这意味着你可以使用子类型的实例替换泛型参数，这有助于实现更灵活的集合操作。

11.1.3、泛型与Object类型的对比

11.1.3.1、类型安全性

泛型：泛型提供了编译时的类型安全。当你使用泛型类或方法时，你必须在编译时指定具体的类型参数。这允许编译器捕获可能的类型错误，并提供强类型检查。

Object 类型：Object 是所有类型的基类，它可以存储任何类型的值。但是，当你使用 Object 类型时，你会失去编译时的类型信息，这可能导致运行时的类型错误。此外，当你需要对 Object 类型的值执行操作时，通常需要进行显式的类型转换或使用反射，这可能会增加出错的可能性。

11.1.3.1、性能

泛型：泛型可以提供更好的性能，因为它允许编译器生成针对特定类型的优化代码。这避免了装箱和拆箱操作，减少了类型转换的开销，并允许值类型保持其值语义。

Object 类型：使用 Object 类型可能会导致性能下降，特别是当涉及值类型时。因为值类型在存储为 Object 时需要进行装箱操作，从 Object 提取值类型时需要进行拆箱操作。这些操作涉及额外的内存分配和类型转换开销。

11.1.3.3、代码重用和可读性

泛型：泛型允许你编写可重用的代码逻辑，该逻辑可以适用于多种类型，而无需为每种类型编写特定的代码。这提高了代码的重用性，并减少了维护工作量。此外，泛型代码更具可读性，因为类型参数化使得代码的意图更加明确。

Object 类型：虽然使用 Object 类型可以实现一定程度的代码重用，但它通常会导致更多的运行时类型检查和类型转换代码。这可能会降低代码的可读性和可维护性。

11.1.4、泛型的优势

类型安全：泛型的主要优势之一是提供类型安全。在非泛型编程中，许多操作都需要进行类型转换，这增加了出错的可能性。使用泛型，你可以明确指定类型参数，编译器可以在编译时检查类型错误，从而提高安全性。

代码重用：泛型通过创建独立于特定类型的类和方法，显著提高了代码的重用性。这意味着你可以编写一次代码，并使用不同的类型参数多次调用该代码。这减少了重复的代码，并提高了开发效率。

性能优化：泛型通过减少类型转换和避免装箱和拆箱操作，可以提高性能。在非泛型编程中，将简单类型作为 Object 传递会引起装箱和拆箱操作，这些操作具有较大的开销。使用泛型可以避免这些开销，从而提高性能。

灵活性：泛型提供了很大的灵活性，允许你编写适用于多种数据类型的代码。这使得你可以在不牺牲类型安全性的情况下，更加灵活地处理数据。

可扩展性：泛型使得代码更容易扩展。你可以定义泛型接口、泛型类、泛型方法等，并在需要时添加新的实现。这使得代码更容易适应未来的需求变化。

二进制代码重用：由于泛型在编译时实例化，生成的二进制代码可以重用。这减少了程序的大小，并提高了加载性能。

11.2、泛型基础

11.2.1、泛型类

11.2.1.1、泛型类的声明

声明一个泛型类使用语法，其中T是一个类型参数。类型参数用于指定泛型类中使用的数据类型。

public class GenericClass<T>  
{  
    // 泛型类的成员  
}

11.2.1.2、创建泛型类的实例

要创建泛型类的实例，需要指定类型参数的值。

var instance = new GenericClass<int>(); // 使用 int 作为类型参数  
var otherInstance = new GenericClass<string>(); // 使用 string 作为类型参数

11.2.1.3、泛型类的约束

在某些情况下，可能希望对泛型类使用的类型参数施加一些限制。这可以通过使用约束来实现。约束告诉编译器类型参数必须满足某些条件。

引用类型约束 (where T : class)：该约束指定类型参数必须是引用类型。

public class GenericClass<T> where T : class  
{  
    // 泛型类的成员  
}

使用此约束，可以确保泛型类中的某些成员（如非静态方法）仅适用于引用类型。

值类型约束 (where T : struct)：该约束指定类型参数必须是值类型。

public class GenericClass<T> where T : struct  
{  
    // 泛型类的成员  
}

使用此约束，可以确保泛型类中的某些成员（如非静态方法）仅适用于值类型。

基类约束 (where T : BaseType)：该约束指定类型参数必须是指定的基类或其派生类。

public class GenericClass<T> where T : BaseType  
{  
    // 泛型类的成员  
}

使用此约束，可以确保泛型类中的某些成员仅适用于继承自特定基类的类型。

接口约束 (where T : IInterface)：该约束指定类型参数必须实现指定的接口或其派生接口。

public class GenericClass<T> where T : IInterface  
{  
    // 泛型类的成员  
}

使用此约束，可以确保泛型类中的某些成员仅适用于实现了特定接口的类型。

自定义约束：还可以定义自己的约束，通过在泛型类中定义一个静态方法，并在约束表达式中调用它。

public class GenericClass<T> where T : new() // 自定义约束，表示T必须有一个无参构造函数  
{  
    // 泛型类的成员和构造函数调用逻辑等。  
}

11.2.2、泛型接口

11.2.2.1、泛型接口的声明

声明一个泛型接口使用相同的语法，其中T是一个类型参数。类型参数用于指定泛型接口中使用的数据类型。

public interface GenericInterface<T>  
{  
    // 泛型接口的成员  
}

11.2.2.2、实现泛型接口

要实现一个泛型接口，需要创建一个类或结构体，并实现接口中定义的所有成员。在实现泛型接口时，需要指定与接口相同的类型参数。

public class MyClass : GenericInterface<int> // 实现具有 int 类型参数的泛型接口  
{  
    public int GetValue() // 实现接口中的方法  
    {  
        return 42; // 返回一个整数值  
    }  
}

需要注意的是，也可以通过定义泛型方法来间接实现泛型接口。泛型方法是类的成员，它返回一个值或者没有返回值，并可以接受类型参数。通过定义泛型方法，可以编写适用于多种数据类型的通用逻辑，并在需要时将其应用于不同的类型。

11.2.3、泛型方法

11.2.3.1、泛型方法的声明

声明一个泛型方法使用相同的语法，其中T是一个类型参数。类型参数用于指定泛型方法中使用的数据类型。

public static int GenericMethod<T>(T arg)  
{  
    // 泛型方法的实现  
    return (int)arg; // 假设T是可转换为int的类型  
}

11.2.3.2、调用泛型方法

要调用一个泛型方法，需要指定类型参数的值。类型参数的值可以是任何有效的C#类型。

int result = GenericMethod<int>(42); // 调用具有 int 类型参数的泛型方法，并传递一个 int 类型的参数  
Console.WriteLine(result); // 输出 42

11.2.3.3、类型推断

编译器可以自动推断泛型方法的类型参数值。当在调用泛型方法时，如果没有显式指定类型参数的值，编译器将根据传递给方法的实际参数类型来推断类型参数的值。

string str = "Hello";  
int result = GenericMethod(str); // 调用泛型方法时没有指定类型参数的值，编译器将自动推断为 string 类型  
Console.WriteLine(result); // 输出 0，因为 string 不能直接转换为 int（这里仅为示例）

11.2.4、泛型委托

11.2.4.1、泛型委托的声明

泛型委托允许定义一个委托，该委托可以引用任何返回类型和任何参数类型的任何方法。声明泛型委托时，使用delegate关键字后跟泛型标记。

public delegate T GenericDelegate<T>(T arg); // 泛型委托，T 是返回类型，T 是参数类型

11.2.4.2、使用泛型委托

要使用泛型委托，需要创建一个委托实例，并将其指向一个具有匹配签名的方法。然后可以通过该委托调用该方法。

public class Program  
{  
    public static void Main()  
    {  
        // 创建泛型委托实例并指向一个方法  
        GenericDelegate<string> del = new GenericDelegate<string>(PrintString);  
          
        // 通过委托调用方法  
        del("Hello, World!"); // 输出 "Hello, World!"  
    }  
      
    // 与泛型委托签名匹配的方法  
    public static string PrintString(string str)  
    {  
        Console.WriteLine(str);  
        return str; // 返回字符串作为泛型委托的返回类型  
    }  
}

在此示例中，我们创建了一个名为del的GenericDelegate实例，并将其指向名为PrintString的方法。然后我们通过委托del调用PrintString方法，并传递字符串参数"Hello, World!"。由于PrintString方法的签名与委托签名匹配（返回类型为string，参数类型为string），因此该方法可以通过委托进行调用。最后，我们打印出传递给方法的字符串参数，并返回它作为委托的返回值。

11.3、泛型高级特性

11.3.1、泛型约束

where子句的使用：可以使用where子句来指定泛型参数的类型约束。

public class Box<T> where T : IEquatable<T>  
{  
    // 类的实现  
}

在上面的例子中，T必须实现IEquatable接口。这样的约束确保了可以安全地对泛型类型进行比较操作。

主约束和次要约束：可以使用多种约束来限制泛型参数的类型。主要的约束包括：

• class：表示T必须是引用类型。
• struct：表示T必须是值类型。
• new()：表示T必须有一个无参数的构造函数。
• ：表示T必须是一个类型参数。这是默认的约束，如果没有指定任何其他约束，那么T必须是类型参数。
  这些约束可以组合使用，以提供更具体的类型限制

public class MyGenericClass<T> where T : class, IMyInterface, new()  
{  
    // 类的实现  
}

在上面的例子中，T必须是一个引用类型、实现IMyInterface接口，并且必须有一个无参数的构造函数。

构造函数约束：通过使用new()约束，可以要求泛型类型具有一个无参数的公共构造函数。这在创建泛型对象的实例时非常有用。

public class MyGenericClass<T> where T : new()  
{  
    public T CreateInstance()  
    {  
        return new T(); // 调用无参数构造函数创建新实例  
    }  
}

值类型和引用类型约束：通过使用struct和class约束，可以限制泛型参数是值类型还是引用类型。

public class MyGenericClass<T> where T : struct // T 必须是值类型  
{  
    // 类的实现  
}

public class MyGenericClass<T> where T : class // T 必须是引用类型  
{  
    // 类的实现  
}

继承约束和接口约束：通过指定一个或多个类或接口约束，可以限制泛型参数的类型必须是某个类或必须实现某个接口。

public class MyGenericClass<T> where T : MyBaseClass, IMyInterface // T 必须是 MyBaseClass 的派生类并且实现 IMyInterface 接口  
{  
    // 类的实现  
}

或者使用多个接口约束：

public class MyGenericClass<T> where T : IMyInterface1, IMyInterface2 // T 必须实现 IMyInterface1 和 IMyInterface2 接口  
{  
    // 类的实现  
}

11.3.2、协变与逆变

11.3.2.1、协变（Covariance）

协变允许将派生类的实例赋值给基类的引用。在泛型接口或委托中，可以使用out关键字来声明协变参数。这意味着，如果一个泛型接口或委托有一个协变参数，那么可以传递一个更具体的类型（派生自原始类型的类型）给这个参数。

interface ICovariant<out T>  
{  
    T Get();  
}

在上面的例子中，T被声明为协变参数，这意味着你可以有一个ICovariant的实例，或者有一个更具体的派生自string的类型。

11.3.2.2、逆变（Contravariance）

逆变允许将基类的实例赋值给派生类的引用。在泛型接口或委托中，可以使用in关键字来声明逆变参数。这意味着，如果一个泛型接口或委托有一个逆变参数，那么可以传递一个更具体的类型（派生自原始类型的类型）给这个参数。

interface IContravariant<in T>  
{  
    void Set(T value);  
}

在上面的例子中，T被声明为逆变参数，这意味着你可以有一个IContravariant