# 对于值类型：
==和equals等价，都是比较存储信息的内容本身

# 对于引用类型：
==比较的是引用类型在栈中的地址，equals方法则比较的是引用类型在托管堆中的存储信息的内容

C#中Equals与==的区别

## 一、程序集（Assembly）

### 概念

- 程序集是 C# 编译后的最终产物，通常是 `.dll` 或 `.exe` 文件。
- 它包含：
  - IL 中间语言代码
  - 元数据（Metadata）
  - 清单（程序集信息）
  - 可选资源文件

### Unity 中程序集的生成与划分规则

| 文件夹路径               | 是否编译 | 生成的程序集名称                        |
| ------------------------ | -------- | ---------------------------------------- |
| `Assets/Scripts/`        | ✅       | `Assembly-CSharp.dll`（主逻辑）          |
| `Assets/Plugins/`        | ✅       | `Assembly-CSharp-firstpass.dll`          |
| `Assets/Editor/`         | ✅       | `Assembly-CSharp-Editor.dll`             |
| 使用 `.asmdef` 自定义目录 | ✅       | 自定义模块程序集（如 `Game.UI.dll`）     |

### 编译行为总结

- Unity 编译不是全量，而是按“程序集单位”增量编译；
- `.asmdef` 可手动拆分模块，提升编译效率与解耦性；
- 所有程序集输出至 `Library/ScriptAssemblies/` 目录。

---

## 二、元数据（Metadata）

### 概念

- 元数据是记录代码结构的信息，用于描述程序集中的类型、字段、方法、特性等；
- 每个类的结构都会以元数据形式写入 `.dll` 中；

### 包含内容

| 元数据项        | 示例                             |
| --------------- | -------------------------------- |
| 类型名          | `public class Player`            |
| 字段信息        | `public int HP`                  |
| 方法签名        | `public void Move(float spd)`    |
| 特性（Attribute）| `[Serializable]`                 |
| 参数/返回类型等 | 用于反射调用或自动匹配            |

### 作用

- CLR 用于代码执行；
- 反射 API 获取结构信息；
- 支持序列化、自动绑定、调试等功能。

---

## 三、反射（Reflection）

### 概念

- 反射是在运行时动态读取类型信息（元数据）并操作其字段、方法、属性的机制；
- 本质：通过读取程序集的元数据，实现对类型的动态操作；

### 常见用途

| 用途              | 示例                                     |
| ----------------- | ---------------------------------------- |
| 动态创建对象      | `Activator.CreateInstance(type)`         |
| 获取字段/方法信息 | `type.GetField("Name")`                  |
| 调用方法          | `method.Invoke(obj, null)`               |
| 获取/设置字段值   | `field.GetValue(obj)` / `SetValue(...)` |
| 获取自定义特性    | `GetCustomAttribute<T>()`                |

### 使用流程图

```
Assembly.Load("xxx.dll")
     ↓
GetType("命名空间.类名")
     ↓
构建 Type/FieldInfo/MethodInfo
     ↓
动态创建对象 / 获取字段 / 调用方法
```

---

## 四、典型应用场景

| 场景                    | 使用反射 | 使用元数据 | 说明                          |
| ----------------------- | -------- | ---------- | ----------------------------- |
| 热更新框架（ILRuntime） | ✅        | ✅         | 动态加载、调用模块             |
| 导表工具（JSON映射）     | ✅        | ✅         | 自动字段绑定无需硬编码         |
| 插件系统/自动注册       | ✅        | ✅         | 自动注册模块，减少手工操作     |
| 编辑器工具生成          | ✅        | ✅         | 自动化生成 Inspector 字段列表 |
| 特性驱动的行为扩展       | ✅        | ✅         | 利用 Attribute 实现数据驱动    |

---

## 五、关键词速查

| 关键词       | 含义                                           |
| ------------ | ---------------------------------------------- |
| Assembly     | 程序集，最终产物 `.dll`/`.exe`                |
| Metadata     | 记录程序结构的描述信息，写入程序集内部         |
| Reflection   | 运行时动态获取类型信息、字段、方法等操作       |
| `.csproj`    | 告诉编译器哪些文件组成项目，如何编译生成程序集 |
| `.asmdef`    | Unity 中手动拆分程序集的配置文件               |
| IL           | 中间语言代码（Intermediate Language）          |

---

## 六、反射 API 实战与常见用法

### 获取类型信息

```csharp
Type type = typeof(MyClass);
Type type2 = obj.GetType();
```

### 动态创建实例

```csharp
object obj = Activator.CreateInstance(type);
```

带参数构造函数：

```csharp
object obj = Activator.CreateInstance(type, new object[] { "Tom", 18 });
```

### 获取字段并访问

```csharp
FieldInfo field = type.GetField("name");
object value = field.GetValue(obj);
field.SetValue(obj, "NewName");
```

访问私有字段：

```csharp
var field = type.GetField("hp", BindingFlags.NonPublic | BindingFlags.Instance);
```

### 获取属性并访问

```csharp
var prop = type.GetProperty("Score");
var val = prop.GetValue(obj);
prop.SetValue(obj, 99);
```

### 获取方法并调用

```csharp
var method = type.GetMethod("Attack");
method.Invoke(obj, new object[] { 10 });
```

### 获取构造函数并调用

```csharp
var ctor = type.GetConstructor(Type.EmptyTypes);
var obj = ctor.Invoke(null);
```

### 遍历字段/属性/方法

```csharp
foreach (var f in type.GetFields()) Console.WriteLine(f.Name);
```

### 获取特性

```csharp
var attr = field.GetCustomAttribute<ObsoleteAttribute>();
if (attr != null) Console.WriteLine("该字段已过时");
```

### 加载外部程序集并实例化类型

```csharp
var asm = Assembly.LoadFrom("MyLib.dll");
var type = asm.GetType("MyLib.Foo");
var obj = Activator.CreateInstance(type);
```

---

## 七、API 快速查阅表

| 功能               | 常用 API                                             |
|------------------|-----------------------------------------------------|
| 获取类型            | `typeof(T)` / `obj.GetType()`                       |
| 创建实例            | `Activator.CreateInstance(type)`                   |
| 获取字段/属性/方法     | `GetField()` / `GetProperty()` / `GetMethod()`      |
| 批量获取            | `GetFields()` / `GetMethods()`                     |
| 访问字段/属性值       | `GetValue()` / `SetValue()`                       |
| 调用方法            | `Invoke()`                                        |
| 获取构造函数         | `GetConstructor()` / `ConstructorInfo.Invoke()`   |
| 加载程序集           | `Assembly.Load()` / `LoadFrom()`                  |
| 获取特性（Attribute） | `GetCustomAttribute<T>()`                         |

---

# 八、总结
**什么是反射？**
>反射是 C# 中一种运行时机制，它允许程序在不知道类型定义的情况下，动态获取类型信息、创建对象、访问字段、调用方法

**反射的原理是？**
>C# 编译后生成的程序集（DLL 或 EXE）中包含了类型的元数据，这些元数据记录了类的结构（包括字段、属性、方法、特性等）。
运行时通过 .NET 提供的 System.Reflection 命名空间读取这些元数据，并通过 Type、FieldInfo、MethodInfo 等对象实现动态操作。


C#_反射、程序集、元数据

# 一、什么是进程，什么是线程

## 1. 进程
* 进程（Process）是程序运行时的最外层容器，代表一个**独立运行的应用程序实例**；
* 操作系统为每个进程分配**独立的内存空间和系统资源**；
* 进程之间**相互隔离**，互不干扰。

> **例子**：打开 Unity，即启动了一个 Unity 编辑器进程。

---

## 2. 线程
* 线程（Thread）是进程内的**执行单位**，代表程序中的一条执行路径；
* 同一个进程可以包含多个线程，**线程共享进程的内存和资源**；
* 多线程可以提高程序的并发性与响应能力。

> **例子**：在 Unity 中同时执行加载资源、UI绘制、脚本运行，这些操作可能运行在不同线程中。

---

## 3. 两者的区别

* 线程必须依附在进程中，不能单独存在；
* 每个进程至少有一个主线程；
* 一个进程可包含多个线程协同完成任务；
* **进程是容器，线程是执行者。**

| 比较项       | 进程（Process）       | 线程（Thread）         |
| --------- | ----------------- | ------------------ |
| 概念        | 应用程序的运行实例         | 应用中执行任务的基本单位       |
| 内存空间      | 独立，不与其他进程共享       | 共享所属进程的内存空间        |
| 通信成本      | 高，需特殊机制（如管道、套接字等） | 低，可直接读写共享内存        |
| 创建/销毁开销   | 大，需分配/释放大量资源      | 小，仅管理执行栈和上下文       |
| 崩溃影响      | 不影响其他进程           | 可能导致整个进程崩溃         |
| 示例（Unity） | Unity 编辑器、游戏运行实例  | 资源加载线程、主线程、后台处理线程等 |

---

## 4. 结合实际场景进行理解

**当我打开百度网盘时，操作系统为它创建了一个进程，分配独立的资源与内存。此时，我在百度网盘中一边下载文件，一边播放正在下载的视频，这两个任务实际上是由该进程内部的多个线程协同完成的。一个进程中可以包含多个线程，而线程必须依附于进程才能存在。进程是操作系统中用于资源管理的基本单位，而线程是任务执行和调度的最小单位，真正承担着程序的运行工作。**

---

# 二、多线程
在刚刚已经提到了，一个进程中可以包含多个线程，那么多线程就是指**在一个进程中同时运行多个线程，使程序能并发执行多个任务** ，通常适合处理一些复杂耗时的逻辑，比如加载文件，网络通信等。

---

## 多线程在C#中的应用

### Thread
```csharp
using System.Threading;//引用多线程命名空间

void Run()
{
    Console.WriteLine("运行在线程中");
}
//声明创建一个线程
Thread thread = new Thread(Run);
thread.Start();
//线程执行
thread.Start();
//设置为后台线程(默认创建的就是前台线程）
thread.IsBackground = true;
//线程休眠
Thread.Sleep(1000);
//关闭和释放一个线程
thread.Abort();
thread = null;
```
以上的举例只是通过使用C#中的Theard类来使用多线程，这是最基础也是最接近底层的方式，但是需要我们手动维护（创建，释放，调度，控制生命周期等），用起来还是非常繁琐和复杂的，可以使用别的方式来使用多线程。

### ThreadPool线程池
* 在多线程的应用程序开发中，频繁的创建删除线程会带来性能消耗，产生内存垃圾。为了避免这种开销C#推出了线程池ThreadPool类。
* ThreadPool中有若干数量的线程，如果有任务需要处理时，会从线程池中获取一个空闲的线程来执行任务。任务执行完毕后线程不会销毁，而是被线程池回收以供后续任务使用。当线程池中所有的线程都在忙碌时，又有新任务要处理时，线程池才会新建一个线程来处理该任务，如果线程数量达到设置的最大值，任务会排队，等待其他任务释放线程后再执行。线程池能减少线程的创建，节省开销，可以减少GC垃圾回收的触发。
* 线程池相当于就是一个专门装线程的缓存池。

```csharp
using System.Threading;

ThreadPool.QueueUserWorkItem(state => {
    Console.WriteLine("线程池中的线程");
});

```
**优点**：节省开销，减少线程的创建，进而有效减少GC触发，系统自动管理线程复用，适合短时间小任务；
**缺点**：不能控制线程池中线程的执行顺序，也不能获取线程池内线程取消/异常/完成的通知；不支持取消、延迟、返回值、无法手动控制线程生命周期、不适合长期任务

### Task
1. `Task` 是 .NET 中对异步操作的高级抽象，属于 **Task Parallel Library (TPL)**，本质上是对 **ThreadPool** 的封装。它代表一个可能在未来完成的工作单元，可以有返回值（`Task<TResult>`），并且能与 `async/await` 搭配使用。
2. 特点

    1. 通过 `Task<TResult>` 返回计算结果
    2. 异常会保存在 `Task` 对象中，可在 `await` 或 `Task.Wait` 时捕获  
    3. 支持 `Task.WhenAll`、`Task.WhenAny` 等组合任务  
    4. 支持 `CancellationToken` 实现任务取消  
    5. 可通过 `TaskScheduler` 修改任务的调度方式  
    6. 与 `async/await` 配合,极大简化异步代码编写  

```csharp
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task<int> task = Task.Run(() =>
        {
            // 模拟计算
            int sum = 0;
            for (int i = 1; i <= 5; i++)
                sum += i;
            return sum;
        });

        int result = await task; // 等待并获取结果
        Console.WriteLine($"结果：{result}");
    }
}
```
**使用场景**

* 需要`返回值`的异步任务
* 需要`组合`或`协调`多个任务
* 需要`异常捕获`和`取消`功能
* 现代异步编程（`async`/`await`）

**缺点**：
* 相较于直接使用 ThreadPool，有额外的调度开销
* 对长时间阻塞操作不如专用线程合适

>在游戏客户端开发中，实际上前端大多数场景是用不多线程的，为什么呢？

> **1. Unity设计本身就是一个以主线程为核心架构的引擎，其绝大多数 API 都必须在主线程调用（运行在多线程中会直接报错）。Task 和 ThreadPool 是 .NET 提供的通用异步/并发工具，但在 Unity 客户端中并不适用于日常逻辑，甚至可能导致严重的线程安全问题，以及产生大量GC。**
> 
>**2. 相比之下，UniTask 是专门为 Unity 场景设计的异步控制方案，零GC、高性能、安全且可读性强。除非你在做复杂的逻辑计算或后台处理，寻轮等（并且确保不会访问 Unity API），否则 Unity 客户端开发中几乎无需主动使用 Task 或 ThreadPool。**

---

# 三、前后台线程
## 前台线程
   默认创建的线程就是前台线程，只要有一个前台线程在运行，进程就不会退出，**程序必须等所有前台线程执行完毕后，才会关闭**，适合处理一些关键任务（游戏主线程、渲染、下载）
    
## 后台线程
   需要我们手动设置`thread.IsBackground = true;`，不会阻止进程退出，一旦所有前台线程结束，即使后台线程还在执行，进程也会被强制终止，也就是说，**后台进程会随着所有前台进程的结束或整个进程的结束而随时被终止，不会等待其执行完成**，适合处理一些后台日志、定时检测等非必须完成的任务

---

# 四、锁和死锁
## 1. 锁
### 定义

锁是一种**线程同步机制**，用于防止多个线程同时访问共享资源，从而导致数据错误或程序崩溃。

### 为什么需要锁？

在多线程并发环境中，如果多个线程同时读写同一变量或集合，容易出现：

* 数据竞争（Race Condition）
* 状态不一致（脏数据）
* 程序崩溃（并发修改集合）

锁的作用是**让每次只有一个线程可以进入临界区**，从而确保线程安全。

### C#常见锁机制

| 锁机制                    | 用法示例                         | 特点             |
| ---------------------- | ---------------------------- | -------------- |
| `lock`                 | `lock(obj) { /* 访问共享资源 */ }` | 最常用，简单易懂，自动释放锁 |
| `Monitor`              | `Monitor.Enter/Exit`         | 提供更细粒度控制，如超时尝试 |
| `Mutex`                | 支持跨进程锁定                      | 成本较高，不适合高频使用   |
| `SpinLock`             | 忙等锁，占 CPU                    | 极短任务，高性能场景使用   |
| `ReaderWriterLockSlim` | 支持并发读、独占写                    | 读多写少场景         |


```csharp
private object _lockObj = new object();

void SafeAdd(List<int> list, int value)
{
    lock (_lockObj)
    {
        list.Add(value);
    }
}
```

---

## 2. 死锁

### 定义

死锁是指两个或多个线程**互相等待对方释放资源**，造成永久阻塞，程序无法继续执行。

### 死锁发生的四个必要条件

1. **互斥**：资源不能被多个线程同时占用。
2. **占有且等待**：线程持有资源的同时申请其他资源。
3. **不可抢占**：资源不能被强制回收，只能线程自己释放。
4. **循环等待**：多个线程之间形成资源的循环等待链。

**⚠ 这四个条件同时成立时，就可能导致死锁。**

### 死锁示例

```csharp
object lockA = new object();
object lockB = new object();

void Thread1()
{
    lock (lockA)
    {
        Thread.Sleep(100);
        lock (lockB)
        {
            Console.WriteLine("线程1获得A和B");
        }
    }
}

void Thread2()
{
    lock (lockB)
    {
        Thread.Sleep(100);
        lock (lockA)
        {
            Console.WriteLine("线程2获得B和A");
        }
    }
}
```

* 两个线程互相持有对方需要的锁 → 死锁

---

## 3. 锁与死锁的关系

* **锁是为了解决线程安全问题的工具**；
* **但死锁恰恰是锁使用不当造成的副作用**；
* 也就是说：**加锁≠防止死锁，不当加锁 = 死锁根源**。

类比说明：

锁就像红绿灯，控制线程（车辆）通行，防止撞车；
但如果每个路口都卡着一辆车互不相让，就会交通瘫痪——这就是死锁。

---

## 4. 如何避免死锁？

| 策略                       | 描述                                |
| ------------------------ | --------------------------------- |
| ✅ **统一加锁顺序**             | 所有线程按相同顺序申请资源                     |
| ✅ **尽量避免嵌套锁**            | 不在一个锁里再加另一个锁                      |
| ✅ **使用 `TryEnter` 超时机制** | 超时退出锁等待                           |
| ✅ **缩小锁的作用范围**           | 减少锁粒度、锁时长                         |
| ✅ **使用无锁数据结构**           | 如 `ConcurrentQueue`、`Interlocked` |

---


C#_Thread、ThreadPool、Task

# 一、什么是“闭包”？

> 闭包是**一个函数 + 它所捕获的变量上下文**的组合体。

换句话说：

> 当一个函数（通常是 lambda 或匿名函数）**访问了其外部作用域中的变量**，并且这个函数被作为**对象传递或延迟执行**，那么它就形成了一个“闭包”。

---

# 二、闭包由什么组成？

1. 一个函数（通常是匿名函数或 lambda 表达式）  
2. 一组被捕获的变量（来自函数外部作用域）  
3. 编译器会将这些变量打包为一个**类实例对象**

这整个结构就叫做一个闭包。

---

# 三、通俗示例：现实比喻

想象你是厨师（函数），你做菜时随手拿了几样家里冰箱里的食材（外部变量）带去了餐厅，等顾客来了你再做菜（延迟执行）。

- 你 = 函数  
- 冰箱里的食材 = 被捕获的变量  
- 带出门的购物袋 = 闭包对象（把变量装起来）  
- 顾客点单 = 调用这个闭包

---

# 四、C# 中闭包的代码示例

```csharp
void Example()
{
    int count = 0; // 外部变量

    Action action = () =>
    {
        Console.WriteLine(count); // Lambda 捕获了外部变量 count
    };

    count = 42;

    action(); // 输出：42
}
```

这里 lambda `()=> Console.WriteLine(count)` **捕获了外部变量 `count`**，所以编译器会创建一个闭包类来保存这个 `count` 变量，并生成一个委托对象。

---

# 五、C# 编译器如何处理闭包（背后发生了什么）

它大致会生成一个类似这样的代码：

```csharp
class DisplayClass
{
    public int count;

    public void Lambda()
    {
        Console.WriteLine(count);
    }
}

void Example()
{
    DisplayClass dc = new DisplayClass();
    dc.count = 0;

    Action action = dc.Lambda;

    dc.count = 42;

    action(); // 输出：42
}
```

> 编译器悄悄帮你创建了一个类（通常名为 `<>c__DisplayClass...`），变量变成它的字段，lambda 变成它的方法。执行 lambda 本质上就是执行这个类的方法。

---

# 六、闭包带来的 GC 问题

每次创建一个捕获了变量的 lambda，就会：

- 编译生成一个闭包类
- 运行时 `new` 一个闭包对象实例（堆上）
- 创建一个委托绑定它的方法

因此：**频繁写闭包就会频繁堆分配，导致 GC 压力**

---

# 七、闭包的特点总结

| 特性                  | 是否成立 |
|-----------------------|----------|
| 捕获外部变量           | ✅       |
| 延迟执行时仍能访问原值 | ✅       |
| 编译为类 + 实例        | ✅       |
| 会在堆上产生 GC        | ✅       |
| 不捕获变量时不是闭包   | ❌       |

---

# 八、如何判断某个 lambda 是否形成闭包？
1. lambda 内部是否访问了函数外部的局部变量？
   - 是：会创建闭包对象（产生 GC）
   - 否：不会创建闭包对象，可能为 static 方法引用或静态委托

2. lambda 是否在每次执行处都被重新声明/注册？
   - 是：可能每次创建新的闭包对象
   - 否：只创建一次闭包对象，可忽略 GC 影响

---

# 九、闭包变量共享问题

```csharp
var actions = new List<Action>();
for (int i = 0; i < 3; i++) {
    actions.Add(() => Console.WriteLine(i));
}
foreach (var action in actions) action(); // 输出 3, 3, 3
```
上述代码中，当触发事件的时候，得到的是i最终值为3，**因为这里所有的闭包捕获的是同一个变量i，i是引用而非拷贝的值**，i在循环中是不停变化的，当我们触发事件的时候，循环已经结束了，但是捕获的又是同一个变量i，所以输出的值都是相同的，所以需要一个临时变量来存储每次循环中i的值

**解决方法，使用临时变量来存储**

```csharp
for (int i = 0; i < 3; i++) {
    int temp = i;
    actions.Add(() => Console.WriteLine(temp));
}
```

# 十、Unity中的注意事项

- UI 注册事件中最常见闭包来源：`onClick.AddListener(() => Method())`，（**这里Button在注册委托的时候会在堆上分配一个闭包对象 + 一个委托实例。而后续每次点击按钮（触发事件）时，仅调用已经存在的委托对象，不会再次分配内存，也不会创建新的闭包对象**）
- 如果 lambda 中使用了外部变量，就形成闭包
- 方法组 `AddListener(Method)` 没有闭包，零 GC
- 重复注册 lambda（如在 Update 里）会导致大量 GC

---

# 🔚 总结

> **闭包是指一个函数连同它所捕获的外部变量一起打包起来的结构。它通常由 lambda 表达式触发，在编译时会生成一个类，在运行时 `new` 出一个对象，进而可能导致 GC。**


C#_闭包Lambada

# 委托
## 委托的基本概念

- **定义**：委托是一种类型安全的函数指针，允许将方法作为参数传递或赋值给变量。
- **作用**：实现方法的回调机制，支持事件驱动编程。

## 委托的声明与使用

- **声明语法**：

  ```csharp
  public delegate void MyDelegate(string message);
  ```

- **实例化与调用**：

  ```csharp
  MyDelegate del = new MyDelegate(MethodName);
  del("Hello, World!");
  ```

## 多播委托（Multicast Delegate）

- **定义**：一个委托可以同时引用多个方法。
- **添加方法**：使用 `+=` 运算符添加方法。
- **移除方法**：使用 `-=` 运算符移除方法。

## 内置委托类型

- **Action**：表示无返回值的方法。

  ```csharp
  Action<string> action = Console.WriteLine;
  ```

- **Func**：表示有返回值的方法。

  ```csharp
  Func<int, int, int> add = (x, y) => x + y;
  ```

## 委托的高级特性

- **匿名方法**：使用 `delegate` 关键字定义匿名方法。

  ```csharp
  MyDelegate del = delegate(string msg) { Console.WriteLine(msg); };
  ```

- **Lambda 表达式**：简化的匿名方法写法。

  ```csharp
  MyDelegate del = (msg) => Console.WriteLine(msg);
  ```


# 事件
## 事件的基本概念

- **定义**：事件是对委托的封装，用于实现发布-订阅模式，使对象之间能够进行松耦合的通信。
- **作用**：当某个动作发生时，事件可以通知所有订阅者，从而触发相应的处理逻辑。

## 事件的声明与使用

- **声明事件**：

  **event(关键字) + 委托类型 + 事件名**

  ```csharp
  //以下为C#中自带的委托类型
  //Action类型皆不带返回值,可带参数
  public event Action OnTest1;//不带参数
  public event Action<int> OnTest2;//带一个int类型参数

  //Func类型皆带返回值,可带参数(最后一个为返回值)
  public event Func<int> OnTest3;
  public event Func<string, int> OnTest4;//带一个string类型参数,返回int类型
  
  //自定义委托类型
  public event MyDelegate CustomEvent;
  public delegate void MyDelegate(string msg);
  ```
  **特殊的自带委托类型，EventHander**
  
  ```csharp
  public event EventHandler<T> evHandler;
  ```
  其中T必须继承自`EventArgs`，也就是说T至少是个class
  - eventHandler注册事件
  ```csharp
  evHandler += (object sender, EventArgs e) =>
  {
      //sender获取到事件的发送者
      if (sender is Test)
      {
        //获取到事件传递过来的参数
        e.xxxx
      }
  };
  ```
  - eventHandler触发事件
  ```csharp
  //触发Handler事件,this指的是事件的发送者
  evHandler?.Invoke(this, EventArgs.Empty);
  ```
- **订阅事件**：

  ```csharp
  MyEvent += new EventHandler(MyEventHandler);
  ```

- **触发事件**：

  ```csharp
  MyEvent?.Invoke(this, EventArgs.Empty);
  ```

## 事件的组成部分

- **发布者（Publisher）**：定义并触发事件的对象。
- **订阅者（Subscriber）**：订阅并响应事件的对象。
- **事件处理器（EventHandler）**：处理事件的委托方法。

## 自定义事件参数

- **定义自定义参数类**：

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

- **声明带有自定义参数的事件**：

  ```csharp
  public event EventHandler<MyEventArgs> MyEvent;
  ```

- **触发事件并传递参数**：

  ```csharp
  MyEvent?.Invoke(this, new MyEventArgs { Message = "Hello" });
  ```

## 事件的注意事项
### 访问限制
事件只能由声明它的类触发，外部类只能订阅或取消订阅事件，不能触发事件。
### 线程安全
事件在多线程执行和异步调用时可能出现的问题
* 多个线程同时订阅（+=）或取消订阅（-=）
* 一个线程在触发事件，另一个线程取消了订阅
* 异步任务中调用事件
### 常见事件安全的问题
1. **NullReferenceException（空引用异常）**
    ```csharp
    MyEvent?.Invoke(this, EventArgs.Empty);
    ```
    如果在判断 `MyEvent != null` 后，另一个线程刚好将所有订阅者移除，会导致 `MyEvent` 在调用时变为 null，从而抛出异常。

2. **委托调用执行异常或遗漏**

    当多个线程同时执行：
    ```csharp
    MyEvent += HandlerA;
    MyEvent += HandlerB;
    ```
    这可能破坏底层的委托链，导致：
    - 方法调用顺序异常；
    - 某些订阅丢失或遗漏；
    - 程序行为不一致。
### 如何避免
一般框架中都会封装好事件系统，避免我们手动调用导致的线程安全的问题，比如GameFramework

* 使用临时变量装载后再调用，这样当有其他线程-=移除了，我们逻辑还可以继续执行而不会抛出空引用
```csharp
EventHandler handler = MyEvent;
if (handler != null)
{
    handler(this, EventArgs.Empty);
}
```

* 空判断后再调用

```csharp
MyEvent?.Invoke(this, EventArgs.Empty);
```

# 委托和事件的区别
- **事件**：是对委托的封装，用于发布-订阅模式，提供更安全的访问机制。
- **声明事件**：

  ```csharp
  public event MyDelegate MyEvent;
  ```

- **触发事件**：

  ```csharp
  MyEvent?.Invoke("Event triggered");
  ```

| 对比项       | 委托（Delegate）                                       | 事件（Event）                                                |
|--------------|--------------------------------------------------------|--------------------------------------------------------------|
| 本质         | 类型安全的函数指针（封装方法引用）                     | 基于委托的封装机制                                           |
| 语法定义     | `public delegate void MyDelegate();`                  | `public event MyDelegate MyEvent;`                           |
| 访问权限     | 可被外部代码**直接调用、赋值、清空**，不安全           | 外部代码**只能 += 或 -= 订阅与取消**，不能调用               |
| 调用方式     | 外部和内部代码都可以调用                               | 只能在**声明它的类内部**调用                                 |
| 封装性       | 无封装（委托字段是公开变量）                           | 提供了封装（事件只能通过订阅机制访问）                       |
| 多播支持     | 支持（委托可组合多个方法）                             | 支持（事件本质是多播委托）                                   |
| 使用场景     | 回调、策略模式、函数链式调用                           | 发布-订阅模式（UI 事件、系统事件、状态通知）                 |
| 默认线程安全 | ❌ 否，操作需自行加锁或复制引用                         | ❌ 否，同样需加锁或拷贝引用触发                              |
| 是否必须依赖 | 独立存在                                               | 必须基于委托类型                                              |
> 💡 总结：事件是对委托的进一步封装，用于发布-订阅模型，限制外部随意触发调用，使程序结构更安全、清晰。
