C# 委托与事件

在.NET Core的开发体系中，委托是构建灵活、低耦合应用架构的核心基础，它打破了传统方法调用的强绑定关系，让开发者可以将方法作为一等对象进行传递和管理。从基础的函数指针封装，到事件机制、观察者模式的落地实现，委托贯穿了.NET Core中绝大多数异步通知、回调解耦的场景。

1.委托是类型安全的函数指针

委托本质上是一种继承自System.MulticastDelegate的特殊类类型，它定义了方法的签名规范，是.NET中实现类型安全回调的核心载体。和不安全的函数指针不同，委托会严格校验目标方法的参数类型、数量和返回值，只有完全匹配签名的方法才能被委托实例引用，从根源上避免了非法内存调用的风险。

在.NET Core中声明一个自定义委托，只需要明确它的参数列表和返回值即可：

cs 复制代码

// 定义一个用于计算的委托，接收两个int参数，返回int结果
public delegate int Calculate(int x, int y);

使用时可以直接将匹配签名的方法赋值给委托实例，后续就能像调用普通方法一样执行委托指向的逻辑：

cs 复制代码

public class MathOperations
{
    public int Add(int a, int b) => a + b;
}

// 实例化委托，绑定Add方法
Calculate calc = new MathOperations().Add;
int result = calc(5, 3); // 执行后得到结果8

为了避免开发者重复定义通用委托，.NET Core内置了三种常用泛型委托，覆盖大多数日常开发场景：

Action系列：所有无返回值的方法委托，支持0到16个输入参数
Func<TResult>系列：所有带返回值的方法委托，最后一个泛型参数指定返回值类型
Predicate<T>：专门用于返回布尔值的委托，常用来实现集合元素的筛选逻辑

2.委托实现模块解耦

传统开发中如果两个模块需要传递执行逻辑，往往需要通过硬编码依赖或者大量接口定义来实现，模块之间的耦合度极高，一旦内部逻辑调整就可能引发连锁修改。委托的出现彻底解决了这个问题，它让调用方和执行方只需要约定统一的方法签名，不需要互相感知对方的具体实现，完全实现了逻辑的解耦。

举一个典型的场景：数据校验模块和业务处理模块分离。校验模块不需要知道后续要执行什么业务逻辑，只需要对外暴露一个委托参数，任何传入匹配签名方法的调用者，都能在数据校验通过后自动执行对应逻辑：

cs 复制代码

public class DataValidator
{
    // 传入一个委托作为校验通过后的回调
    public void CheckData(int inputData, Action<int> onValidSuccess)
    {
        if (inputData > 0)
        {
            // 校验通过，执行传入的回调逻辑
            onValidSuccess.Invoke(inputData);
        }
    }
}

后续业务扩展时，不管是新增日志记录逻辑、数据库写入逻辑还是缓存更新逻辑，都不需要修改DataValidator的内部代码，只需要传入不同的委托方法即可，两个模块之间完全没有硬编码依赖，极大提升了代码的可维护性。

3.基于委托的灵活逻辑封装

委托可以将零散的可变逻辑封装成独立的单元，和固定不变的主流程代码完全分离，开发者可以在不修改主框架代码的前提下，灵活替换不同的业务实现，这也是策略模式在.NET中最轻量化的落地方式。

比如实现一个通用的集合遍历处理方法，遍历的主流程是固定的，但每个元素的处理逻辑可以通过委托动态传入：

cs 复制代码

public static void ProcessCollection<T>(List<T> source, Action<T> processItem)
{
    foreach (var item in source)
    {
        processItem(item);
    }
}

后续使用时，既可以传入打印元素的逻辑，也可以传入元素转换、统计筛选的逻辑，同一个主流程可以适配完全不同的业务场景，不需要为每一种处理逻辑都重写一遍遍历代码，大幅减少了重复代码的编写。

4. 多播委托是管理多个执行链

所有委托都天然继承自MulticastDelegate，这意味着一个委托实例可以同时绑定多个方法，形成一条完整的调用链，这就是多播委托的核心能力。开发者可以使用+=操作符向委托实例中添加多个方法，使用-=操作符移除已绑定的方法，调用委托时会按照方法添加的顺序依次执行所有绑定的逻辑。

cs 复制代码

Action multiAction = () => Console.WriteLine("执行第一个方法");
multiAction += () => Console.WriteLine("执行第二个方法");
multiAction += () => Console.WriteLine("执行第三个方法");

multiAction.Invoke();
// 输出顺序：
// 执行第一个方法
// 执行第二个方法
// 执行第三个方法

使用多播委托时需要注意两个关键特性：

如果委托带有返回值，调用多播委托后只会返回最后一个执行方法的返回值，前面所有方法的返回结果都会被忽略
移除委托方法时，必须传入完全一致的方法引用才能成功移除，匿名方法由于每次生成的实例不同，几乎无法通过-=操作符成功解绑

5. 委托与事件是封装安全的通知机制

直接将委托作为类的公开成员对外暴露会存在安全隐患：外部代码可以随意清空委托的所有绑定方法，甚至直接替换整个委托实例，破坏类内部的通知逻辑。为了解决这个问题，C#提供了event关键字，它本质上是对委托的一层封装，只允许外部使用+=和-=进行订阅和取消订阅操作，完全禁止外部直接赋值和调用委托，从语法层面保证了通知机制的安全性。

.NET Core中推荐使用标准的事件定义模式，基于内置的EventHandler和EventHandler<TEventArgs>来声明事件：

cs 复制代码

// 自定义事件参数，传递事件相关数据
public class ThresholdReachedEventArgs : EventArgs
{
    public int CurrentValue { get; set; }
    public int Threshold { get; set; }
}

public class Counter
{
    // 声明事件
    public event EventHandler<ThresholdReachedEventArgs> ThresholdReached;

    // 受保护的虚方法，用于触发事件，允许派生类重写逻辑
    protected virtual void OnThresholdReached(ThresholdReachedEventArgs e)
    {
        // 空合并运算符避免订阅者为空时触发空异常
        ThresholdReached?.Invoke(this, e);
    }

    public void CountToThreshold(int threshold)
    {
        for (int i = 0; i <= threshold; i++)
        {
            if (i == threshold)
            {
                OnThresholdReached(new ThresholdReachedEventArgs
                {
                    CurrentValue = i,
                    Threshold = threshold
                });
            }
        }
    }
}

.NET Core 及之后的版本还放宽了事件参数的约束，不再要求自定义的TEventArgs必须继承自System.EventArgs，你可以直接使用结构体作为事件参数，进一步提升值类型场景下的性能表现。

6. 基于委托实现观察者模式

观察者模式的核心是实现发布者和多个订阅者之间的推送通知机制，传统的观察者模式需要定义大量接口、维护订阅者列表、编写循环通知的逻辑，而借助多播委托，你可以用非常少的代码实现完整的观察者能力。

比如实现一个猫叫触发所有动物做出反应的场景，不需要定义任何订阅者接口，直接用多播委托维护所有订阅者的响应逻辑：

cs 复制代码

public class CatPublisher
{
    // 用多播委托维护所有订阅者的响应方法
    public Action OnCatMeow;

    public void Meow()
    {
        Console.WriteLine("猫叫了一声");
        // 依次通知所有订阅者
        OnCatMeow?.Invoke();
    }
}

// 订阅者逻辑
var cat = new CatPublisher();
cat.OnCatMeow += () => Console.WriteLine("狗开始汪汪叫");
cat.OnCatMeow += () => Console.WriteLine("老鼠立刻躲起来");
cat.OnCatMeow += () => Console.WriteLine("鸭子嘎嘎嘎跑开");

cat.Meow();

这种基于委托实现的观察者模式比传统接口实现的版本更加轻量化，不需要维护复杂的订阅者集合，所有的方法管理都由委托的调用链自动完成。如果需要更标准的.NET官方观察者实现，还可以使用IObservable<T>和IObserver<T>接口，适配更复杂的异步推送场景。

7. 委托和事件的核心区别与选型

委托和事件的使用场景，二者的核心差异本质上是访问控制和职责边界的不同：

委托是一个完整的类类型，它可以被任意赋值、调用、作为方法参数传递，适合用来做回调、策略封装、方法传递等场景
事件是委托的封装成员，它只允许外部订阅和取消订阅，不支持直接赋值和外部触发，专门用于实现对象状态变更的通知机制

在实际开发中，如果你需要向外暴露一个状态变化的通知点，优先使用事件，它能保证通知机制的安全性，避免外部代码意外破坏内部逻辑；如果你需要传递一段可变的逻辑、封装不同的执行策略，直接使用委托即可，不需要额外包装成事件。

从底层运行逻辑来看，事件本质上就是在类内部封装了一个私有委托字段，只对外暴露add和remove两个访问器，所有事件的能力都建立在委托的基础之上，二者共同构成了.NET Core中整个回调和通知体系的基石。