1
// 规则一：== 和 != 必须同时定义
2
// 规则二：< 和 > 必须同时定义
3
// 规则三：<= 和 >= 必须同时定义
4
// 规则四：true 和 false 必须同时定义
5

6
struct Temperature : IEquatable<Temperature>
7
{
8
    public double Celsius { get; }
9
    public Temperature(double c) => Celsius = c;
10

11
    // == 和 != 成对
12
    public static bool operator ==(Temperature a, Temperature b)
13
        => a.Celsius == b.Celsius;
14
    public static bool operator !=(Temperature a, Temperature b)
15
        => !(a == b);
16

17
    // < 和 > 成对
18
    public static bool operator <(Temperature a, Temperature b)
19
        => a.Celsius < b.Celsius;
20
    public static bool operator >(Temperature a, Temperature b)
21
        => a.Celsius > b.Celsius;
22

23
    // <= 和 >= 也成对（定义了 < 和 > 后编译器不自动生成 <= >=）
24
    public static bool operator <=(Temperature a, Temperature b)
25
        => a.Celsius <= b.Celsius;
26
    public static bool operator >=(Temperature a, Temperature b)
27
        => a.Celsius >= b.Celsius;
28

29
    // 重载 == 必须重写 Equals + GetHashCode + 实现 IEquatable<T>
30
    public override bool Equals(object obj)
31
        => obj is Temperature t && this == t;
32
    public override int GetHashCode()
33
        => Celsius.GetHashCode();
34
    public bool Equals(Temperature other) => this == other;
35
}

1
// 场景：数据库连接状态类，有三种状态
2
class DbConnection
3
{
4
    public enum State { Disconnected, Connected, Error }
5
    public State CurrentState { get; set; }
6

7
    // true: 连接可用
8
    public static bool operator true(DbConnection conn)
9
        => conn.CurrentState == State.Connected;
10

11
    // false: 连接不可用（未连接或出错）
12
    public static bool operator false(DbConnection conn)
13
        => conn.CurrentState != State.Connected;
14

15
    // 配合 & 运算符，支持短路逻辑
16
    public static DbConnection operator &(DbConnection a, DbConnection b)
17
        => a.CurrentState == State.Connected ? b : a;
18
}
19

20
// 使用：自然的条件判断
21
DbConnection conn = new DbConnection { CurrentState = State.Connected };
22
if (conn)  // 隐式调用 operator true(conn) → Connected → true
23
{
24
    conn.Execute("SELECT * FROM Players");
25
}
26

27
// 甚至可以 &&（编译器转为 operator true + operator &）：
28
var conn2 = new DbConnection { CurrentState = State.Connected };
29
if (conn && conn2)  // 短路：如果 conn 为 false，conn2 不会被评估
30
{
31
    // ...
32
}

1
struct Celsius
2
{
3
    public double Value { get; }
4
    public Celsius(double v) => Value = v;
5

6
    // implicit: 隐式转换 — 安全，不丢失信息
7
    public static implicit operator double(Celsius c) => c.Value;
8

9
    // explicit: 显式转换 — 可能失败或丢失精度
10
    public static explicit operator Celsius(double d)
11
    {
12
        if (d < -273.15)
13
            throw new ArgumentOutOfRangeException(nameof(d),
14
                "温度不能低于绝对零度");
15
        return new Celsius(d);
16
    }
17
}
18

19
// 使用区别
20
Celsius c = new Celsius(100);
21
double d = c;                      // ✅ 隐式，不需要 cast
22
Celsius back = (Celsius)d;         // ✅ 显式，需要 cast
23
// Celsius bad = d;                // ❌ 编译错误，explicit 必须 cast
24

25
// 设计原则：
26
// implicit: 从"小"到"大"，不丢失信息（如 int → long，Celsius → double）
27
// explicit: 从"大"到"小"，可能丢失信息或抛异常（如 double → int，double → Celsius）

1
// C# 编译器的一条重要规则：
2
// 如果定义了 operator +，编译器自动生成 operator +=
3
// 你不需要手动定义 +=、-=、*=、/=、%= 等
4

5
struct Vec3
6
{
7
    public float X, Y, Z;
8

9
    public static Vec3 operator +(Vec3 a, Vec3 b)
10
        => new Vec3 { X = a.X + b.X, Y = a.Y + b.Y, Z = a.Z + b.Z };
11

12
    // += 自动由 + 生成！
13
    // a += b;  → 编译器展开为 a = a + b;
14
}
15

16
// 注意：如果你想要高效的 +=（原地修改而非分配新对象），
17
// 需要手动定义，但通常不让 struct 可变是更好的设计

1
// 当多个运算符重载同时匹配时的解析规则
2
struct Vector
3
{
4
    public float X, Y;
5

6
    // 两个版本的乘法
7
    public static Vector operator *(Vector v, float s) => new Vector { X = v.X * s, Y = v.Y * s };
8
    public static Vector operator *(float s, Vector v) => new Vector { X = v.X * s, Y = v.Y * s };
9
    // ↑ 两个都要定义以支持 v * 3.0f 和 3.0f * v
10
}
11

12
// 编译器解析步骤（和 C++ 的 ADL 不同）：
13
// 1. 非成员候选：在当前命名空间和作用域中查找所有 operator @
14
// 2. 成员候选：在操作数的类型中查找成员 operator @
15
// 3. 如果两个操作数都定义了 operator @ → 二义性错误

1
// 委托内部有两个关键 IntPtr 字段：
2
// _methodPtr:  指向方法 JIT 编译后的本地代码
3
// _methodPtrAux: 辅助指针（用于泛型方法或接口调用转换）
4

5
class Player
6
{
7
    public int GetScore() => 100;
8
}
9

10
Player p = new Player();
11
Func<int> getScore = p.GetScore;  // 委托指向实例方法
12

13
// 委托内部：
14
// _target     = p 的引用          （因为这是实例方法）
15
// _methodPtr  = GetScore() JIT 代码的地址
16

17
Func<int> staticMethod = () => 42;  // Lambda 指向静态方法
18

19
// 委托内部（闭包版本）：
20
// _target     = 闭包类的实例       （Lambda 捕获变量时生成 DisplayClass）
21
// _methodPtr  = Lambda 体的 JIT 代码地址

1
// ❌ 每帧分配新委托
2
void Update()
3
{
4
    // 每次 Update 都 new 一个 Action 委托对象在堆上
5
    ExecuteAction(() => transform.Translate(1, 0, 0));
6
    // → GC.Alloc 16-32 字节（委托对象）+ 可能的闭包分配
7
}
8

9
// ✅ 缓存委托
10
private Action _cachedAction;
11

12
void Start()
13
{
14
    _cachedAction = () => transform.Translate(1, 0, 0);  // 只分配一次
15
}
16

17
void Update()
18
{
19
    ExecuteAction(_cachedAction);  // 零分配
20
}
21

22
// ✅ 用静态 Lambda（C# 9+）避免闭包分配
23
void Update()
24
{
25
    // static 关键字确保 Lambda 不捕获任何变量 → 编译器可能重用一个静态委托实例
26
    ExecuteAction(static () => Console.WriteLine("tick"));
27
}

1
// 委托分配成本对比实验
2
class DelegateAllocTest
3
{
4
    private int _counter = 0;
5

6
    // ❌ 实例方法委托 —— 每次创建都分配（因为 _target 是 this）
7
    public Action CreateInstanceAction() => () => _counter++;
8
    // 每次调用 CreateInstanceAction() 都创建一个新的委托对象
9

10
    // ✅ 静态方法委托 —— 可以缓存为单例
11
    private static void StaticMethod() { }
12
    public Action GetStaticAction() => StaticMethod;
13
    // 多次调用 GetStaticAction() 可能返回同一个委托对象（编译器优化）
14

15
    // ✅ 静态 Lambda —— C# 9+，明确告诉编译器不捕获变量
16
    public Action GetStaticLambda() => static () => Console.WriteLine("tick");
17
    // static Lambda 不捕获任何变量 → 编译器可以缓存为静态字段
18
}

1
// 你写的：
2
public event Action OnDamage;
3
// OnDamage += HandleDamage;
4
// OnDamage -= HandleDamage;
5

6
// 编译器为 event 生成的 add_OnDamage（简化示意）：
7
private Action _onDamage;
8
public void add_OnDamage(Action value)
9
{
10
    Action handler2;
11
    Action current = _onDamage;
12
    do
13
    {
14
        handler2 = current;
15
        Action combined = (Action)Delegate.Combine(handler2, value);
16
        current = Interlocked.CompareExchange(ref _onDamage, combined, handler2);
17
    } while (current != handler2);
18
}
19
// Interlocked.CompareExchange 保证即使在多线程同时 += 时也不会丢失订阅者

1
// 委托适合：单一方法、需要 Lambda 表达式、需要多播
2
// 接口适合：多个方法、有状态、需要类层次
3

4
// ✅ 用委托：一次性回调
5
void LoadAssetAsync(string path, Action<Asset> onComplete);
6

7
// ✅ 用接口：多方法的策略模式
8
interface IDamageCalculator
9
{
10
    float CalculateDamage(AttackData attack, DefenseData defense);
11
    DamageType GetDamageType();
12
    string GetDescription();
13
}
14

15
// ✅ 混合：用委托但暴露接口（如 LINQ 的 IComparer<T> 与 Comparsion<T>）

1
// 委托声明时用 in/out 标记支持变型
2
delegate TResult Func<in T, out TResult>(T arg);
3
//                   ↑ 逆变      ↑ 协变
4

5
// 协变：返回值可以用更具体的类型
6
Func<object, string> f1 = o => o.ToString();
7
Func<string, object> f2 = f1;  // ✅ string → object 是协变
8

9
// 逆变：参数可以用更抽象的类型
10
Action<object> printObj = o => Console.WriteLine(o);
11
Action<string> printStr = printObj;  // ✅ object → string 是逆变
12
// printStr 调用时传入 string，但接收端期望 object → 安全
13

14
// 逆变的实际用途：事件处理
15
public event EventHandler<EventArgs> GenericEvent;
16
// 订阅者可以用更具体的参数类型
17
void OnKeyPress(object sender, KeyEventArgs e) { }
18
GenericEvent += OnKeyPress;  // ✅ KeyEventArgs 继承自 EventArgs

1
// === 你写的代码 ===
2
int counter = 0;
3
int factor = 2;
4
Action increment = () => {
5
    counter += factor;
6
    Console.WriteLine(counter);
7
};
8
increment();  // 输出 2
9

10
// === 编译器生成的代码（反编译简化） ===
11
[CompilerGenerated]
12
sealed class <>c__DisplayClass0_0
13
{
14
    public int counter;   // 捕获的 counter
15
    public int factor;    // 捕获的 factor
16

17
    internal void <M>b__0()
18
    {
19
        counter += factor;
20
        Console.WriteLine(counter);
21
    }
22
}
23

24
// 使用侧变成：
25
var closure = new <>c__DisplayClass0_0();
26
closure.counter = 0;
27
closure.factor = 2;
28
Action increment = new Action(closure.<M>b__0);
29
increment();  // 输出 2
30
Console.WriteLine(closure.counter);  // 2 —— counter 已经被修改了

1
// 多个 Lambda 捕获同一个作用域的变量 → 共享同一个闭包实例
2
int x = 0;
3
int y = 10;
4

5
Action incX = () => x++;
6
Action incY = () => y++;
7

8
// 编译器生成一个 DisplayClass，同时包含 x 和 y
9
// DisplayClass {
10
//     public int x;
11
//     public int y;
12
//     void IncX() => x++;
13
//     void IncY() => y++;
14
// }
15

16
incX();
17
Console.WriteLine(x);  // 1
18
Console.WriteLine(y);  // 10 —— 通过同一闭包实例访问

1
// ❌ 最经典的闭包面试题
2
var actions = new List<Action>();
3
for (int i = 0; i < 5; i++)
4
{
5
    actions.Add(() => Console.WriteLine(i));
6
}
7
foreach (var act in actions)
8
    act();
9
// 输出：5 5 5 5 5
10

11
// 为什么？
12
// for 循环的 i 在整个循环体中只有一个变量实例
13
// 编译器生成一个 DisplayClass 包含 i
14
// 所有 5 个 Lambda 共享同一个 DisplayClass 实例的同一个 i 字段
15
// 循环结束后 i = 5，所有 Lambda 看到的都是 5
16

17
// ✅ 修复一：为每次迭代创建独立变量
18
for (int i = 0; i < 5; i++)
19
{
20
    int copy = i;  // ← 每次迭代都 new 一个新的 copy
21
    actions.Add(() => Console.WriteLine(copy));
22
}
23
// 输出：0 1 2 3 4
24

25
// ✅ 修复二：用 foreach（C# 5.0+ 修复了 foreach 的这个问题）
26
foreach (int i in Enumerable.Range(0, 5))
27
{
28
    actions.Add(() => Console.WriteLine(i));
29
}
30
// 输出：0 1 2 3 4
31
// 原因：C# 5+ 的 foreach 每次迭代的迭代变量都是独立的（编译器行为变更）
32

33
// ⚠️ 但 foreach over array 仍然是旧行为（C# 优化为 for）
34
int[] arr = { 0, 1, 2, 3, 4 };
35
foreach (int i in arr)
36
{
37
    actions.Add(() => Console.WriteLine(i));
38
}
39
// 这是数组优化后的 foreach → 变量 i 只有一个！

1
// 静态 Lambda 的运行时优势
2
class Component
3
{
4
    private int _state;
5

6
    // ❌ 普通 Lambda：创建闭包捕获 this._state
7
    public Action GetHandler_Bad() => () => Process(_state);
8
    // 每次调用 GetHandler_Bad() → 分配 DisplayClass + Action
9

10
    // ✅ 静态 Lambda + 参数：零闭包
11
    public Action GetHandler_Good()
12
    {
13
        int stateCopy = _state;
14
        return () => Process(stateCopy);
15
    }
16
    // 如果编译器能内联 → 可能零分配
17

18
    // ✅ 最优：静态 + 不捕获任何东西
19
    public Action GetHandler_Best() => static () => Console.WriteLine("tick");
20
    // 编译器可能缓存为静态只读字段，永久复用同一个委托实例
21
}

1
// 闭包捕获和传参的选择
2

3
// 方式一：闭包捕获（简洁但有分配）
4
Action CreateCounter_Closure()
5
{
6
    int count = 0;
7
    return () => Console.WriteLine(++count);  // 分配 DisplayClass
8
}
9

10
// 方式二：对象字段（零分配，但需要维护类）
11
class Counter
12
{
13
    private int _count;
14
    public void Increment() => Console.WriteLine(++_count);
15
}
16

17
// 选择原则：
18
// 临时/低频操作 → 闭包（代码简洁）
19
// 热路径/高频调用 → 对象字段或静态 Lambda（零分配）

1
// 当 Lambda 被赋值给 Expression<T> 时，编译器不生成 IL 代码，
2
// 而是生成一棵代表表达式结构的 AST
3
Expression<Func<int, int, int>> addExpr = (a, b) => a + b;
4

5
// addExpr 不是委托，不能直接调用！
6
// addExpr(3, 4);  // ❌ 编译错误
7

8
// 需要先编译为委托
9
var add = addExpr.Compile();
10
Console.WriteLine(add(3, 4));  // 7
11

12
// 表达式树的内部结构（简化）：
13
// LambdaExpression
14
//   Body: BinaryExpression (Add)
15
//     Left: ParameterExpression (a)
16
//     Right: ParameterExpression (b)
17
//   Parameters: [ParameterExpression(a), ParameterExpression(b)]
18

19
// 这就是 LINQ to SQL 的核心：
20
// db.Users.Where(u => u.Age > 18)
21
// ↑ 这个 Lambda 被编译为 Expression，然后被翻译为 SQL

1
struct Vector3 : IEquatable<Vector3>
2
{
3
    public float X, Y, Z;
4

5
    public Vector3(float x, float y, float z) => (X, Y, Z) = (x, y, z);
6

7
    // 算术
8
    public static Vector3 operator +(Vector3 a, Vector3 b)
9
        => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);
10
    public static Vector3 operator -(Vector3 a, Vector3 b)
11
        => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
12
    public static Vector3 operator *(Vector3 v, float s)
13
        => new(v.X * s, v.Y * s, v.Z * s);
14
    public static Vector3 operator *(float s, Vector3 v) => v * s;
15
    public static Vector3 operator /(Vector3 v, float s)
16
        => new(v.X / s, v.Y / s, v.Z / s);
17

18
    // 一元
19
    public static Vector3 operator -(Vector3 v) => new(-v.X, -v.Y, -v.Z);
20

21
    // 点积（不重载为运算符，保持数学直觉——运算符只做逐元素操作）
22
    public static float Dot(Vector3 a, Vector3 b)
23
        => a.X * b.X + a.Y * b.Y + a.Z * b.Z;
24

25
    // 比较
26
    public static bool operator ==(Vector3 a, Vector3 b)
27
        => a.X == b.X && a.Y == b.Y && a.Z == b.Z;
28
    public static bool operator !=(Vector3 a, Vector3 b) => !(a == b);
29

30
    public override bool Equals(object obj) => obj is Vector3 v && this == v;
31
    public override int GetHashCode() => HashCode.Combine(X, Y, Z);
32
    public bool Equals(Vector3 other) => this == other;
33
}
34

35
// 使用体验：完全自然的物理计算
36
Vector3 position = new(100, 50, 0);
37
Vector3 velocity = new(5, -2, 0);
38
Vector3 gravity = new(0, -9.81f, 0);
39
float dt = 0.016f;
40

41
position += velocity * dt + 0.5f * gravity * dt * dt;
42
// 读起来就是物理公式，没有 .Add() .Multiply() 的噪音

1
// 游戏中 Buff/Debuff 系统：多个效果叠加
2
public class ModifierStack<T>
3
{
4
    private Func<T, T> _modifiers;
5

6
    public void Add(Func<T, T> modifier) => _modifiers += modifier;
7
    public void Remove(Func<T, T> modifier) => _modifiers -= modifier;
8

9
    public T Apply(T input)
10
    {
11
        T result = input;
12
        if (_modifiers != null)
13
        {
14
            foreach (Func<T, T> m in _modifiers.GetInvocationList())
15
                result = m(result);
16
        }
17
        return result;
18
    }
19
}
20

21
// 使用：伤害计算流水线
22
var damagePipeline = new ModifierStack<float>();
23
damagePipeline.Add(d => d * 1.2f);  // +20% 攻击力
24
damagePipeline.Add(d => d + 50);    // +50 固定伤害
25
damagePipeline.Add(d => d * 0.8f);  // 目标有 20% 减伤
26

27
float final = damagePipeline.Apply(100);
28
// 计算顺序：(100 * 1.2 + 50) * 0.8 = 136
29
// 注意：Apply 的顺序 = 添加顺序（先加的在外层）

1
// Unity UI 事件：用 event 封装，防止外部误调
2
public class GameButton
3
{
4
    public event Action OnClick;
5
    public event Action OnHoverEnter;
6
    public event Action OnHoverExit;
7

8
    // 内部触发（只有 Button 自己可以 Invoke）
9
    private void HandlePointerDown()
10
    {
11
        OnClick?.Invoke();  // ✅ 类内可以调用
12
    }
13

14
    // 提供线程安全的触发
15
    protected virtual void RaiseOnClick()
16
    {
17
        var handler = OnClick;  // 快照避免竞态
18
        handler?.Invoke();
19
    }
20
}
21

22
// 外部使用（只能订阅/取消，不能调用）
23
var btn = new GameButton();
24
btn.OnClick += () => AudioManager.Play("click.wav");     // ✅
25
btn.OnClick += () => SceneManager.LoadScene("Battle");   // ✅
26
// btn.OnClick();  // ❌ 编译错误！外部不能 Invoke 事件
27
// btn.OnClick = null;  // ❌ 编译错误！外部不能赋值（会清掉其他模块的订阅）

1
// 游戏资源 Handle：支持向基类隐式转换，向子类显式转换
2
struct AssetHandle<T> where T : UnityEngine.Object
3
{
4
    private string _path;
5
    private T _cached;
6

7
    public AssetHandle(string path) => _path = path;
8

9
    // 向 T 隐式转换 —— 自动加载
10
    public static implicit operator T(AssetHandle<T> handle)
11
    {
12
        if (handle._cached == null)
13
            handle._cached = Resources.Load<T>(handle._path);
14
        return handle._cached;
15
    }
16

17
    // 向基类转换 —— 安全
18
    public static implicit operator AssetHandle<UnityEngine.Object>(AssetHandle<T> handle)
19
        => new AssetHandle<UnityEngine.Object>(handle._path);
20
}
21

22
// 使用
23
AssetHandle<Texture2D> heroTex = new AssetHandle<Texture2D>("Textures/Hero");
24
Texture2D tex = heroTex;          // 隐式加载
25
AssetHandle<Object> generic = heroTex;  // 隐式向基类转换