c#委托与事件（详解）

委托：方法与方法的桥梁

在编程的世界里，委托是一个强大的工具，它允许我们将方法作为参数传递。为了更好地理解这个概念，让我们从一个简单的例子开始。假设我们有一个简单的问候程序，它可以根据不同的语言输出不同的问候语。

我们有英文和中文两种问候方式：

```csharp

public void EnglishGreeting(string name) {

Console.WriteLine("Morning, " + name);

}

public void ChineseGreeting(string name) {

Console.WriteLine("早上好, " + name);

}

```

接着，我们希望有一个方法可以灵活选择使用哪种问候方式：

```csharp

public enum Language {

English,

Chinese

}

public void GreetPeople(string name, Language lang, Action greetAction) {

greetAction(name); // 这里调用传递进来的方法，执行问候动作

}

```

当我们想要向某人打招呼时，我们通常会使用一个特定的问候语，如“早上好”或“你好”。但现在，想象一下如果我们有一个功能，可以让用户选择他们想使用的问候方式。那么，我们可以将这个选择封装在一个参数里，称之为“MakeGreeting”。就像我们给名字（name）赋值一样，用户在调用GreetPeople()方法时也可以给MakeGreeting赋予特定的值，比如ChineseGreeting或EnglishGreeting等。

一旦我们有了这个参数，我们就可以在GreetPeople()方法内部使用它，就像使用其他参数一样。这里的MakeGreeting有点特别，因为它代表的是一种方法，而不是一个具体的值。这意味着我们需要以一种特殊的方式来处理它。那么，我们应该如何定义这个特殊的参数呢？

我们知道MakeGreeting应该代表一种方法，这意味着它应该能够接受某些输入并产生某些输出。在这种情况下，我们的MakeGreeting代表的方法接受一个名字（name）作为参数，并且没有返回值。这样的方法可以使用委托来定义。委托是一种特殊的类型，它允许我们将方法作为参数传递、赋值或在其他方法中调用。在这个情境下，我们可以创建一个名为GreetingDelegate的委托，其签名与我们的ChineseGreeting()和EnglishGreeting()方法相匹配。

这样，我们可以在GreetPeople()方法中接受一个GreetingDelegate类型的参数MakeGreeting。当用户调用这个方法时，他们可以传递一个符合GreetingDelegate签名的委托实例作为MakeGreeting的值。然后，在方法体内，我们可以直接调用这个传递进来的委托。

```csharp

public void GreetPeople(string name, GreetingDelegate makeGreeting) {

makeGreeting(name); // 直接调用传递进来的委托

}

```

现在，我们可以使用任何符合GreetingDelegate签名的自定义方法来作为MakeGreeting的值传递给GreetPeople()方法。这意味着我们可以动态地决定使用哪个方法来打招呼，是ChineseGreeting还是EnglishGreeting等。这种方式使得我们的代码更加灵活和可扩展。委托的奥秘：方法与委托的完美结合

在编程的世界里，委托是一个神奇的存在，它允许我们将方法作为参数传递，从而实现代码的灵活性和可扩展性。让我们进一步委托的奥秘，并结合实例揭示其强大的功能。

我们来了解什么是委托。委托是一个类，它定义了方法的类型。通过委托，我们可以将方法动态地赋给参数，从而在程序运行时灵活地调用这些方法。这种机制使得我们可以避免在程序中大量使用If-Else或Switch语句，提高代码的可维护性和可读性。

接下来，让我们看一个使用委托的实例。在这个例子中，我们定义了一个名为GreetingDelegate的委托，它接受一个字符串参数name，并返回一个void类型的结果。我们还有两个静态方法：EnglishGreeting和ChineseGreeting，它们分别输出英文和中文的问候语。

现在，我们有一个名为GreetPeople的方法，它接受一个名字和一个GreetingDelegate类型的委托作为参数。在方法内部，我们通过调用委托来执行相应的问候方法。这意味着我们可以根据需要动态地选择不同的问候方法，而不需要修改GreetPeople方法的代码。

在Main方法中，我们创建了两个GreetingDelegate类型的委托实例，并将EnglishGreeting和ChineseGreeting方法分别绑定到这些委托上。然后，我们调用GreetPeople方法，并传递一个名字和相应的委托实例。程序将根据传递的委托实例输出相应的问候语。

除了将单个方法绑定到委托上，委托还有一个强大的特性：可以将多个方法绑定到同一个委托上。当调用这个委托的时候，将依次调用其所绑定的所有方法。这使得我们可以轻松地组合多个方法，实现更复杂的功能。

通过这个例子，我们可以看到委托的强大功能。它允许我们将方法作为参数传递，避免了大量的条件判断代码，提高了代码的可读性和可维护性。委托还可以将多个方法绑定到一起，实现更复杂的功能。这些特性使得委托成为C编程中不可或缺的一部分。在这个编程的示例中，我们看到了委托（Delegate）的神奇之处。这是一种特殊的类型，可以将其指向任何一个具有特定签名的方法。让我们深入这个代码，并尝试以一种更加生动、吸引人的方式来解释它。

想象一下，你有一个名为“GreetingDelegate”的委托，它等待着被赋予一个或多个问候方法。在程序的起始点，你创建了一个名为“delegate1”的GreetingDelegate类型的变量。这里有个关键点需要注意：首次赋值给这个变量时，你使用的是赋值操作符“=”，而不是绑定操作符“+=”。这意味着你将委托指向了第一个方法——EnglishGreeting。

接下来，你使用“+=”操作符将另一个方法——ChineseGreeting绑定到同一个委托变量上。这意味着当你调用delegate1时，它会依次执行这两个方法。这是一个非常强大的功能，允许你在运行时动态地改变委托调用的方法。

你可能会想：“为什么不直接使用委托来调用这些方法，而不是通过GreetPeople方法？”答案是完全可以这样做。实际上，通过委托直接调用方法与使用GreetPeople方法本质上是相同的。GreetPeople方法可能提供了额外的逻辑处理或参数检查等功能，这在简化代码中可能没有被明确展示。

关于编译错误“没有0个参数的重载”，这是因为当你尝试使用“new GreetingDelegate()”创建一个新的委托实例时，必须指定一个现有的方法作为参数。而当你使用“+=”来绑定方法时，实际上是在已有的委托实例上添加新的方法引用，不需要额外的参数。

让我们再次回顾一下这个编程示例的核心思想：通过委托将多个方法组合在一起，然后一次性调用它们。这种功能使得代码更加灵活和可重用，尤其是在处理事件或回调函数时非常有用。尽管在此过程中可能会遇到一些编译错误，但正是这些挑战让我们不断和成长。当然可以。当我们谈到委托时，它就像是一个可以指向任何方法的引用。我们可以动态地将多个方法绑定到同一个委托实例上，并在需要时依次调用它们。下面我们来详细一下这个概念，并给出一个具体的实现例子。

在C中，委托允许我们将多个方法关联到一个变量上。一旦委托变量被赋予一个方法，我们就可以通过简单的赋值操作来添加或移除绑定的方法。这就是我们所说的委托的“+=”和“-=”操作符的用法。通过这种方式，我们可以构建一个方法链，按照我们自己的需要来调用这些方法。接下来让我们回到我们的示例中来。

假设我们在一个名为“GreetingManager”的类中有一个方法“GreetPeople”，我们希望这个方法能够根据提供的委托变量来调用不同的问候方法。为此，我们可以创建一个名为“GreetingDelegate”的委托，并定义两个静态方法“EnglishGreeting”和“ChineseGreeting”。接下来，我们可以在Main方法中创建一个GreetingManager对象，并使用委托变量来调用这两个方法。让我们看一下这个过程是如何实现的。

我们定义委托和静态方法：

```csharp

public delegate void GreetingDelegate(string name); // 定义委托类型

public class GreetingManager { // 定义GreetingManager类

public void GreetPeople(string name, GreetingDelegate greetingMethod) { // 方法接受一个委托作为参数

greetingMethod(name); // 执行委托指向的方法

}

}

private static void EnglishGreeting(string name) {

Console.WriteLine("Morning, " + name); // 英文问候方法

}

private static void ChineseGreeting(string name) {

Console.WriteLine("早上好, " + name); // 中文问候方法

}

```

然后，在Main方法中创建GreetingManager对象并使用委托变量来调用这些方法：

```csharp

static void Main(string[] args) {

GreetingManager gm = new GreetingManager(); // 创建GreetingManager对象实例

GreetingDelegate combinedGreetings = EnglishGreeting; // 初始化委托变量指向英文问候方法

combinedGreetings += ChineseGreeting; // 添加中文问候方法到委托变量中

combinedGreetings -= EnglishGreeting; // 如果需要的话，移除英文问候方法（可选步骤）

代码与演绎：从打招呼的委托看面向对象设计

在编程的世界里，委托是一种特殊的类型，它允许我们将方法作为参数传递。当我们谈论面向对象的设计时，封装是一个核心概念，旨在隐藏对象的内部状态和行为，只通过对象提供的方法与外部交互。那么，如何将委托与封装完美结合呢？让我们通过一个简单的打招呼的例子来。

假设我们有一个 GreetingManager 类，它有一个 GreetPeople 方法，用来向某人打招呼。我们可能希望通过委托来注册不同的打招呼方式。原始的代码大致如下：

我们首先对 GreetingManager 类进行改造，使其内部声明一个 GreetingDelegate 类型的变量，用于存储或组合多种打招呼的方法。在客户端代码中，我们可以对这个变量进行赋值和组合。

这种设计存在一些问题。在调用 GreetPeople 方法时，我们需要显式地传递这个委托变量。这显得有些冗余，而且破坏了封装性。理想情况下，类的内部状态应该被隐藏，只通过公共接口与外界交互。

于是，我们对 GreetingManager 类进行进一步的改进。我们将 delegate1 声明为私有字段，然后在 GreetPeople 方法中检查这个字段是否非空。如果非空，就通过它调用相应的方法。这样一来，客户端代码可以注册多种打招呼的方式，但在调用 GreetPeople 时无需关心具体的委托实现。

这样的设计仍然存在问题。虽然委托现在被封装在 GreetingManager 类内部，但由于它是私有的，客户端无法直接对其进行操作。委托的目的是为了实现方法的动态调用和组合，如果将其隐藏起来，就失去了其存在的意义。我们需要找到一种平衡，既保证封装性，又允许客户端对委托进行操作。

一种可能的解决方案是将委托声明为 public，但在类内部进行管理。这意味着客户端可以注册和组合打招呼的方式，但由于有类的封装机制，他们不能直接访问或修改内部的委托变量。这样，我们既利用了委托的动态特性，又保证了对象的封装性。

当我们编程中的注册方法时，可能会遇到使用“=”进行赋值和使用“+=”进行注册的情况。这两种方式都是为了将方法绑定到委托上。尽管它们在调用时的顺序不同，实质上的区别却让人有些困惑。

假如我们暂时抛开这些固有的思维，设想一下，如果我们的delegate1不是一个委托类型，而是一个字符串类型，我们会怎么做呢？答案是通过属性对字段进行封装。那么，在这种情境下，Event应运而生。它就像是一个封装了委托类型变量的容器，确保了无论我们在类的内部如何声明，它总是保持着一种私有状态。而在类的外部，事件提供了与声明时相同访问权限的“+=”注册和“-=”注销方式。

```csharp

public class GreetingManager {

// 在这里我们声明了一个事件

public event GreetingDelegate MakeGreet;

public void GreetPeople(string name) {

MakeGreet(name);

}

}

```

可以看到，MakeGreet事件的声明与之前的委托变量delegate1的声明之间的唯一区别在于多了一个event关键字。结合之前的讲解，现在你应该能够明白，事件其实并不难以理解。它的本质就是声明了一个经过封装的委托类型变量。

```csharp

static void Main(string[] args) {

GreetingManager gm = new GreetingManager();

// gm.MakeGreet = EnglishGreeting; // 编译错误1

gm.MakeGreet += ChineseGreeting;

gm.GreetPeople("Jimmy Zhang");

}

```

尽管我们尝试通过赋值方式访问MakeGreet事件，却会收到编译错误，提示“Delegate.GreetingManager.MakeGreet”只能出现在“+=”或“-=”的左边（从类型“Delegate.GreetingManager”中使用时除外）。这是因为尽管我们在GreetingManager里将MakeGreet声明为public，但实际上MakeGreet会被编译成一个私有字段。这就解释了为什么会出现上述的编译错误。

进一步MakeGreet所产生的代码，我们可以看到：

```csharp

private GreetingDelegate MakeGreet; // 对事件的声明 实际是 声明一个私有的委托变量

[MethodImpl(MethodImplOptions.Synchronized)]

public void add_MakeGreet(GreetingDelegate value) {

this.MakeGreet = (GreetingDelegate)Delegatebine(this.MakeGreet, value);

}

[MethodImpl(MethodImplOptions.Synchronized)]

public void remove_MakeGreet(GreetingDelegate value) {

this.MakeGreet = (GreetingDelegate)Delegate.Remove(this.MakeGreet, value);

}

```

现在我们已经明确，MakeGreet事件确实是一个GreetingDelegate类型的委托。不管它的访问权限是public还是private，它总是被声明为private。它还有两个方法：add_MakeGreet和remove_MakeGreet，分别用于注册和注销委托类型的方法。也就是说，“+=”对应add_MakeGreet，“-=”对应remove_MakeGreet。这样的设计使得事件在编程中能够更灵活地管理方法的注册和注销。在编程的世界中，我们常常需要处理不同组件间的交互与通信。这其中的一个关键概念就是委托和事件，它们是实现观察者设计模式（Observer Design Pattern）的重要工具。今天，我们将深入委托、事件以及它们在实现观察者模式中的应用。

让我们理解什么是委托。在C中，委托是一种特殊的类型，它表示引用方法的对象。这意味着你可以使用委托将方法作为参数传递，或者将方法作为返回值返回。这为我们提供了一种灵活的方式来处理事件和回调函数。在定义委托时，我们实际上是在描述一个签名，这个签名表示一个方法的返回类型、参数类型和数量。例如，我们可以定义一个名为“GreetingDelegate”的委托，它接受一个字符串参数并返回void。当编译器遇到这样的定义时，它会生成一个特定的类来处理这种方法的调用。

接下来，我们谈谈事件。事件是类中的特殊成员，它是带有附加功能的委托。事件允许一个类通知其他类关于某些特定的行为或状态变化。事件的真正强大之处在于它们提供了一种机制来封装代码中的因果关系，使得类之间的耦合度降低。当某个事件发生时（例如水温超过95度），可以触发一系列的动作（如发出警报、显示提示等）。

现在，让我们以一个实际的例子来展示这些概念的应用。假设我们有一个高档热水器，当水温达到一定值时，我们需要进行不同的操作来通知用户。为了模拟这个过程，我们可以创建一个热水器类（Heater），并在其中定义烧水的方法（BoilWater）。当水温超过某个阈值时（例如95度），我们触发一个事件，该事件会调用不同的方法来完成不同的操作，如发出语音警报和显示提示。为了实现这一点，我们需要使用观察者模式。在这个模式中，热水器作为被观察者（Subject），而警报器和显示器则是观察者（Observer）。当热水器状态发生变化时（如水烧开），它会通知所有注册的观察者采取相应的行动。通过这种方式，我们可以将热水器的核心功能与警报和显示功能分开，提高了代码的模块化和可重用性。为了实现观察者模式，我们可以使用委托和事件来实现对象之间的解耦通信。这样一来，不同的组件可以独立开发、测试和维护，同时保持系统的高效和稳定。

委托和事件是编程中非常重要的概念，它们为我们提供了一种灵活的方式来处理对象之间的交互和通信。通过深入理解这些概念并正确应用它们，我们可以构建出更加健壮、可维护和可扩展的代码结构。在这个例子中，我们展示了如何使用委托和事件来实现观察者模式，从而实现了不同组件之间的解耦通信。这是构建复杂系统时的一种常见做法，有助于提高代码的质量和效率。在日常生活的小事中，我们或许可以发现一些程序设计模式的影子。想象一下家中的热水器、警报器和显示器这三者之间的关系，便能窥探出观察者模式（Observer Pattern）的奥妙。现在让我们用代码来重现这一模式，深入理解其运作机制。

我们来看热水器的工作流程。当水温逐渐升高时，热水器需要通知警报器和显示器，让它们做出相应的反应。这里的热水器、警报器和显示器分别对应着观察者模式中的被观察对象（Subject）和观察者（Observer）。

类定义：

热水器（Subject）:

```csharp

public class Heater : Subject

{

private int temperature;

public void BoilWater()

{

for (int i = 0; i <= 100; i++)

{

temperature = i;

NotifyObservers($"当前水温：{temperature}度"); // 当水温变化时通知所有观察者

}

}

}

```

这里我们引入了`Subject`基类，它为我们提供了通知观察者的功能。这是一个通用的做法，使得我们的热水器类可以专注于自己的业务逻辑，而观察者模式的实现细节则由基类来处理。

警报器（Observer）:

警报器关心的是水温是否达到了某个阈值。当热水器通知它水温变化时，警报器会进行相应的判断和操作。我们可以这样定义警报器类：

```csharp

public class Alarm : Observer

{

public override void Update(Heater heater, string message)

{

if (int.Parse(message.Split(':')[1]) >= 95) // 判断水温是否达到阈值

{

Console.WriteLine("警报！水温已超过95度！"); // 发出警报信息

}

}

}

```

显示器（Observer）:

显示器则关心的是实时水温的显示。当热水器通知它水温变化时，显示器会更新显示内容。我们可以这样定义显示器类：

```csharp

public class Display : Observer

{

public override void Update(Heater heater, string message)

{

Console.WriteLine($"水温已更新为：{message}"); // 显示水温信息

}

}

```

观察者模式的实现:

现在我们有了这些组件的类定义，就可以组合它们来模拟整个观察者模式的流程了。在程序中，警报器和显示器会注册为热水器的观察者。当热水器开始烧水时，每次水温的变化都会自动通知到这两个观察者，它们分别做出响应——警报器判断是否发出警报，显示器显示当前水温。这就形成了一个对象间的一对多依赖关系，当被观察对象的状态改变时，所有依赖它的对象都会被自动更新。这就是观察者模式的精髓所在。通过这种模式，我们可以实现软件设计的松耦合性，使得代码更加灵活和可维护。在.NET Framework中，委托与事件是事件驱动编程的核心组成部分。它们提供了一种灵活的方式来处理对象间的通信和交互。让我们通过一个简单的例子来深入理解这一过程，并为什么.NET Framework中的事件模型和委托参数设计得如此特殊。

我们来了解什么是委托。在上面的代码中，有一个名为“BoilHandler”的委托，它是一个事件处理器的签名，定义了事件触发时执行的方法的类型。委托允许我们将方法作为参数传递、为事件注册处理程序以及在其他方法中调用这些方法。在.NET中，标准的委托命名约定是以“EventHandler”结尾。这是因为它们经常用于处理事件，并返回一个void类型的结果。委托通常接受两个参数：一个是触发事件的对象的引用（Object类型），另一个是包含事件数据的对象（通常是继承自EventArgs的类型）。这样的设计允许观察者模式中的观察者通过回调方法访问触发事件的对象和与之相关的数据。例如在我们的例子中，警报器可以通过委托中的对象引用访问热水器，并根据温度做出响应。接下来让我们更深入地为什么设计成这样。为什么要使用这种特定的委托模式？这主要是出于以下几个原因：

基于 .NET Framework 重构的家用电热水器

```csharp

using System;

using SystemponentModel;

using System.Text;

namespace Appliances.Kitchen {

// 现代化的智能热水器

public class SmartHeater : HeaterBase {

public string Model { get; set; } = "AdvancedHeat 2023"; // 添加现代化型号标识

public string ProductionArea { get; set; } = "China, Shenzhen"; // 设置生产地信息

public int CurrentTemperature { get; private set; } = 0; // 当前温度属性

public event EventHandler WaterBoiledEvent; // 定义水开事件，传递温度信息

// 定义水温达到预设值时触发的事件参数类

public class TemperatureEventArgs : EventArgs {

public int BoiledTemperature { get; set; } // 水烧开的温度值

public TemperatureEventArgs(int temperature) {

BoiledTemperature = temperature;

}

}

// 启动烧水过程的方法，模拟水温逐渐上升的过程

public void StartBoiling() {

for (int i = 0; i <= 100; i++) {

CurrentTemperature = i; // 模拟水温上升过程

if (CurrentTemperature >= 95) { // 当水温接近沸点时触发事件

OnWaterBoiled(CurrentTemperature); // 内部调用事件处理方法，传递当前温度信息给订阅者（警报器或显示器）

}

}

}

// 事件触发处理方法的实现，供内部调用使用

protected virtual void OnWaterBoiled(int temperature) {

TemperatureEventArgs e = new TemperatureEventArgs(temperature); // 创建事件参数对象，包含当前温度信息

《AlarmChina Xian - RealFire 001的警告与显示》

在科技的浪潮中，我们每天都在接触各种各样的智能设备，它们为我们带来便捷的也带来了许多关于编程和技术的知识。今天，我将通过两个实例，带大家了解委托与事件的概念，并通过一个热水器的范例，深入了解Observer设计模式。

让我们从简单的开始。设想一个GreetingPeople的小程序，在这个程序中，委托扮演着传递信息的角色。就像我们在节日时互送祝福一样，委托就是将信息从一个方法传递到另一个方法的一种机制。那么，委托用来做什么呢？它可以让我们在不确定的时候，将某个操作交给一个特定的对象去完成。

接下来，我们引出事件的概念。事件是委托的一种特殊形式，它允许一个对象通知其他对象自己的状态变化。这就像我们在热水壶中烧水，当水温达到一定程度时，热水壶会自动触发一个警报事件，通知我们水已经烧开了。

接下来，通过一个热水器的范例，我们将Observer设计模式。在这个模式中，当热水器中的水烧到一定温度时，会触发一个警报事件，通过注册的不同方式，不同的对象会接收到这个事件并进行相应的操作。比如，警报器会发出警告声，而显示屏则会显示当前的水温。这个范例展示了如何通过委托和事件实现观察者模式，使对象之间能够相互协作，共同完成任务。

在.Net Framework中，委托和事件的实现方式也是非常灵活的。我们可以通过注册事件处理程序，将一个方法与事件关联起来，当事件发生时，相应的方法就会被自动调用。这种机制使得代码更加解耦，提高了代码的可维护性和可扩展性。

本文希望通过两个实例，让你更深入地理解委托与事件的概念，并了解如何在.Net Framework中实现它们。也希望通过热水器的范例，让你了解Observer设计模式的应用。希望这篇文章能给你带来启发和帮助。

通过cambrian.render('body')的渲染，我们将这篇文章呈现给你，希望你能喜欢并分享给更多的朋友。