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

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

## 委托的声明与使用

- **声明语法**：

  ```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)类型是特殊的）

C#_值类型和引用类型有什么区别

## 一、GC 的目的

垃圾回收器（Garbage Collector，简称 GC）是 .NET CLR（公共语言运行时）中的一项重要机制，用于自动管理内存。其主要职责：
- 自动释放不再使用的对象内存
- 防止内存泄漏
- 避免使用已释放的对象



---

## 二、GC的回收流程

GC 回收大致分为三步：

1. **标记（Mark）**：识别所有“根对象”可达的内存区域（静态字段、方法参数），从Root来开始检查那些是可达对象，那些是不可达对象，不可达对象标记为垃圾
2. **清除（Sweep）**：清除不可达的对象，迁移可达对象到第+1代内存上，并修改引用地址
3. **整理（Compact）**：压缩存活对象，消除内存碎片,不会对大对象进行压缩，83kb以上的对象是大对象

![A_flowchart_in_the_digital_illustration_showcases_.png](https://typroa-note-xuxuxu.oss-cn-guangzhou.aliyuncs.com/11dddc5791f1c2661d91d310b1b92c6e.A_flowchart_in_the_digital_illustration_showcases_.webp)

**随着GC触发的次数越多，对象迁移的次数也就越多，GC的成本就越高,因为高代（Gen2)内存上存储的对象就越大**

---

## 三、GC 的工作机制

### 1. 托管堆（Managed Heap）

所有通过 `new` 创建的对象都存储在托管堆中，也就是堆内存都由 GC 管理。托管堆是连续内存区域，GC 会自动跟踪对象的生命周期。

### 2. 代际回收机制（Generational Collection）
>也就是平时所说的分代回收，分代的计算方式

为提高效率，GC 将对象分为以下几代：

| 代（Generation） | 描述 |
|------------------|------|
| 第 0 代（Gen 0） | 新创建对象，生命周期短 |
| 第 1 代（Gen 1） | 从 Gen0 存活下来的中期对象 |
| 第 2 代（Gen 2） | 生命周期长的老对象，回收代价大 |

GC 更频繁地回收 Gen0，较少处理 Gen2。

### 3. GC 的触发条件

GC 会在以下场景触发：
- 托管堆内存不足
- 系统内存压力大
- 手动调用 `GC.Collect()`
- 应用程序空闲时间

---

## 四、常用 GC API

```csharp
GC.Collect();                // 强制触发 GC
GC.GetGeneration(obj);       // 获取对象所处代
GC.GetTotalMemory(false);    // 获取当前托管堆大小
GC.SuppressFinalize(obj);    // 禁用对象的析构函数调用
```

---

## 五、如何避免频繁触发GC
1. 复用对象（对象池）
2. 轻量的生命周期短的对象，使用结构体代替类
3. 减少闭包的使用

C#_垃圾回收（GC）机制详解

# String是特殊的引用类型

`string` 在 C# 中本质是 **引用类型**，但由于其 **不可变性（Immutable）**，它表现出类似 **值类型** 的行为。



### 1. **不可变性（Immutable）**
- `string` 一旦创建就无法修改，每次修改都会生成新的 `string` 对象，分配新的内存空间
- 赋值不会影响原始字符串，而是创建新的实例。

### 2. **值类型的相等性行为**
- `string`的对象实例都存储在堆内存而不是在栈内存上。
- `string` 直接比较 **内容**，而非对象引用。
- `==` 和 `Equals()` 方法都基于字符串内容进行比较，`Equals()`可以自定义比较规则
- [String赋值的区分](https://xuxuxujs.cn/post/30)

# StringBuilder
`StringBuilder`是 C# 提供的一个用于处理字符串的公共类，本质上是内部维护的事一个字符数组`char[]`，`StringBuilder` 允许在原有字符串的基础上修改内容，而不会创建新的对象，从而提高字符串拼接和修改的效率，特别适用于频繁变更字符串的场景。

## StringBuilder的基本用法
>使用前需要引用命名空间 `using System.Text`
### **创建 `StringBuilder`**
```csharp
using System.Text;

StringBuilder sb = new StringBuilder(); // 默认初始化
StringBuilder sb2 = new StringBuilder("Hello"); // 以初始字符串初始化
StringBuilder sb3 = new StringBuilder(100); // 预分配容量
```
- `StringBuilder()`：创建一个默认大小的 `StringBuilder`。
- `StringBuilder(string value)`：用字符串初始化 `StringBuilder`。
- `StringBuilder(int capacity)`：设置初始容量，减少扩容开销。

### **追加字符串**
```csharp
sb.Append("Hello");
sb.Append(" World");
Console.WriteLine(sb.ToString()); // 输出: Hello World
```
- `Append(string)`：在末尾追加字符串。
- `AppendLine(string)`：追加字符串，并换行。

### **插入字符串**
```csharp
sb.Insert(5, " C#"); // 在索引 5 处插入 " C#"
Console.WriteLine(sb.ToString()); // 输出: Hello C# World
```
- `Insert(int index, string value)`：在指定索引位置插入字符串。

### **替换字符串**
```csharp
sb.Replace("World", "CSharp");
Console.WriteLine(sb.ToString()); // 输出: Hello CSharp
```
- `Replace(oldValue, newValue)`：替换指定的子字符串。

### **删除字符串**
```csharp
sb.Remove(5, 3); // 从索引 5 开始删除 3 个字符
Console.WriteLine(sb.ToString()); // 输出: HelloSharp
```
- `Remove(int startIndex, int length)`：删除指定范围的字符。

---

# `StringBuilder` vs `string`

| 特性          | `string` | `StringBuilder` |
|--------------|---------|---------------|
| **是否可变** | ❌ 不可变 | ✅ 可变 |
| **内存开销** | **大**（每次修改创建新对象） | **小**（原地修改，不创建新对象） |
| **适用场景** | 少量拼接、字符串内容较少 | 需要大量拼接、修改的场景 |
| **性能** | **低**（每次修改重新分配内存） | **高**（减少内存分配，提高效率） |

---