第十一章 Unity C# 性能优化#

一句话理解：Unity C# 性能优化的核心只有三件事——控制 GC 分配（不让垃圾产生）、利用 Job System + Burst（把计算移出主线程且用 SIMD 加速）、理解 IL2CPP 的优化边界（避免写出在 AOT 下慢 10 倍的代码）。其他优化都是这三件事的延伸。

11.1 概念直觉 —— 性能问题的根源#

flowchart TD subgraph "Unity 帧预算 (60fps = 16.67ms)" SCRIPTS["C# 脚本逻辑 Update/LateUpdate/Coroutine 目标: < 5ms"] PHYS["物理模拟 FixedUpdate / PhysX 目标: < 3ms"] RENDER["渲染管线 Culling / Batch / DrawCall 目标: < 7ms"] OTHER["引擎开销 / 余量 ~1.67ms"] end subgraph "C# 侧的性能杀手" GC["GC.Collect 尖峰 分代 GC 扫描整个堆 单次 1-50ms 暂停"] ALLOC["每帧分配 new class / 装箱 / LINQ 累积 → 触发 GC"] REFLECT["反射调用 GetComponent / SendMessage 每次 100-1000x 开销"] MAIN_THREAD["主线程阻塞 同步 IO / 锁等待"] end GC -->|"帧预算超支"| SCRIPTS ALLOC --> GC REFLECT --> SCRIPTS MAIN_THREAD --> SCRIPTS style GC fill:#d00000,stroke:#e85d04,color:white style ALLOC fill:#d00000,stroke:#e85d04,color:white style SCRIPTS fill:#2d6a4f,stroke:#40916c,color:white

11.2 GC 避免 —— 最优先的优化#

11.2.1 分配热力图#

GC 问题排查的第一步不是乱改代码，而是定位分配热点。Unity Profiler 的 CPU Usage 模块可以按帧显示 GC Alloc 量。

1
// 每帧分配检测 —— 使用 Profiler.BeginSample 定位
2
void Update()
3
{
4
    Profiler.BeginSample("AI.Update");
5
    UpdateAI();  // 如果这里分配了 2KB/帧，60fps = 120KB/s，很快触发 GC
6
    Profiler.EndSample();
7
}
8

9
// 常见的分配陷阱（每条都在产生垃圾）：
10
// ✗ foreach 在非数组类型上（产生 IEnumerator 装箱）
11
// ✗ LINQ 热路径（迭代器分配）
12
// ✗ string 拼接（产生中间 string）
13
// ✗ lambda 捕获局部变量（产生闭包类）
14
// ✗ 没有缓存的 GetComponent<>()（内部分配）

11.2.2 六大 GC 避免策略#

策略 1：对象池

1
public class BulletPool
2
{
3
    private readonly Queue<Bullet> _pool = new();
4
    private readonly Bullet _prefab;
5

6
    public Bullet Get(Vector3 position, Quaternion rotation)
7
    {
8
        Bullet bullet;
9
        if (_pool.Count > 0)
10
        {
11
            bullet = _pool.Dequeue();
12
            bullet.gameObject.SetActive(true);
13
        }
14
        else
15
        {
16
            bullet = Object.Instantiate(_prefab);
17
        }
18
        bullet.transform.SetPositionAndRotation(position, rotation);
19
        return bullet;
20
    }
21

22
    public void Return(Bullet bullet)
23
    {
24
        bullet.gameObject.SetActive(false);
25
        _pool.Enqueue(bullet);
26
    }
27
}

策略 2：struct 替代 class

参考第一章——高频创建的数据使用 struct 避免堆分配：

1
// ✗ 每帧 1000 个 Entity 状态查询 → 1000 次堆分配
2
class EntityState { public int HP; public Vector3 Position; }
3

4
// ✓ 值类型 —— 零 GC 分配
5
struct EntityState { public int HP; public Vector3 Position; }
6

7
// 但注意：struct 不要太大（超过 16-24 字节时复制成本超过分配成本）

策略 3：缓存组件引用

1
public class OptimizedComponent : MonoBehaviour
2
{
3
    // ✗ 错误示范
4
    void Update()
5
    {
6
        GetComponent<Rigidbody>().AddForce(Vector3.up);    // 每次分配 + 查找
7
        GetComponent<Renderer>().material.color = Color.red; // material 产生新实例！
8
    }
9

10
    // ✓ 缓存引用
11
    private Rigidbody _rb;
12
    private Renderer _renderer;
13

14
    void Awake()
15
    {
16
        _rb = GetComponent<Rigidbody>();
17
        _renderer = GetComponent<Renderer>();
18
    }
19

20
    void Update()
21
    {
22
        _rb.AddForce(Vector3.up);
23
        _renderer.sharedMaterial.color = Color.red;  // sharedMaterial 不复制
24
    }
25
}

策略 4：避免装箱

1
// ✗ 隐式装箱
2
int damage = 100;
3
string message = "造成 " + damage + " 点伤害";     // int → string 需要 int.ToString()
4
Debug.Log(damage);                                   // Debug.Log(object) → 装箱
5

6
// ✓ 避免
7
string message = $"造成 {damage} 点伤害";            // string interpolation 内部避免装箱
8
Debug.Log(damage.ToString());                         // 显式调用，但大多数情况下没必要
9

10
// ✗ 最隐蔽的装箱：将 struct 当作 interface 使用
11
struct DamageInfo : ICombatInfo { public int Value; }
12
ICombatInfo info = new DamageInfo { Value = 100 };   // 装箱！
13
int v = info.Value;                                    // 每次访问都在装箱的对象上
14

15
// ✓ 使用泛型约束避免装箱
16
void Process<T>(T info) where T : ICombatInfo
17
{
18
    int v = info.Value;  // 无装箱——JIT 为每种 T 生成直接调用
19
}

策略 5：StringBuilder 缓存与字符串优化

1
// ✗ 热路径中的字符串拼接
2
string uiText = "HP: " + currentHP + " / " + maxHP + " (" + percentage + "%)";
3
// 分配 5 个中间 string
4

5
// ✓ StringBuilder 缓存
6
private StringBuilder _uiBuilder = new StringBuilder(100);
7
void UpdateUI(int currentHP, int maxHP)
8
{
9
    _uiBuilder.Clear();  // 不重新分配！
10
    _uiBuilder.Append("HP: ");
11
    _uiBuilder.Append(currentHP);
12
    _uiBuilder.Append(" / ");
13
    _uiBuilder.Append(maxHP);
14
    _uiBuilder.Append(" (");
15
    _uiBuilder.Append(currentHP * 100 / maxHP);
16
    _uiBuilder.Append("%)");
17
    _uiText.text = _uiBuilder.ToString();
18
}

策略 6：避免 foreach 在 List 上的分配

1
// ✗ 在 Unity 旧版本 Mono 中，foreach List<T> 有装箱
2
foreach (var enemy in _enemies)  // 旧 Mono: IEnumerator<T> 装箱
3
    enemy.UpdateAI();
4

5
// ✓ 使用 for 循环（零分配）
6
for (int i = 0; i < _enemies.Count; i++)
7
    _enemies[i].UpdateAI();
8

9
// .NET Core / 新版本中 foreach 已无装箱，但 for 仍比 foreach 略快（少一次 MoveNext 调用）

11.3 Job System —— 多线程任务调度#

11.3.1 概念直觉#

Unity C# Job System 允许将计算密集型任务分配到工作线程执行，利用多核 CPU。

flowchart LR subgraph "主线程" MAIN["MonoBehaviour.Update 安排 Job"] COLLECT["收集 JobHandle 等待完成"] end subgraph "Worker Threads" W1["Worker 0 Execute IJobParallelFor batch[0..255]"] W2["Worker 1 Execute IJobParallelFor batch[256..511]"] W3["Worker 2 Execute IJobParallelFor batch[512..767]"] W4["Worker 3 Execute IJobParallelFor batch[768..1023]"] end MAIN -->|"Schedule()"| W1 MAIN -->|"自动分派"| W2 MAIN -->|"自动分派"| W3 MAIN -->|"自动分派"| W4 W1 -->|"JobHandle"| COLLECT W2 -->|"JobHandle"| COLLECT W3 -->|"JobHandle"| COLLECT W4 -->|"JobHandle"| COLLECT style W1 fill:#2d6a4f,stroke:#40916c,color:white style W2 fill:#2d6a4f,stroke:#40916c,color:white style W3 fill:#2d6a4f,stroke:#40916c,color:white style W4 fill:#2d6a4f,stroke:#40916c,color:white

11.3.2 IJobParallelFor —— 最常用的 Job#

1
using Unity.Jobs;
2
using Unity.Collections;
3
using Unity.Burst;
4

5
// 定义一个 Job
6
[BurstCompile]  // 启用 Burst 编译
7
public struct MoveJob : IJobParallelFor
8
{
9
    [ReadOnly] public NativeArray<Vector3> Directions;   // 只读输入
10
    [ReadOnly] public float DeltaTime;
11
    public NativeArray<Vector3> Positions;                // 可写输出
12

13
    public void Execute(int index)
14
    {
15
        // Burst 将此函数编译为高度优化的机器码（可能包含 SIMD 指令）
16
        Positions[index] += Directions[index] * DeltaTime;
17
    }
18
}
19

20
// 在 MonoBehaviour 中调度
21
public class MovementSystem : MonoBehaviour
22
{
23
    private NativeArray<Vector3> _positions;
24
    private NativeArray<Vector3> _directions;
25

26
    void Update()
27
    {
28
        var job = new MoveJob
29
        {
30
            Directions = _directions,
31
            DeltaTime = Time.deltaTime,
32
            Positions = _positions
33
        };
34

35
        // Schedule: 并行执行，batchSize 控制每个 worker 的批大小
36
        JobHandle handle = job.Schedule(_positions.Length, batchSize: 64);
37

38
        // 可以继续在主线程调度其他 Job...
39

40
        // 最终：等待 Job 完成
41
        handle.Complete();
42

43
        // 现在 _positions 已更新，可以用于渲染
44
    }
45

46
    void OnDestroy()
47
    {
48
        // NativeArray 必须手动释放！
49
        _positions.Dispose();
50
        _directions.Dispose();
51
    }
52
}

11.3.3 Job 的依赖链#

1
// 复杂的多阶段计算
2
var phase1 = new Phase1Job { Input = rawData, Output = phase1Result };
3
var phase2 = new Phase2Job { Input = phase1Result, Output = phase2Result };
4

5
// phase2 依赖 phase1 的输出
6
JobHandle handle1 = phase1.Schedule(dataLength, 64);
7
JobHandle handle2 = phase2.Schedule(dataLength, 64, handle1);  // 传入依赖
8

9
// 两个独立的 Job 可以并行
10
var physicsJob = new PhysicsJob { /* ... */ };
11
var animationJob = new AnimationJob { /* ... */ };
12
JobHandle h1 = physicsJob.Schedule(count, 32);
13
JobHandle h2 = animationJob.Schedule(count, 32);
14

15
// 合并多个依赖——合并后的 Job 等 h1 和 h2 都完成才执行
16
var renderJob = new RenderJob { /* ... */ };
17
JobHandle combinedHandle = JobHandle.CombineDependencies(h1, h2);
18
JobHandle h3 = renderJob.Schedule(count, 32, combinedHandle);
19

20
// 等待所有完成
21
h3.Complete();

graph TD subgraph "Phase 1（数据准备）" Physics["PhysicsJob Worker 0 + Worker 1"] Anim["AnimationJob Worker 2 + Worker 3"] end subgraph "Phase 2（后处理）" Render["RenderJob 等待 Physics + Animation 全部完成后执行"] end Physics -->|"handle1"| Combined{"CombineDependencies (handle1, handle2)"} Anim -->|"handle2"| Combined Combined -->|"combinedHandle"| Render MainThread["主线程"] -.->|"Schedule Physics"| Physics MainThread -.->|"Schedule Animation"| Anim MainThread -.->|"Schedule Render (传入 combinedHandle)"| Combined MainThread -->|"h3.Complete() 等待所有完成"| Render style Physics fill:#2d6a4f,stroke:#40916c,color:white style Anim fill:#2d6a4f,stroke:#40916c,color:white style Render fill:#1b4332,stroke:#52b788,color:white style Combined fill:#e85d04,stroke:#f48c06,color:white

11.3.4 NativeContainer 类型#

类型	用途	线程安全
`NativeArray<T>`	连续数组	读写保护（schedule 自动加锁）
`NativeList<T>`	可变长度列表	并行写入受限
`NativeHashMap<K,V>`	哈希映射	仅 ParallelWriter 支持并行写入
`NativeQueue<T>`	队列	仅主线程写入
`NativeStream`	每个线程独立的输出流	并行安全（天然隔离）

11.4 Burst Compiler —— LLVM 后端优化#

11.4.1 Burst 的核心原理#

Burst Compiler 将 C# IL 通过 LLVM 编译为高度优化的本机代码：

1
C# Job 代码 → IL 字节码 → Burst (LLVM) → 优化的机器码
2
                                         ↓
3
                              ● SIMD 自动向量化
4
                              ● 循环展开
5
                              ● 常量折叠与传播
6
                              ● 内联展开（跨函数调用）
7
                              ● 死代码消除

11.4.2 Burst 的适用与不适用#

1
// ✓ Burst 极适合的场景（纯计算、无引用类型、无 Unity API 调用）
2
[BurstCompile]
3
public struct CalculateDamageJob : IJobParallelFor
4
{
5
    [ReadOnly] public NativeArray<float> AttackStats;
6
    [ReadOnly] public NativeArray<float> DefenseStats;
7
    [ReadOnly] public NativeArray<ElementType> Elements;
8
    public NativeArray<float> Results;
9

10
    public void Execute(int i)
11
    {
12
        // 纯数学计算 → Burst 优化到极致
13
        float baseDmg = AttackStats[i];
14
        float defense = DefenseStats[i];
15

16
        // Burst 会将这些分支编译为条件移动指令 (cmov) 避免分支预测失败
17
        float reduction = defense / (defense + 200f);
18
        float elementMod = Elements[i] switch
19
        {
20
            ElementType.Fire => 1.2f,
21
            ElementType.Ice => 0.8f,
22
            _ => 1.0f
23
        };
24

25
        Results[i] = baseDmg * (1f - reduction) * elementMod;
26
    }
27
}
28

29
// ✗ Burst 不支持的
30
// - 任何引用类型 (class) 的访问
31
// - Unity API 调用 (Transform, GameObject, MonoBehaviour)
32
// - 字符串操作
33
// - try-catch 异常处理
34
// - 虚方法调用（接口也不行）

11.4.3 Burst SIMD 示例#

1
[BurstCompile]
2
public struct VectorMultiplyJob : IJobParallelFor
3
{
4
    [ReadOnly] public NativeArray<Vector3> Vectors;
5
    [ReadOnly] public float Multiplier;
6
    public NativeArray<Vector3> Results;
7

8
    public void Execute(int i)
9
    {
10
        // Burst 自动检测到这是 3 分量的乘法，一次性用 SSE/NEON 指令处理
11
        Results[i] = Vectors[i] * Multiplier;
12
        // 生成的汇编大致为：
13
        //   movss  xmm0, [input]      ; 加载 x
14
        //   movss  xmm1, [input+4]    ; 加载 y
15
        //   movss  xmm2, [input+8]    ; 加载 z
16
        //   mulss  xmm0, xmm3         ; 同时乘法
17
        //   mulss  xmm1, xmm3
18
        //   mulss  xmm2, xmm3
19
        //   movss  [output], xmm0     ; 存储结果
20
        //   ...
21
    }
22
}

11.5 IL2CPP 专项优化#

11.5.1 IL2CPP 下的代码大小优化#

1
// IL2CPP 将每个泛型实例化都生成独立的 C++ 代码
2
// 以下代码在 IL2CPP 下会产生巨大的代码膨胀：
3

4
// ✗ 大量泛型实例化
5
void ProcessAll()
6
{
7
    Process<int>(1);
8
    Process<float>(2f);
9
    Process<double>(3.0);
10
    Process<long>(4L);
11
    Process<short>(5);
12
    Process<byte>(6);
13
    // 每个 T 类型的 Process<T> 在 IL2CPP 下生成独立 C++ 代码！
14
}
15

16
// ✓ 减少泛型多样性
17
void ProcessAll()
18
{
19
    // 如果可以，尽量统一为一种类型
20
    ProcessFloat(1f);
21
    ProcessFloat(2f);
22
    ProcessFloat(3f);
23
}

11.5.2 托管代码剥离防护#

IL2CPP 在构建时会剥离未直接引用的类型（Managed Code Stripping）。导致运行时 Type.GetType() 或反射失败：

1
<!-- link.xml：保护需要反射访问的类型不被剥离 -->
2
<linker>
3
    <assembly fullname="Assembly-CSharp">
4
        <type fullname="MyGame.Player" preserve="all" />
5
        <namespace fullname="MyGame.Weapons" preserve="all" />
6
    </assembly>
7

8
    <!-- 保护 System.Collections.Generic 的特定泛型实例化 -->
9
    <assembly fullname="mscorlib">
10
        <type fullname="System.Collections.Generic.List`1">
11
            <genericargument name="MyGame.Player" />
12
        </type>
13
    </assembly>
14
</linker>

11.6 常见陷阱与反模式#

陷阱 1：Find 方法的隐藏开销#

1
// ✗ 每帧搜索
2
void Update()
3
{
4
    var player = GameObject.Find("Player");          // 遍历整个 Hierarchy —— O(n)
5
    var enemies = GameObject.FindGameObjectsWithTag("Enemy");  // 同样 O(n)
6
    var comp = FindObjectOfType<GameManager>();       // 遍历所有 GameObject
7
}
8

9
// ✓ 启动时缓存
10
private GameObject _player;
11
private GameManager _gameManager;
12
private List<GameObject> _enemies = new();
13

14
void Start()
15
{
16
    _player = GameObject.Find("Player");
17
    _gameManager = FindObjectOfType<GameManager>();
18
}
19

20
void OnEnable()
21
{
22
    // 如果需要动态更新敌人列表，使用事件或碰撞检测而非每帧 Find
23
    EnemySpawner.OnEnemySpawned += OnEnemyAdded;
24
    EnemySpawner.OnEnemyDestroyed += OnEnemyRemoved;
25
}

陷阱 2：Material 属性访问分配#

1
// ✗ 每帧分配新的 Material 实例
2
renderer.material.color = Color.red;  // .material 会 clone 一份！
3

4
// ✓ 使用 sharedMaterial（不影响其他相同材质的对象时）
5
renderer.sharedMaterial.color = Color.red;
6

7
// 如果需要每实例不同的材质属性，使用 MaterialPropertyBlock（零分配）
8
private MaterialPropertyBlock _propBlock;
9
void Start() => _propBlock = new MaterialPropertyBlock();
10

11
void UpdateColor(Color color)
12
{
13
    _propBlock.SetColor("_Color", color);
14
    renderer.SetPropertyBlock(_propBlock);  // 零分配！
15
}

陷阱 3：Transform 组件访问#

1
// ✗ Transform 的位置修改会产生矩阵重新计算
2
transform.position += Vector3.one * Time.deltaTime;
3
// 每次修改 position 都会：
4
// 1. 通知物理引擎
5
// 2. 触发 OnTransformChanged 消息
6
// 3. 重新计算世界矩阵
7
// 4. 重新计算子物体的世界矩阵
8

9
// 对于大量物体的位置更新，考虑：
10
// - 使用 C# Job System + TransformAccessArray
11
// - 或者减少 Transform 层级（摊平 Hierarchy）

陷阱 4：不必要的 Coroutine 分配#

1
// ✗ 每次 StartCoroutine 分配 WaitForSeconds 对象
2
IEnumerator BadPattern()
3
{
4
    while (true)
5
    {
6
        yield return new WaitForSeconds(0.1f);  // 每次循环都 new！
7
    }
8
}
9

10
// ✓ 缓存 YieldInstruction
11
private static readonly WaitForSeconds WaitPointOneSeconds = new WaitForSeconds(0.1f);
12

13
IEnumerator GoodPattern()
14
{
15
    while (true)
16
    {
17
        yield return WaitPointOneSeconds;  // 复用
18
    }
19
}
20

21
// WaitForEndOfFrame、WaitForFixedUpdate 也是同理

陷阱 5：Update 空转#

1
// ✗ 每个 MonoBehaviour 都有自己的 Update——即使为空
2
public class EmptyUpdate : MonoBehaviour
3
{
4
    void Update()
5
    {
6
        // 空的 Update 也会消耗引擎开销：
7
        // C++ → C# 跨域调用 + 方法查找 + 帧计数更新
8
        // 1000 个空 Update 可能消耗 1ms+
9
    }
10
}
11

12
// ✓ 移除非必要的 Update，使用事件驱动
13
public class EventDriven : MonoBehaviour
14
{
15
    void OnEnable()
16
    {
17
        GameEvents.OnTick += HandleTick;  // 只在需要时订阅
18
    }
19

20
    void OnDisable()
21
    {
22
        GameEvents.OnTick -= HandleTick;
23
    }
24

25
    void HandleTick(float deltaTime)
26
    {
27
        // 只有一个订阅点调用，而不是每组件一个 Update
28
    }
29
}

11.7 面试题精选#

Q1：Unity 中最常见的性能问题来源是什么？按优先级排序。

答：优先级排序：

GC 分配：每帧的堆分配累积触发 GC，造成 1-50ms 的尖峰暂停
DrawCall 过多：每个不同材质/Shader 的渲染对象产生额外 DrawCall（非 C# 问题，但有 C# 侧的优化方法如 GPU Instancing）
过多的 Update 调用：大量 MonoBehaviour 的 Update 空转消耗 C++→C# 调用开销
反射/字符串查找：SendMessage、GetComponent(string)、GameObject.Find()
Overdraw + 复杂 Shader：GPU 侧瓶颈

Q2：Unity Job System 和 C# 的 Task Parallel Library 有什么区别？

答：

Job System：Unity 原生线程池，与引擎紧密集成。Job 可以在 Burst Compiler 下编译。NativeContainer 提供自动的读写冲突检测。但不能访问 Unity API（Transform、GameObject 等）。
Task Parallel Library（TPL）：C# 标准库的多线程 API（Task.Run、Parallel.For）。可以访问任何 C# API，但不能直接访问 Unity API（仍需主线程）。不与 Burst 集成。在线程池管理上不如 Job System 高效（Job System 使用 lock-free work-stealing）。

Q3：IL2CPP 下，泛型代码的 AOT 生成有什么限制？

答：IL2CPP 在编译时分析所有可直接证明的泛型实例化。对于值类型泛型，IL2CPP 尝试共享代码但如果值类型大小不同则必须生成独立版本。对于引用类型泛型，所有引用类型共享一份代码（和 JIT 一样）。限制：通过反射或用变量间接创建的泛型实例化（如 MakeGenericType(typeof(T))）可能被遗漏，需要 link.xml 或 [Preserve] 显式保留。

Q4：Burst Compiler 为什么不能编译所有 C# 代码？

答：Burst 的目标是高性能计算——它的类型系统限于 HPC（High-Performance Computing）子集。不支持引用类型是因为 Burst 生成无 GC 的代码（使用自己的内存管理）。不支持 Unity API 是因为 Unity 对象需要通过 C++ 互操作层访问。不支持 try-catch 是因为 Burst 追求零开销的异常模型（类似 C++ 的 -fno-exceptions）。

Q5：1000 个敌人每帧移动，怎么优化？

答：

Job System + Burst：IJobParallelFor 在多个 worker 线程处理，Burst SIMD 加速向量运算
TransformAccessArray：配合 Job 批量更新 Transform，避免 C#→C++ 的逐次互操作开销
LOD 降频：远处敌人每 3 帧更新一次
ECS (DOTS)：如果项目规模极大，迁移到 Entity Component System 彻底消除 MonoBehaviour 开销
Animator Culling：屏幕外敌人禁用 Animator

11.8 游戏开发实战#

场景 1：AOE 伤害计算 —— Job System 化#

1
[BurstCompile]
2
public struct AOEDamageJob : IJobParallelFor
3
{
4
    [ReadOnly] public Vector3 Center;
5
    [ReadOnly] public float Radius;
6
    [ReadOnly] public float Damage;
7
    [ReadOnly] public NativeArray<Vector3> TargetPositions;
8
    [ReadOnly] public NativeArray<float> TargetHealths;
9

10
    public NativeArray<float> Results;          // 输出的新生命值
11
    public NativeArray<bool> WasHit;            // 哪些目标被命中
12

13
    public void Execute(int i)
14
    {
15
        float distSq = math.distancesq(Center, TargetPositions[i]);
16
        if (distSq < Radius * Radius)
17
        {
18
            // 距离越近伤害越高（线性衰减）
19
            float dist = math.sqrt(distSq);
20
            float falloff = 1f - (dist / Radius);
21
            Results[i] = TargetHealths[i] - Damage * falloff;
22
            WasHit[i] = true;
23
        }
24
        else
25
        {
26
            Results[i] = TargetHealths[i];
27
            WasHit[i] = false;
28
        }
29
    }
30
}
31

32
// 使用
33
public class AOESystem : MonoBehaviour
34
{
35
    private NativeArray<Vector3> _positions;
36
    private NativeArray<float> _healths;
37
    private NativeArray<float> _results;
38
    private NativeArray<bool> _wasHit;
39

40
    public void ExecuteAOE(Vector3 center, float radius, float damage)
41
    {
42
        var job = new AOEDamageJob
43
        {
44
            Center = center,
45
            Radius = radius,
46
            Damage = damage,
47
            TargetPositions = _positions,
48
            TargetHealths = _healths,
49
            Results = _results,
50
            WasHit = _wasHit
51
        };
52

53
        JobHandle handle = job.Schedule(_positions.Length, 64);
54
        handle.Complete();
55

56
        // 在主线程处理被命中的目标（触发特效、音效等 Unity API 操作）
57
        for (int i = 0; i < _wasHit.Length; i++)
58
        {
59
            if (_wasHit[i])
60
            {
61
                _healths[i] = _results[i];
62
                OnEnemyHit?.Invoke(i, damage);
63
            }
64
        }
65
    }
66
}

场景 2：零 GC UI 更新#

1
public class DamageNumberDisplay : MonoBehaviour
2
{
3
    // 对象池化的 Damage 数字
4
    private static readonly Queue<DamageNumber> _pool = new();
5

6
    [SerializeField] private Transform _worldSpaceCanvas;
7
    private readonly StringBuilder _builder = new();
8
    private Camera _camera;
9

10
    public void ShowDamage(Vector3 worldPos, float damage, bool isCritical)
11
    {
12
        var display = GetOrCreate();
13
        display.transform.position = worldPos;
14

15
        _builder.Clear();
16
        _builder.Append(isCritical ? "<color=red>" : "");
17
        _builder.Append(Mathf.CeilToInt(damage));
18
        _builder.Append(isCritical ? "</color>" : "");
19

20
        display.SetText(_builder.ToString());
21
        display.PlayAnimation();
22
    }
23

24
    private DamageNumber GetOrCreate()
25
    {
26
        return _pool.Count > 0 ? _pool.Dequeue() : Instantiate(_prefab, _worldSpaceCanvas);
27
    }
28

29
    public static void Return(DamageNumber number) => _pool.Enqueue(number);
30
}

场景 3：Burst 加速的曲线计算#

1
[BurstCompile]
2
public struct EvaluateCurveJob : IJobParallelFor
3
{
4
    [ReadOnly] public NativeArray<Keyframe> Keyframes;  // 序列化的关键帧
5
    [ReadOnly] public int KeyframeCount;
6
    [ReadOnly] public NativeArray<float> Inputs;
7
    public NativeArray<float> Outputs;
8

9
    public void Execute(int i)
10
    {
11
        float t = Inputs[i];
12

13
        // 查找 t 所在的段（Burst 优化的二分查找）
14
        int segment = 0;
15
        for (int k = 1; k < KeyframeCount; k++)
16
        {
17
            if (Keyframes[k].time > t)
18
                break;
19
            segment = k;
20
        }
21

22
        // 线性插值
23
        var k0 = Keyframes[segment];
24
        var k1 = Keyframes[math.min(segment + 1, KeyframeCount - 1)];
25

26
        float localT = (t - k0.time) / math.max(k1.time - k0.time, 0.0001f);
27
        Outputs[i] = math.lerp(k0.value, k1.value, localT);
28
    }
29
}

11.9 三十秒速答#

问题	答案
GC 的单项最大优化？	对象池 + struct 替代 class——消除高频分配
Job System 适合什么？	纯计算、无 Unity API 访问、可并行的数据批量处理
Burst 的核心价值？	LLVM 编译 C# IL → 高度优化机器码，自动 SIMD 向量化
IL2CPP 下最大陷阱？	Managed Code Stripping 删除了反射需要的类型 → link.xml 保护
foreach vs for？	新版 .NET 区别不大，旧 Mono foreach 有装箱；在热路径用 for 更心安
Material.material 为什么危险？	每次访问都 clone 一份新 Material——GC 分配 + 增加 DrawCall

11.10 延伸阅读#

[01_type_system] —— struct vs class 选择与 Span<T> 的零分配栈操作
[02_gc_and_resource_management] —— GC 触发机制与分代回收细节
[05_generics_and_collections] —— 集合性能参考表与选择决策
[09_clr_and_compilation] —— IL2CPP 深度剖析
[10_monobehaviour_in_depth] —— 序列化与 MonoBehaviour 生命周期
Unity DOTS Documentation
Burst User Guide

音乐

音乐