C#_反射

# 一、什么是“闭包”？

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

换句话说：

> 当一个函数（通常是 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 事件、系统事件、状态通知）                 |
| 默认线程安全 | ❌ 否，操作需自行加锁或复制引用                         | ❌ 否，同样需加锁或拷贝引用触发                              |
| 是否必须依赖 | 独立存在                                               | 必须基于委托类型                                              |
> 💡 总结：事件是对委托的进一步封装，用于发布-订阅模型，限制外部随意触发调用，使程序结构更安全、清晰。


C#_委托和事件

| 表达方式                 | 是否为 null | 是否为空字符串 | 是否分配内存 | 引用是否指向相同实例 | 推荐使用场景             | 特点说明                               |
|--------------------------|--------------|----------------|----------------|-------------------------|--------------------------|----------------------------------------|
| `string str = null`      | ✅ 是         | ❌ 否           | ❌ 否           | ❌ 否                    | 表示变量未初始化或无值     | 无引用，访问成员如 `.Length` 会抛异常 |
| `string str = ""`        | ❌ 否         | ✅ 是           | ✅ 是           | ✅ 是（与 string.Empty） | 表示“空但有效”的字符串     | 语法简洁，直接字面量                 |
| `string str = string.Empty` | ❌ 否     | ✅ 是           | ✅ 是           | ✅ 是（与 ""）           | 表达“空字符串”的标准写法   | 可读性强，推荐用于团队代码风格统一   |

C#_字符串中string str=null和string str=""和string str=string.Empty的区别？

**值类型：**
* 包含了所有简单类型（整数、浮点、bool、char）、struct、enum，继承自System.ValueType

**引用类型：**
* 包含了string，object，class，interface，delegate，array
继承自System.Object

**两者的主要区别**
1. 值类型存储在栈内存中，引用类型数据存储在堆内存中，在堆当中存放的只是一个地址，指向堆中的对象
2. 值类型存取快，引用类型存取慢（为什么？）
    * 值类型存储在栈，栈内存上的对象紧凑而连续，连续存储，想要可以直接获取到，不需要二次寻址
    * 引用类型存储在堆，引用类型分散在堆中，地址不连续，获取到数据之前还需要进行一次二次寻址，变量本身存放是一个地址，需要通过这个地址在堆中找才能得到这个数据
3. 栈的内存是自动释放的，堆内存是.NET 中会由[GC](https://xuxuxujs.cn/post/28)来自动释放
4. 赋值上有区别，值类型是拷贝赋值，修改副本后不会影响原始的变量；引用类型拷贝的是引用的地址，修改副本实际上修改的是同一个对象，会影响原始的变量（除了[String](https://xuxuxujs.cn/post/21)类型是特殊的）