04-C#.Net-委托和事件-学习笔记

一、委托（Delegate）基础

1.1 什么是委托？

委托是一种引用类型，本质上是一个类，继承自 MulticastDelegate。它可以封装方法的引用，类似于 C/C++ 中的函数指针，但更加类型安全。

// 委托的定义
public delegate void NoReturnNoPara();
public delegate void NoReturnWithPara(int x, int y);
public delegate int WithReturnNoPara();
public delegate int WithReturnWithPara(out int x, ref int y);

关键点：

委托定义时需要指定参数类型和返回值类型
委托本质是类，会被编译器编译成继承自 MulticastDelegate 的类
委托可以定义在类外部或类内部

1.2 委托的实例化

// 方式1：使用 new 关键字
NoReturnNoPara delegate1 = new NoReturnNoPara(NoReturnNoParaMethod);

// 方式2：直接赋值（语法糖）
NoReturnNoPara delegate2 = NoReturnNoParaMethod;

// 方式3：使用 Lambda 表达式
NoReturnWithPara delegate3 = (x, y) => { Console.WriteLine($"x={x}, y={y}"); };

1.3 委托的执行

// 方式1：使用 Invoke 方法
delegate1.Invoke();

// 方式2：直接调用（语法糖）
delegate1();

// 异步调用（已过时，不推荐）
// delegate1.BeginInvoke(null, null);

1.4 委托的作用和意义

问题场景： 学生问候方式因地域不同而不同（武汉、上海、广东等）

传统方案的问题：

方案1（枚举+switch）：业务逻辑耦合，方法不稳定
方案2（多个独立方法）：大量重复代码

委托解决方案：

public delegate void SayHiDelegate();

public void SayHiPerfect(SayHiDelegate sayHiDelegate)
{
    Console.WriteLine("问候前，招招手...");
    sayHiDelegate.Invoke();  // 执行传入的具体问候逻辑
}

// 使用
student.SayHiPerfect(student.SayHiWuhan);
student.SayHiPerfect(student.SayHiShanghai);

优势：

代码稳定：核心方法不需要修改
逻辑解耦：不同业务逻辑分离
逻辑重用：去除重复代码

二、框架内置委托

2.1 Action 委托

Action 是无返回值的委托，最多支持 16 个参数。

// 无参数
Action action = () => Console.WriteLine("Hello");

// 有参数
Action<int> action1 = (x) => Console.WriteLine(x);
Action<int, string> action2 = (x, y) => Console.WriteLine($"{x}, {y}");

// 最多16个参数
Action<int, int, int, ..., int> action16 = (p1, p2, ..., p16) => { };

2.2 Func 委托

Func 是有返回值的委托，最多支持 16 个输入参数 + 1 个返回值。

// 无参数，有返回值
Func<int> func = () => 100;

// 有参数，有返回值（最后一个泛型参数是返回值类型）
Func<int, int> func1 = (x) => x * 2;
Func<int, string, int> func2 = (x, y) => x + y.Length;

// 最多16个输入参数 + 1个返回值
Func<int, int, ..., int, string> func17 = (p1, p2, ..., p16) => "result";

为什么要有内置委托？

统一委托类型，避免定义大量自定义委托
减少类型数量（委托本质是类）
提高代码可读性和互操作性

三、多播委托（Multicast Delegate）

3.1 概念

所有委托都继承自 MulticastDelegate，可以通过 += 和 -= 操作符注册和移除多个方法。

Action action = DoNothing;
action += DoNothingStatic;
action += new Student().Study;
action += Student.StudyAdvanced;
action += () => Console.WriteLine("Lambda");

// 执行时按注册顺序依次调用
action.Invoke();

3.2 移除方法

action -= DoNothing;  // 成功移除

// 注意：以下情况无法移除
action -= new Student().Study;  // 失败：不是同一个实例
action -= () => Console.WriteLine("Lambda");  // 失败：Lambda 每次生成不同方法

移除规则：

从后往前逐个匹配
必须是同一个实例的同一个方法
匹配到后移除并停止继续匹配

3.3 异步执行多播委托

// 多播委托不能直接使用 BeginInvoke
// action.BeginInvoke(null, null);  // 错误

// 正确做法：遍历委托列表
foreach (Action item in action.GetInvocationList())
{
    item.BeginInvoke(null, null);  // 每个方法异步执行
}

四、委托的高级应用：嵌套委托（俄罗斯套娃）

4.1 委托嵌套原理

委托可以包装另一个委托，形成多层嵌套，实现 AOP（面向切面编程）。

public delegate void ShowDelegate();

// 核心业务逻辑
ShowDelegate coreMethod = () => Console.WriteLine("核心业务");

// 第一层包装：添加日志
ShowDelegate withLog = () => {
    Console.WriteLine("前置日志");
    coreMethod.Invoke();
    Console.WriteLine("后置日志");
};

// 第二层包装：添加性能监控
ShowDelegate withMonitor = () => {
    Console.WriteLine("开始监控");
    withLog.Invoke();
    Console.WriteLine("结束监控");
};

withMonitor.Invoke();

4.2 结合特性实现自动装配

public abstract class AbstractMethodAttribute : Attribute
{
    public abstract ShowDelegate Do(ShowDelegate action);
}

public class BeforeMethodAttribute : AbstractMethodAttribute
{
    public override ShowDelegate Do(ShowDelegate action)
    {
        return new ShowDelegate(() => {
            Console.WriteLine("前置处理");
            action.Invoke();
            Console.WriteLine("后置处理");
        });
    }
}

// 使用
[BeforeWriteLog]
[BeforeMethod]
public void Method()
{
    Console.WriteLine("核心业务");
}

// 自动装配执行
ShowDelegate showMethod = () => methodInfo.Invoke(instance, null);
foreach (var attribute in methodInfo.GetCustomAttributes().Reverse())
{
    showMethod = attribute.Do(showMethod);
}
showMethod.Invoke();

应用场景：

ASP.NET Core 中间件管道
日志记录
性能监控
事务管理
权限验证

五、事件（Event）

5.1 事件的定义

事件是特殊的委托，使用 event 关键字修饰。

public class Cat
{
    // 委托
    public Action MiaoAction = null;
    
    // 事件
    public event Action MiaoEvent = null;
    
    public void Miao()
    {
        Console.WriteLine("喵~");
        MiaoEvent?.Invoke();  // 只能在类内部触发
    }
}

5.2 委托 vs 事件

特性	委托	事件
本质	类	特殊的委托
外部赋值	可以 `=` 赋值	只能 `+=` 和 `-=`
外部调用	可以直接调用	不能外部调用
安全性	较低	较高
子类访问	可以	不可以

Cat cat = new Cat();

// 委托可以这样操作
cat.MiaoAction = null;  // 清空所有订阅
cat.MiaoAction();       // 外部直接触发

// 事件只能这样操作
cat.MiaoEvent += Handler;  // 只能添加
cat.MiaoEvent -= Handler;  // 只能移除
// cat.MiaoEvent();        // 错误：不能外部触发
// cat.MiaoEvent = null;   // 错误：不能赋值

5.3 观察者模式（发布-订阅模式）

核心要素：

发布者（Publisher）：定义事件并触发
订阅者（Subscriber）：订阅事件并响应
订阅关系：通过 += 建立

示例：猫叫引发的连锁反应

public class Cat
{
    public event Action MiaoEvent;
    
    public void Miao()
    {
        Console.WriteLine("猫：喵~");
        MiaoEvent?.Invoke();
    }
}

public class Dog
{
    public void Wang() => Console.WriteLine("狗：汪汪！");
}

public class Mouse
{
    public void Run() => Console.WriteLine("老鼠：快跑！");
}

// 使用
Cat cat = new Cat();
cat.MiaoEvent += new Dog().Wang;
cat.MiaoEvent += new Mouse().Run;
cat.Miao();  // 触发所有订阅者的响应