罗罗编程学习记录
本页内容 展开查看

13.2.3 CSharp 脚本与架构

所属:全栈开发面试题库 / 13 游戏开发与实时渲染 / 13.2 Unity

覆盖范围

  • MonoBehaviour 生命周期
  • 协程(Coroutine)
  • 事件与委托
  • 依赖注入(DI)
  • DOTS/ECS

高频题速览

编号 题目 难度 频率
13.2.3-001 MonoBehaviour 的生命周期顺序是怎样的? 基础 ★★★★★
13.2.3-002 协程(Coroutine)的原理是什么? 进阶 ★★★★★
13.2.3-003 事件和直接调用有什么区别? 基础 ★★★★
13.2.3-004 为什么要避免在 Update 里 GetComponent? 基础 ★★★★
13.2.3-005 DOTS/ECS 解决什么问题? 高级 ★★★
13.2.3-006 协程和 async/await 的区别? 进阶 ★★★
13.2.3-007 C# 事件内存泄漏怎么防止? 进阶 ★★★★
13.2.3-008 单例模式在 Unity 里怎么用? 基础 ★★★★

13.2.3-001 MonoBehaviour 的生命周期顺序是怎样的?

一句话结论

Unity 生命周期:Awake → OnEnable → Start → FixedUpdate(物理)→ Update → LateUpdate → OnDisable → OnDestroy;编辑器下还有 Reset。

概念解释

  • Awake:对象实例化时调用,早于 Start,用于初始化引用。
  • OnEnable:对象启用时调用,每次 SetActive(true) 都调。
  • Start:第一次 Update 前调用,用于初始化。
  • FixedUpdate:固定步长物理更新,每帧可能多次。
  • Update:每帧调用。
  • LateUpdate:所有 Update 后调用,用于相机跟随。
  • OnDisable:对象禁用时调用。
  • OnDestroy:对象销毁时调用。

原理流程

  1. 实例化对象:Awake → OnEnable → Start(第一次)。
  2. 每帧:FixedUpdate(N 次)→ Update → LateUpdate。
  3. 禁用:OnDisable。
  4. 销毁:OnDestroy。

代码或图示

实例化:
  Awake() → OnEnable() → Start()

每帧:
  FixedUpdate() × N (物理步长)
  Update() × 1
  LateUpdate() × 1

禁用:OnDisable()
销毁:OnDestroy()

常见误区

  • 误区:Awake 和 Start 一样;正解:Awake 在实例化时立即调,Start 在第一次 Update 前;Awake 时对象可能还没 active。
  • 误区:OnEnable 只调一次;正解:每次 SetActive(true) 都调,反复启用禁用会多次调。

追问

  • 为什么用 Start 而不是 Awake?答:Awake 时其他对象可能还没初始化,Start 保证所有对象 Awake 完了;跨对象引用在 Start 里更安全。
  • OnApplicationQuit 和 OnDestroy 的区别?答:OnApplicationQuit 是应用退出,OnDestroy 是对象销毁;退出时先 OnApplicationQuit 再 OnDestroy。

13.2.3-002 协程(Coroutine)的原理是什么?

一句话结论

协程用迭代器(IEnumerator)实现暂停和恢复:yield return 暂停执行,下一帧或指定时间后继续;不是多线程,仍在主线程执行。

概念解释

  • 协程:用 IEnumerator + yield return 实现的分段执行。
  • yield return:暂停协程,返回一个等待条件(下一帧、几秒后、等异步操作)。
  • 主线程:协程仍在主线程执行,不是多线程。
  • StartCoroutine:启动协程。

原理流程

  1. StartCoroutine 启动协程,获取 IEnumerator。
  2. 执行到 yield return null,暂停,记录当前位置。
  3. 下一帧 Unity 继续执行 MoveNext,从暂停处继续。
  4. yield return new WaitForSeconds(1):等 1 秒后继续。

代码或图示

void Start() {
    StartCoroutine(LoadSceneRoutine());
}

IEnumerator LoadSceneRoutine() {
    Debug.Log("开始加载");
    yield return new WaitForSeconds(1f);  // 等 1 秒
    Debug.Log("1 秒后");
    yield return null;  // 等下一帧
    Debug.Log("下一帧");
}

常见误区

  • 误区:协程是多线程;正解:协程在主线程执行,只是分段暂停;不是真多线程。
  • 误区:协程可以并行;正解:协程仍在主线程,同一帧顺序执行;不并行。

追问

  • 协程怎么停止?答:StopCoroutine 或 StopAllCoroutines;协程所在 GameObject 销毁时协程自动停止。
  • WaitForSeconds 和 WaitForRealSeconds 的区别?答:WaitForSeconds 受 timeScale 影响(暂停游戏时暂停),WaitForRealSeconds 不受影响。

13.2.3-003 事件和直接调用有什么区别?

一句话结论

事件(event)是发布-订阅模式:发布者不知道订阅者是谁,松耦合;直接调用是硬编码依赖,调用者知道被调用者是谁;事件适合松耦合,直接调用适合明确依赖。

概念解释

  • 事件:event Action OnClick,发布者触发,订阅者注册回调。
  • 松耦合:发布者不需要知道订阅者,只触发事件。
  • 直接调用:player.OnClick(),调用者直接调方法。
  • 委托:事件的底层是委托(delegate)。

原理流程

  1. 直接调用:A 调 B.Method(),A 必须知道 B 存在。
  2. 事件:B 定义事件,A 注册 B.OnEvent += Handler,B 触发事件时 A 自动收到通知。
  3. 松耦合:B 不需要知道 A 存在,只触发事件。

代码或图示

// 直接调用(紧耦合)
player.OnDeath();  // 必须知道 player

// 事件(松耦合)
public event Action OnPlayerDeath;  // Player 类定义
// GameManager 订阅
Player.OnPlayerDeath += HandleDeath;
// Player 触发
OnPlayerDeath?.Invoke();

常见误区

  • 误区:事件总是比直接调用好;正解:事件松耦合但调试困难;明确依赖用直接调用更清晰。
  • 误区:事件没有性能开销;正解:事件触发要遍历订阅者列表,高频事件(如每帧)用直接调用更好。

追问

  • 事件和 C# event 的区别?答:C# event 是封装的委托,外部只能 +=/-=,不能直接 Invoke;普通委托外部可以 Invoke。
  • 什么是 EventBus?答:全局事件总线,任意对象发布和订阅事件,完全解耦;但调试困难,滥用会导致代码难以追踪。

13.2.3-004 为什么要避免在 Update 里 GetComponent?

一句话结论

GetComponent 是查找操作(遍历组件列表),每帧调用开销大;应该在 Start/Awake 缓存引用到字段,Update 直接用字段。

概念解释

  • GetComponent:在 GameObject 的组件列表中查找指定类型,O(n) 复杂度。
  • 缓存:在 Start 里找到引用,存为字段,Update 直接用字段。
  • SerializeField:编辑器拖拽引用,零运行时开销。

原理流程

  1. 错误:Update 里 GetComponent<Rigidbody>() 每帧遍历。
  2. 正确:Start 里 rb = GetComponent<Rigidbody>() 缓存到字段。
  3. 最佳:[SerializeField] Rigidbody rb 编辑器拖拽。

代码或图示

// 错误:每帧查找
void Update() {
    Rigidbody rb = GetComponent<Rigidbody>();  // 每帧遍历
    rb.MovePosition(...);
}

// 正确:Start 缓存
private Rigidbody rb;
void Start() {
    rb = GetComponent<Rigidbody>();
}
void Update() {
    rb.MovePosition(...);  // 直接用缓存
}

常见误区

  • 误区:GetComponent 很便宜;正解:每帧调用在 100 个对象时就是 100 次遍历;缓存是基本优化。
  • 误区:缓存后就不用管了;正解:如果组件被 Destroy 或 Disable,缓存引用可能失效;要检查 null。

追问

  • GetComponent 和 GetComponentInChildren 的区别?答:GetComponent 只查自身,GetComponentInChildren 递归查子节点;后者更慢。
  • 什么是 TryGetComponent?答:新版 API,返回 bool 和 out 参数,避免 null 检查。

13.2.3-005 DOTS/ECS 解决什么问题?

一句话结论

DOTS(Data-Oriented Technology Stack)用 ECS 数据布局解决传统 MonoBehaviour 的缓存不友好和多线程问题;大量小实体(粒子、群体 AI)时性能提升显著,但学习曲线陡。

概念解释

  • DOTS:Unity 的数据导向技术栈,包括 ECS、C# Job System、Burst Compiler。
  • ECS:Entity(ID)+ Component(纯数据)+ System(遍历逻辑),数据连续存储。
  • Job System:多线程并行计算。
  • Burst:把 C# 编译成高性能本机码,接近 C++ 性能。

原理流程

  1. 传统 MonoBehaviour:组件分散在堆上,遍历时缓存不命中,单线程。
  2. ECS:同类 Component 连续存储,遍历时缓存友好。
  3. Job System:System 遍历任务分发到多线程。
  4. Burst:编译 System 代码为本机码,向量化执行。

代码或图示

传统:1000 个敌人,每个敌人是 GameObject + MonoBehaviour
  遍历:GetComponent 链式查找,缓存不命中,单线程

ECS:1000 个 Entity,Position Component 连续存储
  Movement System:for each position in array:  // 连续内存,缓存友好
    并行 Job 计算

常见误区

  • 误区:DOTS 一定比 MonoBehaviour 快;正解:对大量小实体(粒子、群体 AI)快很多;少量复杂对象(如玩家角色)MonoBehaviour 更易维护。
  • 误区:DOTS 可以替代 MonoBehaviour;正解:DOTS 是补充,新项目可以纯 ECS,老项目逐步迁移。

追问

  • 什么是 Burst Compiler?答:把 C# Job 代码编译成优化的本机码,自动向量化,性能接近 C++。
  • DOTS 在生产项目成熟吗?答:DOTS 仍在发展中,大型项目谨慎使用;小团队和独立项目可用,大型项目需评估风险。

13.2.3-006 协程和 async/await 的区别?

一句话结论

协程是 Unity 专属的迭代器模式,受 Unity 生命周期管理;async/await 是 C# 通用异步模式,可以跨 Unity 帧执行,不受 timeScale 影响。

概念解释

  • 协程:IEnumerator + yield return,Unity 调度,受 timeScale 和暂停影响。
  • async/await:C# Task 模式,通用异步,不受 Unity 生命周期和 timeScale 影响。
  • 跨帧:async/await 可以跨 Unity 帧执行(如等待网络请求)。
  • 取消:async/await 支持 CancellationToken,协程停止靠 StopCoroutine。

原理流程

  1. 协程:yield return new WaitForSeconds(1) 受 timeScale 影响,暂停游戏时暂停。
  2. async/await:await Task.Delay(1000) 不受 timeScale 影响,暂停游戏时继续。
  3. 协程:GameObject 销毁时自动停止。
  4. async/await:GameObject 销毁时不自动停止,要手动 CancellationToken。

代码或图示

// 协程(受 timeScale 影响)
IEnumerator Routine() {
    yield return new WaitForSeconds(1f);  // timeScale=0 时暂停
}

// async/await(不受 timeScale 影响)
async void Method() {
    await Task.Delay(1000);  // timeScale=0 时继续
}

常见误区

  • 误区:async/await 可以替代所有协程;正解:async/await 不受 Unity 生命周期管理,GameObject 销毁时协程自动停止,async 要手动取消。
  • 误区:Task.Delay 受 timeScale 影响;正解:Task.Delay 是 C# 通用 API,不受 Unity timeScale 影响。

追问

  • 怎么让 async/await 跟随 Unity 生命周期?答:用 CancellationToken,在 OnDestroy 里 Cancel,async 方法检查 token。
  • UniTask 是什么?答:第三方库,替代 Task,集成 Unity 生命周期,性能更好,推荐替代 async/await。

13.2.3-007 C# 事件内存泄漏怎么防止?

一句话结论

事件订阅者如果不取消订阅,发布者会持有订阅者引用,导致订阅者无法被 GC 回收;在 OnDisable/OnDestroy 中 -= 取消订阅。

概念解释

  • 事件泄漏:发布者 event 持有订阅者引用,订阅者即使不需要了也无法被 GC。
  • 取消订阅:event -= Handler 在对象销毁时调用。
  • 常见场景:UI 订阅游戏事件,UI 关闭但没取消订阅,UI 对象不回收。

原理流程

  1. 订阅:player.OnDeath += UI.OnPlayerDeath,player 持有 UI 引用。
  2. UI 关闭:player 仍持有 UI 引用,UI 无法 GC。
  3. 正确:OnDisable 里 player.OnDeath -= UI.OnPlayerDeath,取消订阅。

代码或图示

// 订阅
void OnEnable() {
    Player.OnDeath += HandleDeath;
}

// 取消订阅(必须!)
void OnDisable() {
    Player.OnDeath -= HandleDeath;
}

void HandleDeath() { ... }

常见误区

  • 误区:事件不会泄漏;正解:静态事件泄漏最严重,发布者是静态的,永远持有订阅者引用。
  • 误区:-= 一次就够;正解:要和 += 配对,每次 += 都要 -=;lambda 订阅更难取消(要存委托引用)。

追问

  • lambda 订阅怎么取消?答:Player.OnDeath += () => { ... } 无法 -=,因为每次 lambda 是新委托;要存为字段再 -=。
  • 弱引用事件是什么?答:用 WeakReference 包装订阅者,发布者不持有强引用,订阅者可被 GC;但实现复杂。

13.2.3-008 单例模式在 Unity 里怎么用?

一句话结论

单例提供全局访问点,但要防重复(Awake 检查)和防销毁(DontDestroyOnLoad);过度使用单例会导致紧耦合和测试困难。

概念解释

  • 单例:全局只有一个实例,Instance 静态属性访问。
  • 防重复:Awake 检查是否已有实例,有则销毁自己。
  • 跨场景:DontDestroyOnLoad 让单例场景切换保留。
  • 缺点:全局状态、紧耦合、难测试。

原理流程

  1. Awake:检查 Instance 是否 null,null 则赋值并 DontDestroyOnLoad。
  2. 不 null:Destroy(gameObject),避免重复。
  3. 全局访问:GameManager.Instance.xxx()。

代码或图示

public class GameManager : MonoBehaviour {
    public static GameManager Instance { get; private set; }
    void Awake() {
        if (Instance == null) {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        } else {
            Destroy(gameObject);
        }
    }
}

常见误区

  • 误区:单例总是好的;正解:单例全局访问但紧耦合,测试困难;小项目方便,大项目要控制。
  • 误区:单例一定 DontDestroyOnLoad;正解:只跨场景需要的才用;单场景管理器不需要。

追问

  • 单例和静态类的区别?答:单例是 MonoBehaviour,有生命周期和协程;静态类没有生命周期;单例可拖拽引用,静态类不能。
  • 怎么替代单例?答:依赖注入(DI)容器,对象注册到容器,需要时注入,可测试;但复杂度高。

13.2.3-009 C# 事件(event)和 UnityEvent 的区别?

一句话结论

C# event 是纯代码层面,轻量、编译时检查;UnityEvent 是序列化的,可在 Inspector 里拖拽绑定,但有反射开销。

概念解释

  • C# event:标准 .NET 事件,编译时检查,轻量。
  • UnityEvent:Unity 提供,可序列化,Inspector 绑定。
  • C# event 轻量,UnityEvent 有反射开销。

原理流程

  1. C# event:public event Action OnClick; 代码绑定。
  2. UnityEvent:public UnityEvent OnClick; Inspector 拖拽绑定。
  3. 运行时:C# event 直接调用,UnityEvent 反射调用。

代码或图示

// C# event
public event Action OnClick;
void Start() { OnClick += HandleClick; }

// UnityEvent
public UnityEvent OnClick;
// Inspector 里拖拽方法

常见误区

  • 误区:UnityEvent 性能好;正解:UnityEvent 有反射开销,高频事件用 C# event。
  • 误区:C# event 不能在 Inspector 绑定;正解:C# event 代码绑定,UnityEvent 可视化绑定。

追问

  • 什么是委托(delegate)?答:函数指针类型。
  • 什么是反射?答:运行时动态调用方法。

待整理清单

  • [ ] DOTS/ECS 在生产项目的成熟度
  • [ ] UniTask 替代 async/await 的最佳实践
  • [ ] DI 容器在 Unity 中的方案(VContainer、Zenject)