1
// 游戏中最要命的事：在帧循环里触发 Gen 2 GC
2
void Update()  // 每帧调用
3
{
4
    // ❌ 每帧分配大对象可能触发 Full GC → 卡顿
5
    var buffer = new byte[100000];  // > 85KB → LOH
6

7
    // ✅ 在 Start 中预分配，Update 中复用
8
}
9

10
// 预分配策略
11
private byte[] _buffer = new byte[100000];  // 一次分配，永久使用
12
void Update()
13
{
14
    Array.Clear(_buffer, 0, _buffer.Length);  // 复用
15
}

1
class NativeResource
2
{
3
    private IntPtr _handle;  // 非托管资源句柄
4

5
    public NativeResource()
6
    {
7
        _handle = NativeAPI.CreateResource();
8
    }
9

10
    // Finalizer：GC 回收前调用，最后的兜底
11
    ~NativeResource()
12
    {
13
        // ⚠️ Finalizer 在专门的 Finalizer 线程上运行
14
        // ⚠️ 你不知道什么时候会调用
15
        // ⚠️ 有 Finalizer 的对象回收更慢（需要两次 GC）
16
        NativeAPI.ReleaseResource(_handle);
17
    }
18
}
19

20
// 有 Finalizer 的对象的回收过程：需要两轮 GC！
21

22
// 这意味着有 Finalizer 的对象至少要多活一轮 GC！

1
```csharp
2
// ✅ 正确模式：IDisposable + Finalizer 双保险
3
class NativeResource : IDisposable
4
{
5
    private IntPtr _handle;
6
    private bool _disposed = false;
7

8
    public NativeResource()
9
    {
10
        _handle = NativeAPI.CreateResource();
11
    }
12

13
    // 主动清理（用户调用或 using）
14
    public void Dispose()
15
    {
16
        Dispose(true);
17
        GC.SuppressFinalize(this);  // 告诉 GC：不用调 Finalizer 了
18
    }
19

20
    // 兜底清理（GC 调用）
21
    ~NativeResource()
22
    {
23
        Dispose(false);
24
    }
25

26
    protected virtual void Dispose(bool disposing)
27
    {
28
        if (_disposed) return;
29

30
        if (disposing)
31
        {
32
            // 清理托管资源（其他 IDisposable 对象）
33
            // 这里托管对象可能还没被回收（因为 GC 顺序不确定）
34
        }
35

36
        // 清理非托管资源（无论 disposing 是 true 还是 false 都要做）
37
        if (_handle != IntPtr.Zero)
38
        {
39
            NativeAPI.ReleaseResource(_handle);
40
            _handle = IntPtr.Zero;
41
        }
42

43
        _disposed = true;
44
    }
45
}

1
// using 语句 —— C# 版的 RAII（针对 IDisposable）
2
// 编译器展开：
3

4
// 你写的：
5
using (var file = File.OpenRead("data.bin"))
6
{
7
    // 使用文件
8
}
9

10
// 编译器生成的（简化）：
11
var file = File.OpenRead("data.bin");
12
try
13
{
14
    // 使用文件
15
}
16
finally
17
{
18
    if (file != null)
19
        ((IDisposable)file).Dispose();
20
}
21
// finally 保证：即使抛异常，file 也会被 Dispose

1
// 最简单的对象池实现
2
class ObjectPool<T> where T : class, new()
3
{
4
    private readonly Stack<T> _available = new Stack<T>();
5

6
    public T Rent()
7
    {
8
        if (_available.Count > 0)
9
            return _available.Pop();
10
        return new T();
11
    }
12

13
    public void Return(T item)
14
    {
15
        // 重置状态（如果实现了 IResettable）
16
        if (item is IResettable resettable)
17
            resettable.Reset();
18
        _available.Push(item);
19
    }
20
}
21

22
// 使用
23
var pool = new ObjectPool<List<int>>();
24
var list = pool.Rent();
25
list.Add(42);
26
// ... 使用 ...
27
pool.Return(list);  // 放回池子里，不丢给 GC

1
// Unity 中的对象池（GameObject 版本）
2
class BulletPool
3
{
4
    private readonly Queue<GameObject> _pool = new Queue<GameObject>();
5
    private readonly GameObject _prefab;
6

7
    public GameObject Spawn(Vector3 pos, Quaternion rot)
8
    {
9
        GameObject obj;
10
        if (_pool.Count > 0)
11
        {
12
            obj = _pool.Dequeue();
13
            obj.SetActive(true);
14
        }
15
        else
16
        {
17
            obj = Object.Instantiate(_prefab);
18
        }
19
        obj.transform.SetPositionAndRotation(pos, rot);
20
        return obj;
21
    }
22

23
    public void Despawn(GameObject obj)
24
    {
25
        obj.SetActive(false);
26
        _pool.Enqueue(obj);
27
    }
28
}

1
// 强引用：只要存在，GC 就不会回收
2
object strong = new object();  // 强引用
3

4
// 弱引用：GC 可以回收，回收后 Target 变为 null
5
WeakReference weak = new WeakReference(new object());
6

7
if (weak.TryGetTarget(out object target))
8
{
9
    // 对象还活着，使用它
10
    Console.WriteLine(target);
11
}
12
else
13
{
14
    // 对象已被 GC 回收
15
}
16

17
// 游戏中的应用：缓存
18
class TextureCache
19
{
20
    private Dictionary<string, WeakReference<Texture2D>> _cache = new();
21

22
    public Texture2D GetOrLoad(string path)
23
    {
24
        if (_cache.TryGetValue(path, out var weakRef)
25
            && weakRef.TryGetTarget(out var tex))
26
        {
27
            return tex;  // 缓存命中
28
        }
29

30
        var newTex = LoadTexture(path);  // 重新加载
31
        _cache[path] = new WeakReference<Texture2D>(newTex);
32
        return newTex;
33
    }
34
    // 优势：内存紧张时，未使用的 Texture 可以被 GC 自动回收
35
    //       不需要手动"卸载未使用资源"
36
}

1
// C# 的 try-catch-finally
2

3
try
4
{
5
    // 可能抛异常的代码
6
    var data = File.ReadAllText("config.json");
7
    var config = JsonSerializer.Deserialize<Config>(data);
8
}
9
catch (FileNotFoundException ex)
10
{
11
    // 精确捕获
12
    Console.WriteLine($"配置文件不存在: {ex.FileName}");
13
}
14
catch (JsonException ex)
15
{
16
    Console.WriteLine($"配置格式错误: {ex.Message}");
17
}
18
catch (Exception ex) when (ex is not OutOfMemoryException)
19
{
20
    // ✅ C# 6.0 异常过滤器（Exception Filter）
21
    // 只捕获除了 OOM 之外的异常
22
    Console.WriteLine($"其他错误: {ex.Message}");
23
}
24
finally
25
{
26
    // 无论是否抛异常，这里都会执行
27
    // 用于释放资源（但 using 更优雅）
28
}

1
// 竞技游戏的帧循环：16ms 一帧，GC 暂停不能 > 1ms
2
public class CombatFrame
3
{
4
    // 预分配所有临时缓冲区
5
    private readonly List<DamageEvent> _damageEvents = new(64);
6
    private readonly List<CollisionPair> _collisions = new(256);
7
    private readonly CombatResult[] _results = new CombatResult[256];
8

9
    public void Tick(float dt)
10
    {
11
        _damageEvents.Clear();
12
        _collisions.Clear();
13

14
        // 收集伤害事件 → _damageEvents（复用，零分配）
15
        CollectDamageEvents(_damageEvents);
16

17
        // 碰撞检测 → _collisions（复用，零分配）
18
        DetectCollisions(_collisions);
19

20
        // 处理结果 → _results（复用，零分配）
21
        int resultCount = ProcessCombat(_damageEvents, _collisions, _results);
22

23
        // 应用结果
24
        for (int i = 0; i < resultCount; i++)
25
            ApplyResult(_results[i]);
26

27
        // 整帧 0 次 GC 分配！
28
    }
29
}

1
// 加载多个资源，任何一个失败都安全回滚
2
class LevelLoader
3
{
4
    private List<GameObject> _loadedAssets = new List<GameObject>();
5

6
    public bool TryLoadLevel(string levelName)
7
    {
8
        var tempAssets = new List<GameObject>();
9
        try
10
        {
11
            // 加载地形
12
            var terrain = Resources.Load<GameObject>($"Levels/{levelName}/Terrain");
13
            if (terrain == null) throw new AssetLoadException("Terrain not found");
14
            tempAssets.Add(Object.Instantiate(terrain));
15

16
            // 加载建筑
17
            var buildings = Resources.Load<GameObject>($"Levels/{levelName}/Buildings");
18
            if (buildings == null) throw new AssetLoadException("Buildings not found");
19
            tempAssets.Add(Object.Instantiate(buildings));
20

21
            // 全部成功 → 提交
22
            _loadedAssets.AddRange(tempAssets);
23
            return true;
24
        }
25
        catch (AssetLoadException ex)
26
        {
27
            Debug.LogError($"关卡加载失败: {ex.Message}");
28
            // 回滚：销毁已加载的临时资源
29
            foreach (var asset in tempAssets)
30
                Object.Destroy(asset);
31
            return false;
32
        }
33
    }
34
}

1
public class ParticlePool
2
{
3
    private struct PooledParticle
4
    {
5
        public ParticleSystem System;
6
        public float ReturnTime;     // 预定归还时间
7
    }
8

9
    private Queue<int> _freeIndices = new();
10
    private PooledParticle[] _pool = new PooledParticle[1024];
11
    private int _activeCount = 0;
12

13
    public ParticleSystem Rent(ParticleSystem prefab, Vector3 pos, float duration)
14
    {
15
        if (_freeIndices.TryDequeue(out int index))
16
        {
17
            // 复用已有粒子系统
18
            ref var p = ref _pool[index];
19
            p.System.transform.position = pos;
20
            p.System.Play();
21
            p.ReturnTime = Time.time + duration;
22
            return p.System;
23
        }
24
        else
25
        {
26
            // 创建新的（仅在池耗尽时分配）
27
            var system = Object.Instantiate(prefab, pos, Quaternion.identity);
28
            if (_activeCount >= _pool.Length)
29
                Array.Resize(ref _pool, _pool.Length * 2);
30
            _pool[_activeCount++] = new PooledParticle
31
            {
32
                System = system,
33
                ReturnTime = Time.time + duration
34
            };
35
            return system;
36
        }
37
    }
38

39
    public void Update()
40
    {
41
        // 回收超时的粒子
42
        float now = Time.time;
43
        for (int i = 0; i < _activeCount; i++)
44
        {
45
            ref var p = ref _pool[i];
46
            if (p.System.isPlaying && now >= p.ReturnTime)
47
            {
48
                p.System.Stop();
49
                _freeIndices.Enqueue(i);
50
            }
51
        }
52
    }
53
}