1
public class LifecycleDemo : MonoBehaviour
2
{
3
    // 1. Awake：初始化自己的状态
4
    void Awake()
5
    {
6
        // 此时不能依赖其他组件的 Start 已完成
7
        // 但可以依赖 Awake（Unity 保证所有 Awake 在 Start 前执行）
8
        _rigidbody = GetComponent<Rigidbody>();  // 安全
9
        _playerHealth = GetComponent<PlayerHealth>();  // 存在，但可能尚未 Start
10
    }
11

12
    // 2. OnEnable：对象变为 active、每次启用时调用
13
    void OnEnable()
14
    {
15
        // 注册事件、订阅消息
16
        EventBus.OnPlayerDied += HandlePlayerDied;
17
        // 可能被多次调用，注意防止重复注册！
18
    }
19

20
    // 3. Start：第一帧开始前
21
    void Start()
22
    {
23
        // 所有组件的 Awake 已完成，可以安全访问外部组件
24
        _playerHealth.Initialize(_maxHP);  // 安全
25
    }
26

27
    // 4. Update：每帧
28
    void Update()
29
    {
30
        // 帧间隔 = Time.deltaTime，不稳定
31
        transform.Translate(Vector3.forward * speed * Time.deltaTime);
32
    }
33

34
    // 5. FixedUpdate：物理步长
35
    void FixedUpdate()
36
    {
37
        // 间隔 = Time.fixedDeltaTime (默认 0.02s)，稳定
38
        _rigidbody.AddForce(Vector3.forward * force);
39
    }
40

41
    // 6. LateUpdate：Update 之后
42
    void LateUpdate()
43
    {
44
        // 常用于相机跟随 —— 确保在角色移动完成后再跟
45
        Camera.main.transform.position = target.position + offset;
46
    }
47

48
    // 7. OnDisable：禁用时
49
    void OnDisable()
50
    {
51
        // 取消订阅（与 OnEnable 成对）
52
        EventBus.OnPlayerDied -= HandlePlayerDied;
53
        // 停止所有协程
54
        StopAllCoroutines();
55
    }
56

57
    // 8. OnDestroy：销毁时
58
    void OnDestroy()
59
    {
60
        // 释放非托管资源，最后一次清理
61
        // 注意：此时对象已从引擎侧标记为销毁
62
    }
63
}

1
public class SerializationDemo : MonoBehaviour
2
{
3
    // ✓ 会被序列化（显示在 Inspector 中）
4
    public int publicField;                        // public 字段
5
    [SerializeField] private int privateField;     // 标记 SerializeField 的私有字段
6

7
    // ✗ 不会被序列化
8
    private int _hiddenField;                      // 私有字段，未标记
9
    public static int StaticField;                 // static 字段永远不序列化
10
    public const int ConstField = 5;               // const
11
    public int Prop { get; set; }                  // 属性（除非标记 [field: SerializeField]）
12
    public readonly int ReadonlyField;              // readonly
13

14
    // ✓ 可序列化的类型
15
    public int integer;                            // 基本类型
16
    public string text;                            // string
17
    public Vector3 position;                       // Unity 结构体
18
    public Color color;                            // Unity 结构体
19
    public AnimationCurve curve;                   // Unity 对象
20
    public GameObject prefab;                      // UnityEngine.Object 引用
21
    public int[] array;                            // 数组（可序列化元素类型）
22
    public List<int> list;                         // List<T>
23

24
    // △ 需要 [SerializeReference] 的多态字段
25
    [SerializeReference] public IWeapon weapon;    // 接口/抽象类引用
26
    [SerializeReference] public WeaponBase baseWeapon; // 继承体系中的引用
27
}

1
[System.Serializable]
2
public class Sword : IWeapon { public int damage; }
3
[System.Serializable]
4
public class Bow : IWeapon { public float range; }
5

6
public class WeaponHolder : MonoBehaviour
7
{
8
    // [SerializeField]：值拷贝，不支持多态
9
    // 在 Inspector 中：直接编辑 Sword 的字段
10
    [SerializeField] private Sword _sword;
11

12
    // [SerializeReference]：引用类型，支持多态（C#，Unity 2019.3+）
13
    // 在 Inspector 中：可以选择托管具体类型（Sword 或 Bow）
14
    [SerializeReference] private IWeapon _weapon;
15
    [SerializeReference] private List<IWeapon> _weapons;  // 多态列表
16
}

1
// 可序列化的"纯数据"类 —— 不需要继承 MonoBehaviour
2
[System.Serializable]
3
public class CharacterData
4
{
5
    public string name;
6
    public int level;
7
    public List<SkillData> skills;
8
}
9

10
[System.Serializable]
11
public class SkillData
12
{
13
    public string skillName;
14
    public float cooldown;
15
    public AnimationCurve damageCurve;  // Unity 对象也可以序列化
16
}
17

18
// 在 MonoBehaviour 中使用
19
public class CharacterSheet : MonoBehaviour
20
{
21
    [SerializeField] private CharacterData[] _characters;  // 显示在 Inspector 中
22
}

1
// Coroutine 的本质：Unity 在每帧 Update 之后检查 IEnumerator 是否完成
2
IEnumerator MyCoroutine()
3
{
4
    Debug.Log($"Frame {Time.frameCount}: 第一步");  // Frame 10
5
    yield return new WaitForSeconds(2f);              // 暂停 2 秒
6
    Debug.Log($"Frame {Time.frameCount}: 第二步");  // Frame ~130（2 秒后）
7
    yield return null;                                // 暂停一帧
8
    Debug.Log($"Frame {Time.frameCount}: 第三步");  // Frame 131
9
}
10

11
// Unity 引擎在每帧的 Update 之后，遍历所有活跃的 Coroutine：
12
// 伪代码（C++ engine 侧）：
13
void PlayerLoop()
14
{
15
    while (true)
16
    {
17
        // 1. 调用所有 Update
18
        for (auto& comp : activeComponents)
19
            comp.CallManagedUpdate();
20

21
        // 2. 推进所有 Coroutine
22
        for (auto it = coroutines.begin(); it != coroutines.end(); )
23
        {
24
            if (!it->MoveNext())   // IEnumerator.MoveNext()
25
                it = coroutines.erase(it);  // 协程结束
26
            else
27
                ++it;
28
        }
29

30
        // 3. 调用所有 LateUpdate
31
        // 4. 渲染
32
    }
33
}

1
// 每个 yield 指令都是 Unity 自定义的 YieldInstruction 子类
2
public class CoroutineHost : MonoBehaviour
3
{
4
    IEnumerator LoadGameSequence()
5
    {
6
        // yield return null → 下一帧继续
7
        // 内部：标记为"等待一帧"，下次 Update 后推进
8
        yield return null;
9

10
        // yield return new WaitForSeconds(5f) → 5 秒后继续
11
        // 内部：记录时间戳，每帧检查 Time.time >= targetTime
12
        yield return new WaitForSeconds(5f);
13

14
        // yield return new WaitForEndOfFrame() → 渲染帧结束后继续
15
        // 内部：在渲染管线末尾、下一帧 Update 之前推进
16
        yield return new WaitForEndOfFrame();
17

18
        // yield return new WaitForFixedUpdate() → 下一次 FixedUpdate 后继续
19
        // 内部：在 FixedUpdate 循环后推进
20
        yield return new WaitForFixedUpdate();
21

22
        // yield return new WaitUntil(() => Input.GetKeyDown(KeyCode.Space))
23
        // 内部：每帧 Update 后检查条件
24
        yield return new WaitUntil(() => _isLoaded);
25

26
        // yield return new WaitWhile(() => _isLoading)
27
        // 内部：每帧检查条件为 false
28
        yield return new WaitWhile(() => _isLoading);
29

30
        // yield return anotherCoroutine → 等待另一个 Coroutine 完成
31
        // 内部：嵌套 IEnumerator，引擎先推进子协程
32
        yield return StartCoroutine(SubTask());
33

34
        // yield return asyncOperation → 等待异步操作完成
35
        yield return SceneManager.LoadSceneAsync("Game");
36

37
        // yield break → 立即终止（等价于 return）
38
        if (_cancelled)
39
            yield break;
40
    }
41
}

1
// Unity 默认不保证不同脚本的 Awake/Start/Update 调用顺序
2
// 三种方式控制：
3

4
// 方式 1：Script Execution Order 设置（Project Settings）
5
// 指定脚本的优先级数值（越小越先执行）
6

7
// 方式 2：[DefaultExecutionOrder] 属性
8
[DefaultExecutionOrder(-100)]
9
public class InputManager : MonoBehaviour { }  // 最先执行
10

11
[DefaultExecutionOrder(100)]
12
public class CameraController : MonoBehaviour { }  // 最后执行
13

14
// 方式 3：手动依赖管理（最可靠）
15
public class DependentComponent : MonoBehaviour
16
{
17
    [SerializeField] private InputManager _inputManager;
18

19
    void Start()
20
    {
21
        // 不依赖执行顺序，直接引用
22
    }
23
}

1
public class NullTrap : MonoBehaviour
2
{
3
    void Update()
4
    {
5
        if (_target == null)  // Unity 重载了 ==
6
        {
7
            // _target 可能是：
8
            // 1. 真正的 null（C# 引用为空）
9
            // 2. Unity Object 已销毁但 CLR 对象还在
10
            // 两种情况都满足 == null！
11
            _target = FindNewTarget();
12
        }
13

14
        // 如果需要区分"真 null"和"已销毁"：
15
        // bool isReallyNull = ReferenceEquals(_target, null);  // 真 null
16
        // bool isDestroyed = _target == null && !ReferenceEquals(_target, null);
17
        // 但绝大多数情况下，你不需要区分——两者都不该使用
18
    }
19

20
    private Enemy _target;
21
}

1
// 禁用 GameObject → 所有 Coroutine 停止
2
// OnDisable 中 StopAllCoroutines() 被自动调用
3
// 但 async Task 不会停止！
4

5
IEnumerator MixedPattern()
6
{
7
    yield return LoadAsync();  // Coroutine 阶段
8
    // 如果此时 GameObject 被禁用，下面的代码不会执行
9
    ShowResult();
10
}
11

12
async void BadMixedPattern()
13
{
14
    await LoadAsync();  // Task 阶段
15
    // 即使 GameObject 被禁用了，这段仍然执行！
16
    // 可能导致 NullReferenceException（访问已销毁的组件）
17
    ShowResult();
18
}

1
void FixedUpdate()
2
{
3
    // ⚠️ Input.GetKeyDown 在 FixedUpdate 中可能丢失
4
    // GetKeyDown 只在按键的"当前帧"返回 true
5
    // 如果 FixedUpdate 在某一帧被调用 0 次或 2 次：
6
    //   - 0 次 → 漏掉按键
7
    //   - 2 次 → 可能检测不到（第二次调用时 Input 缓冲区已清空）
8
    if (Input.GetKeyDown(KeyCode.Space))
9
        Jump();
10
}
11

12
// ✓ 正确：在 Update 中检测 Input，在 FixedUpdate 中应用
13
void Update()
14
{
15
    if (Input.GetKeyDown(KeyCode.Space))
16
        _shouldJump = true;
17
}
18

19
void FixedUpdate()
20
{
21
    if (_shouldJump)
22
    {
23
        _rigidbody.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
24
        _shouldJump = false;
25
    }
26
}

1
public class AIController : MonoBehaviour
2
{
3
    [SerializeField] private AIState _initialState;
4
    private AIState _currentState;
5
    private Coroutine _stateRoutine;
6

7
    void OnEnable()
8
    {
9
        _currentState = _initialState;
10
        _stateRoutine = StartCoroutine(RunStateMachine());
11
    }
12

13
    void OnDisable()
14
    {
15
        // 停止状态机——OnDisable 自动停止所有 Coroutine
16
        _currentState?.OnExit();
17
    }
18

19
    IEnumerator RunStateMachine()
20
    {
21
        while (_currentState != null)
22
        {
23
            _currentState.OnEnter();
24

25
            while (_currentState.IsActive)
26
            {
27
                _currentState.OnUpdate();
28
                yield return null;  // 每帧一次
29
            }
30

31
            _currentState.OnExit();
32
            _currentState = _currentState.GetNextState();
33
        }
34
    }
35
}

1
// 利用 SerializeReference 在 Inspector 中构建技能树
2
[System.Serializable]
3
public abstract class SkillNode
4
{
5
    public string displayName;
6
    public abstract void Execute(CharacterController caster);
7
}
8

9
[System.Serializable]
10
public class DamageSkillNode : SkillNode
11
{
12
    public float baseDamage;
13
    public ElementType element;
14

15
    public override void Execute(CharacterController caster)
16
    {
17
        // 伤害计算逻辑
18
    }
19
}
20

21
[System.Serializable]
22
public class ConditionSkillNode : SkillNode
23
{
24
    public enum Condition { HPBelow, MPAbove, HasBuff }
25
    public Condition condition;
26
    public float threshold;
27

28
    [SerializeReference] public SkillNode onSuccess;
29
    [SerializeReference] public SkillNode onFail;
30

31
    public override void Execute(CharacterController caster)
32
    {
33
        if (Evaluate(caster))
34
            onSuccess?.Execute(caster);
35
        else
36
            onFail?.Execute(caster);
37
    }
38
}
39

40
// 在 MonoBehaviour 中使用
41
public class SkillConfig : MonoBehaviour
42
{
43
    [SerializeReference]
44
    private SkillNode _rootNode;  // Inspector 中可以自由组合 Damage/Condition/等
45
}

1
public class GameLoader : MonoBehaviour
2
{
3
    [SerializeField] private Slider _progressBar;
4

5
    IEnumerator Start()
6
    {
7
        _progressBar.value = 0f;
8

9
        // 加载配置
10
        yield return StartCoroutine(LoadConfig());
11
        _progressBar.value = 0.2f;
12

13
        // 加载玩家数据
14
        yield return StartCoroutine(LoadPlayerData());
15
        _progressBar.value = 0.5f;
16

17
        // 加载场景（异步操作可以直接 yield return）
18
        var sceneLoad = SceneManager.LoadSceneAsync("Game", LoadSceneMode.Additive);
19
        while (!sceneLoad.isDone)
20
        {
21
            _progressBar.value = 0.5f + sceneLoad.progress * 0.4f;
22
            yield return null;
23
        }
24

25
        // 预热
26
        yield return StartCoroutine(WarmupManagers());
27
        _progressBar.value = 1.0f;
28

29
        // 加载完成
30
        _progressBar.gameObject.SetActive(false);
31
    }
32

33
    IEnumerator LoadConfig()
34
    {
35
        // 模拟等待
36
        yield return new WaitForSeconds(0.5f);
37
    }
38

39
    IEnumerator LoadPlayerData()
40
    {
41
        yield return new WaitForSeconds(1.0f);
42
    }
43

44
    IEnumerator WarmupManagers()
45
    {
46
        yield return new WaitForSeconds(0.3f);
47
    }
48
}