掌握 C# 事件：全面介绍与实践 – wiki基地

作者： /

掌握 C# 事件：全面介绍与实践

C# 事件是 .NET 编程中一个强大而核心的特性，它实现了组件之间的解耦通信，是构建响应式、可扩展应用程序的关键。通过事件，对象可以通知其他对象发生了特定动作，而无需了解这些对象的具体类型或实现细节。本文将全面介绍 C# 事件的机制、使用方法、最佳实践以及一些高级主题。

1. 引言：C# 事件的魅力

想象一下这样的场景：你的应用程序中有一个按钮，当用户点击它时，你需要更新一个文本框，并同时记录一次日志。如果直接在按钮的点击逻辑中调用更新文本框和记录日志的方法，那么按钮类就与文本框类和日志类紧密耦合。当需求变化时（例如，点击按钮还需要播放一个声音），你需要修改按钮的逻辑。

C# 事件提供了一种优雅的解决方案。按钮可以“发布”一个“点击事件”，而文本框和日志系统则可以“订阅”这个事件。当事件发生时，所有订阅者都会收到通知并执行各自的响应逻辑。这样，发布者（按钮）和订阅者（文本框、日志）之间就实现了高度解耦。

事件是实现观察者模式（Observer Pattern）的核心机制，它使得对象之间能够以一对多的方式进行通信，同时保持低耦合。

2. 委托：事件的基石

在深入了解事件之前，我们必须先理解委托（Delegates），因为事件是建立在委托之上的。

什么是委托？

委托是一种类型安全的函数指针。它定义了方法的签名（返回类型和参数列表），可以引用任何匹配其签名的方法。你可以将委托理解为一个“合同”或“蓝图”，规定了被引用方法的样子。

2.1 声明和使用委托

“`csharp
// 声明一个委托类型
// 这个委托可以引用任何没有参数且返回类型为 void 的方法
public delegate void MyEventHandler();

// 声明一个带参数的委托类型
// 这个委托可以引用任何接受一个 string 参数且返回类型为 void 的方法
public delegate void MessageHandler(string message);

public class Publisher
{
// 声明一个委托变量
public MyEventHandler OnSomethingHappened;
public MessageHandler OnMessageReceived;

public void DoSomething()
{
    Console.WriteLine("Publisher is doing something...");
    // 如果有方法被订阅，则调用它们
    OnSomethingHappened?.Invoke(); // 安全地调用，避免 NullReferenceException
    OnMessageReceived?.Invoke("Hello from publisher!");
}

}

public class Subscriber
{
public void HandleSomething()
{
Console.WriteLine(“Subscriber handled something!”);
}

public void DisplayMessage(string msg)
{
    Console.WriteLine($"Subscriber received message: {msg}");
}

}

public class Program
{
public static void Main(string[] args)
{
Publisher p = new Publisher();
Subscriber s = new Subscriber();

    // 订阅方法：将方法绑定到委托变量
    p.OnSomethingHappened += s.HandleSomething;
    p.OnMessageReceived += s.DisplayMessage;

    p.DoSomething();

    // 取消订阅
    p.OnSomethingHappened -= s.HandleSomething;

    Console.WriteLine("\nAfter unsubscribing:");
    p.DoSomething(); // Subscriber won't handle something this time
}

}
“`

输出：

“`
Publisher is doing something…
Subscriber handled something!
Subscriber received message: Hello from publisher!

After unsubscribing:
Publisher is doing something…
Subscriber received message: Hello from publisher!
“`

2.2 多播委托

委托的一个强大特性是多播（Multicast）。一个委托实例可以引用多个方法。当调用这个委托时，所有被引用的方法都会按顺序执行。这是通过 += 和 -= 运算符实现的，它们分别用于添加和移除方法。

在上面的例子中，p.OnSomethingHappened += s.HandleSomething; 就是将 s.HandleSomething 方法添加到了 OnSomethingHappened 委托的调用列表中。

3. 事件：委托的封装

虽然委托可以实现发布/订阅模式，但直接暴露公共委托变量存在一些问题：
1. 外部可以直接赋值 委托 = null：这会意外地清空所有订阅者。
2. 外部可以直接调用委托：发布者应该控制何时触发事件。

为了解决这些问题，C# 引入了 event 关键字。event 关键字实际上是委托的一个受限封装，它在委托的基础上提供了更安全的发布/订阅机制。

3.1 声明一个事件

声明事件通常遵循以下模式：

“`csharp
public class MyEventArgs : EventArgs
{
public string Message { get; set; }
public DateTime EventTime { get; set; }

public MyEventArgs(string message)
{
    Message = message;
    EventTime = DateTime.Now;
}

}

public class EventPublisher
{
// 1. 声明一个委托类型（通常使用 EventHandler 或 EventHandler）
// public delegate void CustomEventHandler(object sender, MyEventArgs e);

// 2. 声明一个事件：使用 event 关键字和委托类型
public event EventHandler<MyEventArgs> MyEvent;

// 或者，对于没有额外数据的事件，可以使用默认的 EventHandler
public event EventHandler SimpleEvent;

public void TriggerEvents(string message)
{
    Console.WriteLine($"\nPublisher triggering events with message: '{message}'");

    // 3. 触发事件：在发布者内部调用事件
    // 最佳实践：在调用前检查事件是否为空 (是否有订阅者)
    // 经典的C#模式是创建一个临时变量以实现线程安全
    EventHandler<MyEventArgs> handler = MyEvent;
    if (handler != null)
    {
        handler(this, new MyEventArgs(message));
    }

    // C# 6.0 引入的更简洁的语法 (线程安全)
    SimpleEvent?.Invoke(this, EventArgs.Empty);
}

}
“`

3.2 订阅事件（事件处理器）

订阅者通过 += 运算符将自己的方法（事件处理器）附加到事件上。

“`csharp
public class EventSubscriber
{
private string _name;

public EventSubscriber(string name)
{
    _name = name;
}

// 事件处理器方法：匹配事件委托的签名
public void HandleMyEvent(object sender, MyEventArgs e)
{
    Console.WriteLine($"- {_name} received MyEvent from {sender.GetType().Name}.");
    Console.WriteLine($"  Message: {e.Message}, Time: {e.EventTime}");
}

public void HandleSimpleEvent(object sender, EventArgs e)
{
    Console.WriteLine($"- {_name} received SimpleEvent from {sender.GetType().Name}.");
}

}

public class ProgramWithEvents
{
public static void Main(string[] args)
{
EventPublisher publisher = new EventPublisher();
EventSubscriber subscriber1 = new EventSubscriber(“Subscriber A”);
EventSubscriber subscriber2 = new EventSubscriber(“Subscriber B”);

    // 订阅事件
    publisher.MyEvent += subscriber1.HandleMyEvent;
    publisher.MyEvent += subscriber2.HandleMyEvent;
    publisher.SimpleEvent += subscriber1.HandleSimpleEvent;

    publisher.TriggerEvents("Important Data!");

    // 取消订阅
    publisher.MyEvent -= subscriber1.HandleMyEvent;
    publisher.TriggerEvents("Less Important Data!");

    // 如果没有订阅者，触发事件也不会报错
    EventPublisher publisher2 = new EventPublisher();
    publisher2.TriggerEvents("No one listening!");
}

}
“`

输出：

“`
Publisher triggering events with message: ‘Important Data!’
– Subscriber A received MyEvent from EventPublisher.
Message: Important Data!, Time: 12/19/2025 10:30:00 AM
– Subscriber B received MyEvent from EventPublisher.
Message: Important Data!, Time: 12/19/2025 10:30:00 AM
– Subscriber A received SimpleEvent from EventPublisher.

Publisher triggering events with message: ‘Less Important Data!’
– Subscriber B received MyEvent from EventPublisher.
Message: Less Important Data!, Time: 12/19/2025 10:30:01 AM
– Subscriber A received SimpleEvent from EventPublisher.

Publisher triggering events with message: ‘No one listening!’
“`

3.3 EventArgs 和自定义 EventArgs

按照 .NET 的约定：
* 事件处理器的第一个参数是 object sender，它引用了事件的源（即触发事件的对象）。
* 事件处理器的第二个参数是 EventArgs e，它包含了事件的数据。
* 如果事件不携带任何数据，可以使用 EventArgs.Empty。
* 如果事件需要携带额外数据，应该创建一个派生自 EventArgs 的自定义类，并在其中添加所需的属性。

“`csharp
// MyEventArgs 就是一个自定义的 EventArgs 类
public class MyEventArgs : EventArgs
{
public string Message { get; set; }
public DateTime EventTime { get; set; }

public MyEventArgs(string message)
{
    Message = message;
    EventTime = DateTime.Now;
}

}
“`

使用 EventHandler<TEventArgs> 泛型委托，可以指定自定义的 EventArgs 类型，从而提供类型安全且方便的事件数据传递。

4. 事件的最佳实践

4.1 命名约定

  • 事件名称： 通常以动词的过去分词或动名词形式命名，表示动作已完成（如 Click、Loaded、DataReceived）。如果事件表示正在进行的操作，则可以加上 ing 后缀（如 Closing）。
  • 事件处理器： 订阅者的方法通常以 On 或 Handle 开头，后跟事件名称（如 OnMyEvent、HandleClick）。
  • 事件触发方法： 发布者内部用于触发事件的方法通常是 protected virtual void OnEventName(EventArgs e)。这样，派生类可以重写此方法来修改事件触发行为，而无需直接访问事件字段。
  • EventArgs 类： 命名为 EventNameEventArgs（如 MyEventArgs）。

4.2 触发事件前的 Null 检查

在触发事件之前，务必检查事件是否为 null（即是否有订阅者），否则会抛出 NullReferenceException。

“`csharp
// 老式但线程安全的做法
EventHandler handler = MyEvent;
if (handler != null)
{
handler(this, new MyEventArgs(message));
}

// C# 6.0 及更高版本推荐的简洁做法 (同样线程安全)
MyEvent?.Invoke(this, new MyEventArgs(message));
“`

4.3 避免内存泄漏：正确订阅和取消订阅

如果一个订阅者对象订阅了一个事件，但在其生命周期结束时没有取消订阅，那么发布者会继续持有对订阅者对象的引用。这会导致订阅者对象无法被垃圾回收，从而引发内存泄漏。

  • 什么时候订阅？ 通常在对象创建时（构造函数、Load 事件等）或需要响应事件时订阅。
  • 什么时候取消订阅？ 通常在订阅者对象不再需要响应事件时（例如，对象被销毁、页面卸载、UI 元素被移除）使用 -= 运算符取消订阅。

“`csharp
// 订阅
publisher.MyEvent += subscriber.HandleMyEvent;

// … 业务逻辑 …

// 取消订阅
publisher.MyEvent -= subscriber.HandleMyEvent;
“`

4.4 线程安全考虑

事件的订阅和取消订阅操作（+= 和 -=）本身是线程安全的。然而，事件的触发 (Invoke) 并不总是线程安全的，尤其是在多线程环境中，如果订阅列表在触发事件时被修改，可能会导致问题。

使用 ?.Invoke() 语法是线程安全的，因为它在内部使用了临时变量来捕获当前订阅列表。对于更复杂的场景，例如确保所有事件处理器都在特定线程上执行（如 UI 线程），则需要使用 SynchronizationContext 或 Dispatcher。

5. 事件访问器 (Event Accessors)

在某些高级场景中，你可能需要自定义事件的 add 和 remove 操作。这可以通过事件访问器实现，它们类似于属性的 get 和 set 访问器。

“`csharp
public class CustomEventPublisher
{
private EventHandler _myEventBackingField;

public event EventHandler<MyEventArgs> MyEvent
{
    add
    {
        Console.WriteLine("Adding subscriber to MyEvent.");
        _myEventBackingField += value;
    }
    remove
    {
        Console.WriteLine("Removing subscriber from MyEvent.");
        _myEventBackingField -= value;
    }
}

public void TriggerEvent(string message)
{
    Console.WriteLine("\nTriggering CustomEvent.");
    _myEventBackingField?.Invoke(this, new MyEventArgs(message));
}

}

public class ProgramWithCustomAccessors
{
public static void Main(string[] args)
{
CustomEventPublisher publisher = new CustomEventPublisher();
EventSubscriber subscriber = new EventSubscriber(“Custom Subscriber”);

    publisher.MyEvent += subscriber.HandleMyEvent; // 调用 add 访问器
    publisher.TriggerEvent("Event with custom accessors!");
    publisher.MyEvent -= subscriber.HandleMyEvent; // 调用 remove 访问器
}

}
“`

输出：

“`
Adding subscriber to MyEvent.

Triggering CustomEvent.
– Custom Subscriber received MyEvent from CustomEventPublisher.
Message: Event with custom accessors!, Time: 12/19/2025 10:30:02 AM
Removing subscriber from MyEvent.
“`

事件访问器常用于：
* 延迟初始化： 只在有订阅者时才创建资源。
* 弱事件： 解决内存泄漏问题，尤其是在事件源生命周期比订阅者长的情况下。
* 日志记录或审计： 记录事件订阅/取消订阅的行为。

6. 常见场景和高级主题

6.1 UI 事件

在 WinForms、WPF、ASP.NET 等 UI 框架中，事件无处不在。例如，一个按钮的 Click 事件：

“`csharp
// 假设这是一个 WinForms 按钮
Button myButton = new Button();
myButton.Text = “Click Me”;
myButton.Click += MyButton_Click; // 订阅 Click 事件

private void MyButton_Click(object sender, EventArgs e)
{
// 处理按钮点击逻辑
MessageBox.Show(“Button Clicked!”);
}
“`

6.2 自定义组件通信

事件是自定义控件或组件之间进行通信的首选方式。一个组件可以发布事件，而其他组件可以订阅这些事件来响应其行为，而无需直接知道彼此的存在。

6.3 异步操作完成通知

当进行一个耗时的异步操作时，可以使用事件来通知调用者操作已完成或有进度更新。

“`csharp
public class AsyncWorker
{
public event EventHandler ProgressChanged;
public event EventHandler WorkCompleted;

public async Task DoWorkAsync()
{
    for (int i = 0; i <= 100; i += 10)
    {
        await Task.Delay(100); // 模拟耗时操作
        ProgressChanged?.Invoke(this, new ProgressEventArgs(i));
    }
    WorkCompleted?.Invoke(this, new CompletionEventArgs(true, "Work finished successfully."));
}

}

public class ProgressEventArgs : EventArgs { public int Progress { get; set; } public ProgressEventArgs(int p) => Progress = p; }
public class CompletionEventArgs : EventArgs { public bool Success { get; set; } public string Message { get; set; } public CompletionEventArgs(bool s, string m) { Success = s; Message = m; } }

// 订阅者
public class WorkerConsumer
{
public WorkerConsumer(AsyncWorker worker)
{
worker.ProgressChanged += OnProgressChanged;
worker.WorkCompleted += OnWorkCompleted;
}

private void OnProgressChanged(object sender, ProgressEventArgs e)
{
    Console.WriteLine($"Progress: {e.Progress}%");
}

private void OnWorkCompleted(object sender, CompletionEventArgs e)
{
    Console.WriteLine($"Work Completed. Success: {e.Success}, Message: {e.Message}");
}

}
“`

6.4 与其他模式的比较

  • 回调函数： 事件可以看作是更结构化、更安全的泛型回调函数机制。事件提供了标准的签名和订阅/取消订阅的约定。
  • 接口： 接口定义了对象必须实现的行为，而事件则提供了一种对象间解耦通信的方式，无需实现特定接口。
  • 响应式扩展 (Rx.NET)： Rx.NET 是一个更高级的异步编程和事件处理框架，它将事件转化为可观察序列（IObservable<T>），允许使用 LINQ 风格的操作符来组合和查询事件流。对于复杂的事件处理逻辑，Rx.NET 提供了更强大的抽象。

7. 结论

C# 事件是 .NET 平台中不可或缺的特性，它使得组件间的通信变得简单、灵活且解耦。通过深入理解委托、事件的声明、订阅、触发以及相关最佳实践，你可以构建出更健壮、可维护和可扩展的应用程序。掌握 C# 事件，是成为一名优秀 .NET 开发者的重要一步。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部