C# 事件与委托

2026-03-02

事件与委托

一句话：委托（delegate）是“可以装方法的变量”；事件（event）是“受保护的委托通知机制”。

小例子

1 2	// 比如定义一个“能接收两个 int，返回一个 int 的方法类型 delegate int Calc(int a, int b);

这句话的意思不是写了一个方法，而是定义了一种方法签名类型。

也就是说，凡是长这样的方法，都可以装进 Calc：

1 2	static int Add(int x, int y) => x + y; static int Sub(int x, int y) => x - y;

使用：

Calc c1 = Add;
Calc c2 = Sub;

Console.WriteLine(c1(3, 2)); // 5
Console.WriteLine(c2(3, 2)); // 1

你可以把它理解成：
Add 是一个方法
Calc 是一种“能引用这类方法的类型”
c1 是一个装了 Add 的变量

为什么需要委托

核心价值有两个：

把“做什么”当参数传进去，相当于把“算法”传进去了。
回调一个方法做完事后，通知另一个方法处理结果，这就是回调。
委托特别适合干这个。

此外，为保证安全性，委托不是随便什么方法都能赋值，签名必须匹配（参数与返回值一致）。

委托的回调：

using System;

namespace CallbackDemo
{
    // 1. 定义委托（回调函数类型）
    delegate void Notify(string message);

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Main: 开始执行");

            // 2. 把“回调方法”传进去
            ProcessTask(OnTaskCompleted);

            Console.WriteLine("Main: 程序结束");
        }

        // 3. 被调用的方法（内部会触发回调）
        static void ProcessTask(Notify callback)
        {
            Console.WriteLine("ProcessTask: 正在处理任务...");

            // 模拟处理过程
            for (int i = 1; i <= 3; i++)
            {
                Console.WriteLine($"ProcessTask: 第{i}步处理中");
            }

            // 4. 处理完成，调用回调方法
            callback("任务已经完成！");
        }

        // 5. 回调函数（由调用方提供）
        static void OnTaskCompleted(string msg)
        {
            Console.WriteLine("回调函数被调用！");
            Console.WriteLine("收到消息: " + msg);
        }
    }
}

输出：

Main: 开始执行
ProcessTask: 正在处理任务...
ProcessTask: 第1步处理中
ProcessTask: 第2步处理中
ProcessTask: 第3步处理中
回调函数被调用！
收到消息: 任务已经完成！
Main: 程序结束

流程拆解

step 1 ProcessTask(OnTaskCompleted); OnTaskCompleted 方法“交给”了 ProcessTask
step 2 进入 ProcessTask static void ProcessTask(Notify callback)
这里的 callback 实际上就是：

callback == OnTaskCompleted

step3 执行任务逻辑 Console.WriteLine("处理中...");for{...}
Step 4：触发回调（核心） callback("任务已经完成！");这行代码等价于：OnTaskCompleted("任务已经完成！");
也就是说：ProcessTask 反过来调用了 Main 提供的方法
step 5 执行回调函数static void OnTaskCompleted(string msg)
输出:
1
2
回调函数被调用！
收到消息: 任务已经完成！
也就是说，可以定义多个不同的函数，只要满足参数和返回值类型与定义的委托一致，就可以作为参数传入到其他函数中

同时，委托还支持多播

delegate void Notify();

static void A() => Console.WriteLine("A");
static void B() => Console.WriteLine("B");

Notify n = A;
n += B;

n();

输出

1
2

A
B

同理，也可以移除

1 2	n -= A; n();

事件

事件本质上是对委托的一层封装，限制外部只能订阅/取消订阅，不能随便触发

示例：

class Button
{
    public event Action Click;

    public void SimulateClick()
    {
        Click?.Invoke();
    }
}

// 外部可以：
button.Click += OnClick;
button.Click -= OnClick;
// 不可：
button.Click();       // 不允许
button.Click = null;  // 不允许

也就是说，发布者负责触发，订阅者只负责响应
经典反例：

class Button
{
    public Action Click;
}
// 外部操作
button.Click += OnClick;
button.Click();       // ❌ 外部可以触发
button.Click = null;  // ❌ 外部可以清空

问题：

👉 外部把“按钮点击”这个行为控制权拿走了

这在设计上是灾难：谁都可以伪造点击谁都可以把监听清空
所以引入了event

class Button
{
    public event Action Click;

    public void SimulateClick()
    {
        Click?.Invoke();
    }
}
// 外部只能
button.Click += OnClick;
button.Click -= OnClick;
// 不能
button.Click();       // ❌ 不允许
button.Click = null;  // ❌ 不允许

事件的本质：一个 private 委托 + 受限访问
完整例子：

using System;

namespace EventDemo
{
    class Button
    {
        // 1. 定义事件
        public event Action Click;

        // 2. 模拟点击
        public void Press()
        {
            Console.WriteLine("按钮被按下");

            // 3. 触发事件（通知所有订阅者）
            Click?.Invoke();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var button = new Button();

            // 4. 订阅事件（可以多个）
            button.Click += OnClick1;
            button.Click += OnClick2;

            // 5. 触发
            button.Press();
        }

        static void OnClick1()
        {
            Console.WriteLine("处理逻辑1：播放声音");
        }

        static void OnClick2()
        {
            Console.WriteLine("处理逻辑2：记录日志");
        }
    }
}

输出：

1
2
3

按钮被按下
处理逻辑1：播放声音
处理逻辑2：记录日志

流程拆解：

 button.Click += OnClick1;
 button.Click += OnClick2;

现在内部相当于：_click = OnClick1 + OnClick2;
2. 触发事件 Click?.Invoke();
等价于：

1 2	OnClick1(); OnClick2();

事件三要素：

发布者这里是 class Button
事件本身 public event Action Click;
订阅者 button.Click += OnClick1;

其余要点

Click?.Invoke() 此处的?表示执行前进行非空判断，若为null则不执行，Click.Invoke()则会在null时报错
事件本质上就是委托，但进行了event封装，委托访问权在外部，事件访问权在内部

多播的返回值问题，如：

delegate int Calc();
// 再绑定多个方法
Calc c = A;
c += B;
c += C;
//调用
int result = c();
// 此时该输出什么？

答案是：

只会得到最后一个方法的返回值
完整例子：

using System;

namespace MulticastReturnDemo
{
    delegate int Calc();

    class Program
    {
        static void Main(string[] args)
        {
            Calc c = Method1;
            c += Method2;
            c += Method3;

            int result = c();

            Console.WriteLine("最终返回值: " + result);
        }

        static int Method1()
        {
            Console.WriteLine("Method1 执行");
            return 10;
        }

        static int Method2()
        {
            Console.WriteLine("Method2 执行");
            return 20;
        }

        static int Method3()
        {
            Console.WriteLine("Method3 执行");
            return 30;
        }
    }
}

输出：

Method1 执行
Method2 执行
Method3 执行
最终返回值: 30

中间有异常咋办？比如： Method1 正常 Method2 抛异常 Method3 正常
那么默认情况下，执行到 Method2 出错后，后面的 Method3 就不会继续执行。此外，可以通过GetInvocationList()此方法来返回当前绑定的所有方法列表。这样你就可以一个一个调用，并分别处理异常