1
// C# 泛型的 IL 表示
2
// 你写的：
3
T Max<T>(T a, T b) where T : IComparable<T>
4
    => a.CompareTo(b) > 0 ? a : b;
5

6
// 编译为 IL（保留泛型）：
7
// .method private hidebysig static !!T Max<([mscorlib]System.IComparable`1<!!T>) T>
8
//        (!!T a, !!T b) cil managed
9
// {
10
//     // IL 中用 !!T 表示"类型参数"，不做展开
11
// }
12

13
// 运行时 JIT 的策略：
14
// 1. 对于所有引用类型（T = string, T = object, T = Player…）
15
//    → 所有引用类型指针大小相同（64位下 8 字节），共享一份机器码
16
//    原因：引用类型操作都是指针操作，和具体类型无关
17
//
18
// 2. 对于值类型
19
//    → 相同大小的值类型共享一份机器码
20
//    → 不同大小的值类型需要不同的机器码（因为寄存器/栈帧布局不同）
21
//    int(4), float(4), uint(4) → 共享
22
//    long(8), double(8) → 共享
23
//    struct{int,int,int}(12) → 独享

1
// 每个封闭泛型类型有独立的静态构造函数
2
class Generic<T>
3
{
4
    public static int Value;
5

6
    static Generic()
7
    {
8
        Console.WriteLine($"初始化 Generic<{typeof(T).Name}>");
9
        Value = typeof(T) == typeof(int) ? 100 : 10;
10
    }
11
}
12

13
// 第一次访问 Generic<int> 时 → 触发 Generic<int> 的静态构造函数
14
Console.WriteLine(Generic<int>.Value);     // 输出：初始化 Generic<Int32> / 100
15

16
// 第一次访问 Generic<string> 时 → 触发 Generic<string> 的静态构造函数
17
Console.WriteLine(Generic<string>.Value);  // 输出：初始化 Generic<String> / 10
18

19
// Generic<int> 和 Generic<string> 在运行时是完全不同的类型
20
// → 有独立的静态字段、独立的方法表、独立的静态构造函数

1
// 这可以用于"编译期常量化"技巧
2
class Factory<T>
3
{
4
    public static readonly bool IsValueType;
5

6
    static Factory()
7
    {
8
        IsValueType = typeof(T).IsValueType;
9
        // 运行时 typeof(T) 的真实类型在这里可用
10
    }
11
}
12

13
// 在泛型方法中，静态只读字段的值可以驱动 JIT 做分支消除
14
bool ShouldUseStack<T>()
15
{
16
    if (Factory<T>.IsValueType)
17
        return true;   // JIT：对于 T=int，这是常量 true → 死代码消除
18
    else
19
        return false;  // JIT：对于 T=string，这是常量 false → 死代码消除
20
}

1
// 六种约束的完整示例
2
// ① base class: T 必须是 Stream 或其派生类
3
void Read<T>(T stream) where T : Stream { }
4

5
// ② interface: T 必须实现 IComparable<T>
6
//    struct + 接口约束 = 不装箱的接口调用（JIT 可以内联）
7
void Sort<T>(T[] items) where T : IComparable<T> { }
8

9
// ③ class: T 必须是引用类型
10
void HandleRef<T>(T obj) where T : class { }
11

12
// ④ struct: T 必须是值类型
13
//    配合 unmanaged 可以在 unsafe 中取指针
14
void ProcessValue<T>(T[] data) where T : struct { }
15

16
// ⑤ new(): T 必须有 public 无参构造
17
T Create<T>() where T : new() => new T();
18

19
// ⑥ unmanaged (C# 7.3+): T 不能包含任何引用
20
unsafe void Process<T>(T[] data) where T : unmanaged
21
{
22
    fixed (T* p = data) { /* 安全的指针操作 */ }
23
}
24
// unmanaged 类型：sbyte/byte/short/ushort/int/uint/long/ulong/
25
//                  float/double/char/bool/decimal/IntPtr/UIntPtr/
26
//                  以及全部由上述类型构成的 struct

1
// 约束的组合和限制
2
// ✅ 可以组合多个约束
3
void Process<T>(T item)
4
    where T : class, IDisposable, new()
5
{ }
6

7
// ❌ 不能同时约束 class 和 struct（互斥）
8
// void Foo<T>(T x) where T : class, struct { }  // 编译错误
9

10
// ❌ new() 必须放在最后
11
// void Foo<T>() where T : new(), IDisposable { }  // 编译错误
12
// void Foo<T>() where T : IDisposable, new() { }  // ✅
13

14
// ❌ 不能约束为 System.Array、System.Delegate、System.Enum
15
//     但可以用 class/struct/接口来等效约束
16

17
// C# 7.3+: 约束为 Enum 或 Delegate
18
void EnumOnly<T>() where T : struct, Enum { }
19
void DelegateOnly<T>() where T : class, Delegate { }

1
// 协变/逆变不仅是编译期检查，运行时也会验证
2

3
// 协变：IEnumerable<out T>
4
IEnumerable<string> strings = new List<string> { "a", "b" };
5
IEnumerable<object> objects = strings;  // ✅ 编译通过，运行时也安全
6

7
// 但要注意数组协变的历史坑（Java/C# 都有）
8
string[] strArr = { "a", "b" };
9
object[] objArr = strArr;      // ✅ 数组协变（C# 1.0 就支持）
10
objArr[0] = 123;               // ❌ ArrayTypeMismatchException！
11
// 运行时数组知道自己的真实类型是 string[]，拒绝存储 int
12

13
// List<T> 没有这个坑，因为 T 是不变的（没有 out/in）
14
// List<string> listStr = new List<string> { "a", "b" };
15
// List<object> listObj = listStr;  // ❌ 编译错误！List<T> 没有 out

1
// EqualityComparer<T>.Default 的查找顺序：
2
//
3
// 1. 如果 T 实现了 IEquatable<T>
4
//    → 使用 GenericEqualityComparer<T>（内部调用 IEquatable<T>.Equals）
5
//    → 对值类型不装箱
6
//
7
// 2. 如果 T 没有实现 IEquatable<T>，且 T 是引用类型
8
//    → 使用 ObjectEqualityComparer<T>（内部调用 Object.Equals）
9
//    → 对值类型有装箱开销
10
//
11
// 3. 如果 T 是 Nullable<U>
12
//    → 使用 NullableEqualityComparer<U>（处理 null 逻辑）
13
//
14
// 4. 如果 T 是 enum
15
//    → 使用 EnumEqualityComparer<T>（直接整数比较，极快）
16
//
17
// 5. 如果 T 实现了 IStructuralEquatable
18
//    → 没有特殊处理，走默认路径
19

20
// 这就是为什么 struct 实现 IEquatable<T> 至关重要：
21
// 没实现 → Object.Equals(object) → 装箱 + 虚调用
22
// 实现了 → GenericEqualityComparer<T> → 直接调用，不装箱

1
// 验证不同选择器的性能差异
2
struct Point : IEquatable<Point>
3
{
4
    public int X, Y;
5

6
    public bool Equals(Point other) => X == other.X && Y == other.Y;
7
    public override bool Equals(object obj) => obj is Point p && Equals(p);
8
    public override int GetHashCode() => HashCode.Combine(X, Y);
9
}
10

11
struct PointSlow  // 没有实现 IEquatable<PointSlow>
12
{
13
    public int X, Y;
14
}
15

16
// Point 比较 → GenericEqualityComparer → 直接调用，零装箱
17
// PointSlow 比较 → ObjectEqualityComparer → 装箱 + 反射比较字段

1
// Dictionary<TKey, TValue> 内部结构（反编译简化）
2

3
struct Entry
4
{
5
    public uint hashCode;   // 哈希码缓存 + 状态标记
6
    // hashCode 的最高位 = 0: 该 Entry 空闲
7
    // hashCode 的最高位 = 1: 该 Entry 被使用
8
    public int next;        // 冲突链中下一个 Entry 的索引，-1 表示链尾
9
    public TKey key;
10
    public TValue value;
11
}
12

13
// 成员字段：
14
// int[] _buckets;       // _buckets[hashCode % buckets.Length] = Entry 索引
15
// Entry[] _entries;     // 紧凑存储所有键值对
16
// int _count;           // 已使用的 Entry 数
17
// int _freeList;        // 空闲 Entry 链表头（用 next 字段链接空闲槽）
18
// int _freeCount;       // 空闲 Entry 数
19
// int _version;         // 修改计数（foreach 检测修改）
20
// IEqualityComparer<TKey> _comparer; // 比较器

1
// ReadOnlyCollection<T> — 现有集合的只读包装，零拷贝
2
List<int> list = new List<int> { 1, 2, 3 };
3
ReadOnlyCollection<int> readOnly = list.AsReadOnly();
4
// readOnly[0] = 10;  // ❌ 编译错误
5

6
// ImmutableList<T> — System.Collections.Immutable
7
// 每次"修改"都创建新实例（持久化数据结构，类似 Clojure）
8
var immList = ImmutableList.Create<int>(1, 2, 3);
9
var newList = immList.Add(4);  // immList 不变，newList 是新实例（结构共享）
10

11
// FrozenSet<T> / FrozenDictionary<K,V> — .NET 8.0
12
// 构建时做大量优化工作（完美哈希、线性扫描选择）
13
// 构建后只读，查找速度比普通 HashSet/Dictionary 快 20-50%
14
// 适合：游戏配置表这类"启动时构建，运行时只读"的数据
15
var frozen = Enumerable.Range(0, 1000)
16
    .Select(i => $"key_{i}")
17
    .ToFrozenSet();
18
// frozen 的内部哈希表经过编译器级优化

1
var list = new List<int> { 1, 2, 3, 4, 5 };
2

3
// ❌ InvalidOperationException: Collection was modified
4
foreach (var x in list)
5
    if (x == 3) list.Remove(x);
6

7
// 原因：List<T>.Enumerator 在 MoveNext() 时检查 _version
8
//      任何修改操作（Add/Remove/Insert）都会增加 _version
9
//      枚举器发现不匹配 → 抛异常
10

11
// ✅ 方案一：RemoveAll
12
list.RemoveAll(x => x == 3);
13

14
// ✅ 方案二：倒序 for
15
for (int i = list.Count - 1; i >= 0; i--)
16
    if (list[i] == 3) list.RemoveAt(i);

1
struct Point
2
{
3
    public int X, Y;
4
    // ❌ 没有显式实现 GetHashCode 和 Equals
5
}
6

7
var dict = new Dictionary<Point, string>();
8
dict[new Point { X = 1, Y = 2 }] = "A";
9

10
// 查找：反射逐字段计算哈希 + 比较 → 极慢
11
var found = dict.TryGetValue(new Point { X = 1, Y = 2 }, out var value);
12
// found 可能是 false！为什么？
13
// ValueType.GetHashCode 对包含引用类型的 struct 只基于第一个字段计算哈希
14
// 如果第一个字段相等但第二个字段不同 → 哈希冲突但 Equals 比较失败
15

16
// ✅ 修复：实现 IEquatable<Point> + 重写 Equals/GetHashCode
17
public override int GetHashCode() => HashCode.Combine(X, Y);

1
class ObjectPool<T> where T : class, new()
2
{
3
    private readonly Stack<T> _pool = new();
4

5
    public T Rent()
6
    {
7
        if (_pool.TryPop(out var item))
8
        {
9
            (item as IPoolable)?.OnRent();
10
            return item;
11
        }
12
        var newItem = new T();
13
        (newItem as IPoolable)?.OnRent();
14
        return newItem;
15
    }
16

17
    public void Return(T item)
18
    {
19
        (item as IPoolable)?.OnReturn();
20
        _pool.Push(item);
21
    }
22
}
23

24
interface IPoolable
25
{
26
    void OnRent();
27
    void OnReturn();
28
}
29

30
class Bullet : IPoolable
31
{
32
    public Vector3 Position;
33
    public bool Active;
34

35
    public void OnRent() => Active = true;
36
    public void OnReturn() { Position = default; Active = false; }
37
}
38

39
// 使用
40
var bullets = new ObjectPool<Bullet>();
41
Bullet b = bullets.Rent();
42
b.Position = spawnPoint;
43
// ... 使用完毕 ...
44
bullets.Return(b);

1
// SparseSet：给每个实体类型存储组件数据，O(1) 增删查
2
class SparseSet<T> where T : struct
3
{
4
    private int[] _sparse;    // entityId → dense 索引（-1 = 不存在）
5
    private int[] _dense;     // 反向：dense 索引 → entityId
6
    private T[] _components;   // 组件数据紧密排列
7
    private int _count;
8

9
    public int Count => _count;
10

11
    public SparseSet(int maxEntities)
12
    {
13
        _sparse = new int[maxEntities];
14
        Array.Fill(_sparse, -1);
15
        _dense = new int[maxEntities];
16
        _components = new T[maxEntities];
17
    }
18

19
    public ref T Add(int entityId, T component)
20
    {
21
        _sparse[entityId] = _count;
22
        _dense[_count] = entityId;
23
        _components[_count] = component;
24
        return ref _components[_count++];  // ref 返回允许原地修改
25
    }
26

27
    public ref T Get(int entityId) => ref _components[_sparse[entityId]];
28

29
    public bool Has(int entityId) =>
30
        (uint)entityId < (uint)_sparse.Length && _sparse[entityId] != -1;
31

32
    public void Remove(int entityId)
33
    {
34
        int idx = _sparse[entityId];
35
        int lastEntity = _dense[_count - 1];
36

37
        // swap-remove 保持数组紧凑
38
        _components[idx] = _components[_count - 1];
39
        _dense[idx] = lastEntity;
40
        _sparse[lastEntity] = idx;
41
        _sparse[entityId] = -1;
42
        _count--;
43
    }
44

45
    // 迭代器：直接遍历 _components，零虚调用
46
    public ReadOnlySpan<T> AsSpan() => _components.AsSpan(0, _count);
47
}
48

49
// 使用
50
var positions = new SparseSet<Vector3>(10000);
51
positions.Add(entityId, new Vector3(1, 2, 3));
52
ref var pos = ref positions.Get(entityId);
53
pos.Y += 1.0f;  // 直接修改了数组内的数据

1
// 配置表：key 有序 → 方便按 ID 范围遍历
2
class ConfigTable
3
{
4
    private SortedDictionary<int, ItemConfig> _items;
5

6
    public ConfigTable(string csvPath)
7
    {
8
        // 从 CSV 加载，SortedDictionary 内建红黑树
9
        _items = new SortedDictionary<int, ItemConfig>();
10
        foreach (var row in File.ReadAllLines(csvPath).Skip(1))
11
        {
12
            var parts = row.Split(',');
13
            var config = new ItemConfig
14
            {
15
                ID = int.Parse(parts[0]),
16
                Name = parts[1],
17
                Price = int.Parse(parts[2])
18
            };
19
            _items[config.ID] = config;
20
        }
21
    }
22

23
    // O(log n) 查找单个
24
    public ItemConfig Get(int id) => _items.TryGetValue(id, out var c) ? c : null;
25

26
    // 按 ID 范围查询（利用 SortedDictionary 的有序性）
27
    public IEnumerable<ItemConfig> GetRange(int minId, int maxId)
28
    {
29
        // 内部用二分查找定位到 minId，然后中序遍历
30
        foreach (var kvp in _items)
31
        {
32
            if (kvp.Key < minId) continue;
33
            if (kvp.Key > maxId) break;
34
            yield return kvp.Value;
35
        }
36
    }
37
}

1
// 利用协变，让 AssetStore<T> 的只读接口统一
2
interface IReadOnlyAssetStore<out T> where T : UnityEngine.Object
3
{
4
    T Get(string path);
5
    bool TryGet(string path, out T asset);
6
}
7

8
class AssetStore<T> : IReadOnlyAssetStore<T> where T : UnityEngine.Object
9
{
10
    private Dictionary<string, T> _cache = new();
11

12
    public T Get(string path)
13
    {
14
        if (!_cache.TryGetValue(path, out var asset))
15
        {
16
            asset = Resources.Load<T>(path);
17
            _cache[path] = asset;
18
        }
19
        return asset;
20
    }
21

22
    public bool TryGet(string path, out T asset) => _cache.TryGetValue(path, out asset);
23
}
24

25
// 使用协变：可以统一传 IReadOnlyAssetStore<Object>
26
void PreloadAll(IReadOnlyAssetStore<UnityEngine.Object> store)
27
{
28
    // 这个函数接受任何 AssetStore<T>，因为 T 继承自 Object
29
}
30

31
var textureStore = new AssetStore<Texture2D>();
32
PreloadAll(textureStore);  // ✅ 协变，编译通过