委托和事件是C#中实现解耦与消息通知的核心机制，委托作为方法签名的类型，支持多播调用，事件在委托基础上提供安全的发布/订阅模式，广泛应用于UI响应、异步回调等场景，有效降低模块间依赖，提升可维护性与扩展性。
C#中的委托（Delegate）和事件（Event）是语言核心的一部分，它们本质上都是为了实现代码间的解耦和消息通知机制。简单来说，委托就像是一个“方法签名”的类型，你可以把它想象成一个可以指向任何符合这个签名的方法的变量。而事件呢，它是在委托的基础上构建的一种特殊机制，允许一个对象（发布者）在发生特定情况时通知其他对象（订阅者），而发布者不需要知道具体是哪些对象在监听。这种模式在构建响应式、模块化的应用程序时显得尤为重要，尤其是在UI编程、异步操作回调以及各种通知系统中。
要理解并有效地使用C#的委托和事件，我们通常从它们的声明、实例化和使用开始。
委托的使用：
声明委托类型： 首先，你需要定义一个委托类型，它规定了将来可以被引用的方法的签名（返回值类型和参数列表）。
// 声明一个委托，它可以指向任何接受一个string参数且没有返回值的方法 public delegate void MessageHandler(string message);
实例化委托： 你可以将一个符合委托签名的方法赋值给委托实例。
public class Notifier
{
public void SendNotification(string msg)
{
Console.WriteLine($"通知已发送: {msg}");
}
public static void LogMessage(string msg)
{
Console.WriteLine($"日志记录: {msg}");
}
}
// 在某个地方使用委托
Notifier notifier = new Notifier();
// 实例化委托，指向一个实例方法
MessageHandler handler1 = new MessageHandler(notifier.SendNotification);
// 或者使用更简洁的语法
MessageHandler handler2 = notifier.SendNotification;
// 实例化委托，指向一个静态方法
MessageHandler handler3 = Notifier.LogMessage;调用委托： 调用委托实例，就相当于调用了它所引用的方法。
handler1("Hello from delegate!"); // 输出：通知已发送: Hello from delegate!
handler3("System startup."); // 输出：日志记录: System startup.多播委托： 委托支持“多播”，即一个委托实例可以引用多个方法。当调用这个委托时，所有引用的方法都会被依次执行。
MessageHandler multiHandler = notifier.SendNotification;
multiHandler += Notifier.LogMessage; // 添加另一个方法
multiHandler += (msg) => Console.WriteLine($"匿名方法处理: {msg}"); // 添加一个匿名方法
multiHandler("Event triggered!");
// 输出：
// 通知已发送: Event triggered!
// 日志记录: Event triggered!
// 匿名方法处理: Event triggered!
multiHandler -= Notifier.LogMessage; // 移除一个方法
multiHandler("Another event!");
// 输出：
// 通知已发送: Another event!
// 匿名方法处理: Another event!事件的使用：
事件是在委托之上构建的，提供了一种更安全、更规范的发布/订阅模式。
声明事件：
事件通常在一个类中声明，使用 event 关键字和之前定义的委托类型。
public class EventPublisher
{
// 声明一个基于 MessageHandler 委托的事件
public event MessageHandler OnMessageSent;
// 也可以使用 .NET 提供的标准 EventHandler 委托
// public event EventHandler<CustomEventArgs> DataProcessed;
public void DoSomethingAndNotify(string data)
{
Console.WriteLine($"Publisher is doing something with: {data}");
// 在这里，我们可以决定何时触发事件
// 检查事件是否有订阅者，避免 NullReferenceException
OnMessageSent?.Invoke($"Data processed: {data}");
}
}
// 定义一个自定义的 EventArgs 类（如果需要传递额外数据）
public class CustomEventArgs : EventArgs
{
public string ProcessedData { get; set; }
public CustomEventArgs(string data) => ProcessedData = data;
}订阅事件： 其他对象可以订阅这个事件，当事件被触发时，它们的处理方法就会被调用。
public class EventSubscriber
{
public string Name { get; set; }
public EventSubscriber(string name) => Name = name;
public void HandleMessage(string message)
{
Console.WriteLine($"Subscriber {Name} received: {message}");
}
}
// 在某个主程序中
EventPublisher publisher = new EventPublisher();
EventSubscriber sub1 = new EventSubscriber("Logger");
EventSubscriber sub2 = new EventSubscriber("Alerter");
// 订阅事件
publisher.OnMessageSent += sub1.HandleMessage;
publisher.OnMessageSent += sub2.HandleMessage;
publisher.OnMessageSent += (msg) => Console.WriteLine($"Anonymous subscriber got: {msg}");
publisher.DoSomethingAndNotify("Important Payload");
// 输出：
// Publisher is doing something with: Important Payload
// Subscriber Logger received: Data processed: Important Payload
// Subscriber Alerter received: Data processed: Important Payload
// Anonymous subscriber got: Data processed: Important Payload取消订阅事件： 当订阅者不再需要接收通知时，应该取消订阅，以避免潜在的内存泄漏。
publisher.OnMessageSent -= sub1.HandleMessage; // 取消 Logger 的订阅
publisher.DoSomethingAndNotify("Another Payload");
// 输出：
// Publisher is doing something with: Another Payload
// Subscriber Alerter received: Data processed: Another Payload
// Anonymous subscriber got: Data processed: Another Payload在我看来，委托和事件在C#中扮演着“通信枢纽”和“解耦利器”的双重角色。它们的重要性在于，让不同的代码模块能够相互交流，而无需了解彼此的内部实现细节。想象一下，你有一个复杂的系统，里面有用户界面、数据处理模块、日志记录器等等。如果没有事件，UI模块可能需要直接调用数据处理模块的方法，或者数据处理模块需要直接引用日志记录器。这样一来，模块之间就形成了紧密的耦合，任何一个模块的改动都可能波及其他模块，维护起来会非常痛苦。
事件的出现，就像是引入了一个“公告板”机制。数据处理模块只需要在完成某项任务时，往公告板上贴一个“任务完成”的通知（即触发事件），而日志记录器、UI更新器等感兴趣的模块，只需要订阅这个公告。这样，数据处理模块根本不需要知道谁在监听，也不需要知道监听者会做什么。这种松散耦合（Loose Coupling）是构建大型、可维护、可扩展应用程序的关键。它极大地提升了代码的灵活性和可重用性。当我们需要添加新的功能时，比如一个邮件通知器，我们只需要让它订阅现有的事件，而不需要修改发布者代码，这简直是架构师的福音。
虽然委托和事件功能强大，但如果不正确使用，也容易踩坑。我个人在项目中就遇到过不少因为事件处理不当导致的头疼问题。
首先，内存泄漏是最大的陷阱之一。当一个订阅者对象订阅了一个事件，但之后这个订阅者对象本应被垃圾回收时，如果它没有取消订阅，发布者对象仍然会持有对它的引用。这意味着垃圾回收器无法回收订阅者对象，导致内存泄漏。特别是当发布者是一个生命周期很长的对象（比如一个单例服务），而订阅者是短暂存在的UI控件时，这个问题尤为突出。
最佳实践是：
-= 操作符取消订阅。这通常在 Dispose 方法、窗体或控件的 Closed/Unloaded 事件中完成。其次，NullReferenceException 是另一个常见问题。在触发事件之前，你必须检查事件是否有任何订阅者。如果 OnMessageSent 事件没有任何订阅者，直接调用 OnMessageSent() 会抛出 NullReferenceException。
最佳实践是：
?.： C# 6.0 引入的 ?. 运算符完美解决了这个问题。OnMessageSent?.Invoke(this, EventArgs.Empty); 会在 OnMessageSent 为 null 时短路，不会执行 Invoke，从而避免异常。if (OnMessageSent != null) { OnMessageSent(this, EventArgs.Empty); } 也可以，但 ?. 更简洁。还有，事件处理的线程安全也是一个需要考虑的问题。如果事件在不同的线程上触发，而事件处理程序访问了共享资源（如UI元素），就可能导致线程问题。
最佳实践是：
Control.Invoke 或 Dispatcher.Invoke）。lock 语句或其他同步机制来保护共享数据的访问。最后，遵循标准命名约定也很重要。通常，事件的命名以 On 开头（如 OnMessageSent），事件处理方法的签名遵循 void OnEventName(object sender, EventArgs e) 或 void OnEventName(object sender, TEventArgs e) 模式。这让代码更具可读性和一致性。
深入挖掘C#事件，你会发现它不仅仅是简单的通知机制，还能在更复杂的场景中发挥作用，并涉及一些设计上的权衡。
一个常见的高级用法是自定义 EventArgs。标准 EventArgs.Empty 只能传递事件源对象，但很多时候，事件需要携带额外的数据。这时，我们就需要派生一个自定义的 EventArgs 类来封装这些数据。
// 自定义事件参数
public class TemperatureChangedEventArgs : EventArgs
{
public double OldTemperature { get; }
public double NewTemperature { get; }
public TemperatureChangedEventArgs(double oldTemp, double newTemp)
{
OldTemperature = oldTemp;
NewTemperature = newTemp;
}
}
// 使用泛型 EventHandler<TEventArgs> 声明事件
public class Thermostat
{
public event EventHandler<TemperatureChangedEventArgs> TemperatureChanged;
private double _currentTemperature;
public double CurrentTemperature
{
get => _currentTemperature;
set
{
if (value != _currentTemperature)
{
var oldTemp = _currentTemperature;
_currentTemperature = value;
// 触发事件并传递自定义数据
TemperatureChanged?.Invoke(this, new TemperatureChangedEventArgs(oldTemp, value));
}
}
}
}这种方式让事件变得非常有价值，因为它能够传递上下文信息，让订阅者做出更精确的响应。
另一个不那么常见但非常强大的特性是显式事件访问器（add 和 remove）。通常，我们声明一个事件时，编译器会自动生成 add 和 remove 方法来管理订阅者列表。但如果你需要自定义事件的订阅/取消订阅逻辑，比如在添加第一个订阅者时才初始化资源，或者需要一个线程安全的订阅者列表，你可以显式地定义 add 和 remove 块。
public class CustomEventPublisher
{
private EventHandler _myEvent; // 实际存储订阅者的委托字段
public event EventHandler MyEvent
{
add
{
Console.WriteLine("Adding subscriber...");
// 可以在这里添加自定义逻辑，比如线程安全地添加委托
lock (this)
{
_myEvent += value;
}
}
remove
{
Console.WriteLine("Removing subscriber...");
// 可以在这里添加自定义逻辑，比如线程安全地移除委托
lock (this)
{
_myEvent -= value;
}
}
}
public void Raise()
{
Console.WriteLine("Raising event...");
_myEvent?.Invoke(this, EventArgs.Empty);
}
}这对于那些需要精细控制事件行为的框架或库开发者来说非常有用，但对于日常应用开发，很少直接用到。
异步事件处理也是一个重要的设计考量。当一个事件有多个订阅者，而其中一个订阅者执行耗时操作时，它可能会阻塞发布者线程，甚至影响其他订阅者的执行。在这种情况下，考虑让事件处理程序异步执行会更合理。
// 在事件处理程序中启动一个异步任务
publisher.OnMessageSent += async (sender, e) =>
{
Console.WriteLine($"Async subscriber started processing: {e.Message}");
await Task.Delay(2000); // 模拟耗时操作
Console.WriteLine($"Async subscriber finished processing: {e.Message}");
};当然，这需要发布者和订阅者都对异步操作有清晰的理解，并且要处理好异常传播和取消逻辑。
总的来说，事件在C#中不仅仅是语言特性，它更是一种设计模式的体现。理解其背后的原理和最佳实践，能够帮助我们构建出更健壮、更易于维护的软件系统。
以上就是C#的委托和事件是什么？如何使用？的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
666
收藏
