C# on 水元素长弓

Unity知识梗概

Thu, 04 Jun 2026 15:34:53 +0800

一、MonoBehaviour 生命周期

1.1 生命周期执行顺序

Unity 中每个 MonoBehaviour 脚本从唤醒到销毁有固定的执行顺序：

1

Awake → OnEnable → Start → FixedUpdate → Update → LateUpdate → OnDisable → OnDestroy

详细执行流程：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


编辑器
 ↓
Reset（编辑器模式下点击 Reset 按钮时调用）
 ↓
Awake（对象加载时调用，仅一次）
 ↓
OnEnable（每次启用时调用，可多次）
 ↓
Start（第一次 Update 前调用，仅一次）
 ↓
物理引擎更新
 ├── FixedUpdate（固定时间间隔，0.02s 一次）
 └── 物理碰撞检测
 ↓
Update（每帧调用，频率与帧率相关）
 ↓
LateUpdate（所有 Update 完成后调用）
 ↓
渲染
 ↓
OnDisable（对象禁用时调用）
 ↓
OnDestroy（对象销毁时调用）

1.2 各方法详解

Awake：用于初始化自身状态，不依赖其他对象。在所有对象初始化完成后调用，可安全使用 GameObject.FindWithTag。不可用于协程。

Start：在 Awake 之后、第一次 Update 之前调用。适合做依赖其他对象的初始化（如获取其他组件引用）。

OnEnable：每次对象被激活时调用。与 OnDisable 成对出现，可在同一生命周期中反复发生。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


public class Player : MonoBehaviour
{
 private Rigidbody rb;
 private int score;

 void Awake()
 {
 // 初始化自身，不依赖其他对象
 rb = GetComponent<Rigidbody>();
 }

 void Start()
 {
 // 依赖其他对象的初始化
 score = GameManager.Instance.InitialScore;
 }

 void OnEnable()
 {
 // 每次激活时注册事件
 InputManager.OnJump += Jump;
 }

 void OnDisable()
 {
 // 每次禁用时取消注册
 InputManager.OnJump -= Jump;
 }
}

1.3 Update、FixedUpdate、LateUpdate 的区别

方法	执行频率	用途	特点
FixedUpdate	固定 0.02s（可配置）	物理相关（刚体力、碰撞）	时间间隔固定，不受帧率影响，一帧内可能调用多次
Update	每帧一次（约 0.0167s @60FPS）	非物理逻辑（输入检测、状态更新）	执行间隔不固定，受帧率波动影响
LateUpdate	Update 全部完成后	依赖其他对象更新后的逻辑（摄像机跟随）	确保所有对象的移动和状态已更新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


public class PlayerController : MonoBehaviour
{
 private Rigidbody rb;
 private float moveInput;

 void Start() => rb = GetComponent<Rigidbody>();

 void Update()
 {
 // Update：处理输入检测
 moveInput = Input.GetAxis("Horizontal");
 }

 void FixedUpdate()
 {
 // FixedUpdate：处理物理移动
 rb.AddForce(Vector3.right * moveInput * 10f);
 }
}

public class CameraFollow : MonoBehaviour
{
 public Transform target;

 void LateUpdate()
 {
 // LateUpdate：在所有移动完成后跟随
 transform.position = target.position + new Vector3(0, 5, -10);
 }
}

二、协程（Coroutine）

2.1 协程的本质

协程是 Unity 中分段执行代码逻辑的机制。它通过 yield return 将方法拆分为多个片段，在特定条件满足后恢复执行。

协程不是多线程：协程完全运行在主线程上，只是通过分帧执行模拟"并行"效果。

协程的底层原理：基于 C# 的迭代器特性。调用 StartCoroutine() 时，Unity 将协程包装为状态机，在每帧的 Update 之后检查 yield 条件是否满足，满足则通过 MoveNext() 推动协程执行到下一个 yield 或结束。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


public class CoroutineExample : MonoBehaviour
{
 void Start()
 {
 // 启动协程
 StartCoroutine(DelaySpawnEnemy());
 StartCoroutine(LoadSceneAsync());
 }

 // 延迟执行
 IEnumerator DelaySpawnEnemy()
 {
 yield return new WaitForSeconds(3); // 等待3秒
 Instantiate(enemyPrefab, spawnPoint.position, Quaternion.identity);
 }

 // 分帧加载资源
 IEnumerator LoadSceneAsync()
 {
 AsyncOperation asyncLoad = SceneManager.LoadSceneAsync("Level2");
 while (!asyncLoad.isDone)
 {
 float progress = asyncLoad.progress;
 UpdateLoadingUI(progress);
 yield return null; // 每帧更新进度
 }
 }

 // 序列动画
 IEnumerator FadeOut(SpriteRenderer renderer)
 {
 Color color = renderer.color;
 while (color.a > 0)
 {
 color.a -= Time.deltaTime * 0.5f;
 renderer.color = color;
 yield return null; // 每帧更新透明度
 }
 }
}

2.2 常用 yield 指令

指令	作用
`yield return null`	等待下一帧
`yield return new WaitForSeconds(n)`	等待 n 秒
`yield return new WaitForEndOfFrame()`	等待帧结束
`yield return new WaitForFixedUpdate()`	等待物理帧更新
`yield return new WaitUntil(() => 条件)`	等待条件为 true
`yield return new WaitWhile(() => 条件)`	等待条件为 false
`yield return StartCoroutine(Other())`	等待另一个协程完成

2.3 协程的注意事项

生命周期：协程依附于 MonoBehaviour，对象销毁时协程自动停止
性能：协程本身开销极低，但频繁 yield return new 会产生 GC 垃圾
优化：复用 WaitForSeconds 对象，避免每次创建

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// ❌ 每次创建新对象，产生 GC
IEnumerator Bad()
{
 yield return new WaitForSeconds(1f);
}

// ✅ 缓存复用，减少 GC
private WaitForSeconds wait = new WaitForSeconds(1f);

IEnumerator Good()
{
 yield return wait;
}

三、对象池（Object Pool）

3.1 为什么需要对象池

频繁 Instantiate 和 Destroy 会产生大量的 GC 压力和内存碎片。对象池通过复用对象来避免这个问题。典型场景：子弹、敌人、特效。

3.2 自定义对象池

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


public class ObjectPool : MonoBehaviour
{
 [SerializeField] private GameObject prefab;
 private Queue<GameObject> pool = new Queue<GameObject>();

 // 从池中获取对象
 public GameObject Get()
 {
 if (pool.Count > 0)
 {
 GameObject obj = pool.Dequeue();
 obj.SetActive(true);
 return obj;
 }
 // 池中没有可用对象，创建新对象
 return Instantiate(prefab);
 }

 // 将对象归还池中
 public void Return(GameObject obj)
 {
 obj.SetActive(false);
 pool.Enqueue(obj);
 }
}

3.3 使用 Unity 内置对象池（UnityEngine.Pool）

Unity 提供了 ObjectPool<T> 泛型类：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


using UnityEngine.Pool;

public class BulletPool : MonoBehaviour
{
 [SerializeField] private GameObject bulletPrefab;
 private ObjectPool<Bullet> pool;

 void Start()
 {
 pool = new ObjectPool<Bullet>(
 createFunc: () => Instantiate(bulletPrefab).GetComponent<Bullet>(),
 actionOnGet: (bullet) => bullet.gameObject.SetActive(true),
 actionOnRelease: (bullet) => bullet.gameObject.SetActive(false),
 actionOnDestroy: (bullet) => Destroy(bullet.gameObject),
 collectionCheck: true,
 defaultCapacity: 10,
 maxSize: 100
 );
 }

 public Bullet GetBullet() => pool.Get();

 public void ReturnBullet(Bullet bullet) => pool.Release(bullet);
}

核心方法：

Get()：从池中获取对象
Release(T)：将对象放回池中

注意事项：

在 actionOnGet 中重置对象状态（位置、速度等）
确保每个 Get() 都有对应的 Release()

四、动态加载资源的方式

4.1 三种加载方式对比

方式	说明	适用场景
Instantiate	直接实例化预制体	最简单，运行时动态生成
Resources.Load	从 Resources 文件夹加载	简单项目，但所有资源都会被打包
AssetBundle	将资源打成 AB 包	大型项目，支持热更新
Addressables	基于 AB 的高级管理系统	官方推荐，支持按需加载

4.2 Resources.Load

1
2
3
4
5
6
7
8


// 同步加载
GameObject prefab = Resources.Load<GameObject>("Prefabs/Player");
Instantiate(prefab);

// 异步加载（不阻塞主线程）
ResourceRequest request = Resources.LoadAsync<GameObject>("Prefabs/Player");
yield return request;
Instantiate(request.asset);

Resources 的缺点：

所有 Resources 文件夹中的资源都会被打入安装包
无法减小包体
已过时，推荐用 Addressables

4.3 Instantiate

1
2
3


// 最简单的动态加载
GameObject bullet = Instantiate(bulletPrefab);
GameObject enemy = Instantiate(enemyPrefab, spawnPosition, Quaternion.identity);

4.4 AssetBundle

1
2
3
4
5
6
7
8


// 从服务器下载 AB 包
using (UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(url))
{
 yield return request.SendWebRequest();
 AssetBundle bundle = DownloadHandlerAssetBundle.GetContent(request);
 GameObject prefab = bundle.LoadAsset<GameObject>("Player");
 Instantiate(prefab);
}

4.5 Addressables

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

// 异步加载资源
AsyncOperationHandle<GameObject> handle =
 Addressables.LoadAssetAsync<GameObject>("Player");
handle.Completed += (op) =>
{
 Instantiate(op.Result);
};

// 释放资源
Addressables.Release(handle);

Addressables 核心特性：

按地址加载，逻辑与物理路径解耦
自动管理依赖
支持本地和远程资源
引用计数自动卸载

五、UGUI 与适配

5.1 Canvas 的三种渲染模式

Screen Space - Overlay（默认）：UI 始终在 3D 元素前面，与摄像机无关。

Screen Space - Camera：UI 通过指定摄像机渲染，支持 3D 效果（如粒子在 UI 前）。

World Space：UI 成为场景中的 3D 物体，可用于怪物血条、VR 开发。

5.2 Canvas Scaler 缩放模式

模式	说明
Constant Pixel Size	UI 保持固定像素大小
Scale With Screen Size	根据参考分辨率动态缩放（推荐）
Constant Physical Size	根据物理尺寸（英寸）缩放

5.3 UI 自适应方案

锚点（Anchors）：定义 UI 元素相对于父容器的定位方式。

锚点预设	效果
居中	元素始终居中
拉伸	元素随父容器拉伸

Rect Transform：UI 元素的变换组件，包含锚点、轴心、偏移量等属性。

布局组件：

Horizontal/Vertical Layout Group：自动排列子元素
Content Size Fitter：根据内容动态调整大小
Aspect Ratio Fitter：保持宽高比

5.4 Image 和 RawImage 的区别

	Image	RawImage
支持类型	Sprite（精灵）	Texture（原始纹理）
九宫格缩放	支持	不支持
填充模式	支持（进度条）	不支持
UV 调整	不支持	支持
动态纹理	不支持	支持（摄像头、RenderTexture）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// RawImage 适用于动态纹理
public class ModelInUI : MonoBehaviour
{
 public Camera modelCamera;
 public RawImage modelDisplay;

 void Start()
 {
 RenderTexture rt = new RenderTexture(512, 512, 24);
 modelCamera.targetTexture = rt;
 modelDisplay.texture = rt;
 }
}

5.5 摇杆实现（不依赖插件）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


public class JoystickController : MonoBehaviour, IDragHandler, IPointerDownHandler, IPointerUpHandler
{
 [SerializeField] private RectTransform joystickBG;
 [SerializeField] private RectTransform joystickHandle;
 private Vector2 inputDirection;

 public Vector2 InputDirection => inputDirection;

 public void OnDrag(PointerEventData eventData)
 {
 Vector2 pos;
 RectTransformUtility.ScreenPointToLocalPointInRectangle(
 joystickBG, eventData.position, eventData.pressEventCamera, out pos
 );
 pos = pos / joystickBG.sizeDelta; // 归一化
 inputDirection = pos.magnitude > 1 ? pos.normalized : pos;
 joystickHandle.anchoredPosition = inputDirection * joystickBG.sizeDelta;
 }

 public void OnPointerUp(PointerEventData eventData)
 {
 inputDirection = Vector2.zero;
 joystickHandle.anchoredPosition = Vector2.zero;
 }
}

// 摇杆控制角色移动
public class PlayerController : MonoBehaviour
{
 public JoystickController joystick;
 public float moveSpeed = 5f;

 void Update()
 {
 Vector2 input = joystick.InputDirection;
 Vector3 movement = new Vector3(input.x, 0, input.y) * moveSpeed * Time.deltaTime;
 transform.Translate(movement);
 }
}

六、鼠标交互与事件系统

6.1 射线检测（Raycast）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


public class ClickInteraction : MonoBehaviour
{
 private Camera mainCamera;

 void Start() => mainCamera = Camera.main;

 void Update()
 {
 if (Input.GetMouseButtonDown(0))
 {
 Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
 RaycastHit hit;

 // 3D 物体检测
 if (Physics.Raycast(ray, out hit))
 {
 Debug.Log("点击了: " + hit.collider.gameObject.name);
 }

 // 2D 物体检测
 RaycastHit2D hit2D = Physics2D.Raycast(ray.origin, ray.direction);
 if (hit2D.collider != null)
 {
 Debug.Log("点击了 2D 物体: " + hit2D.collider.name);
 }
 }
 }
}

6.2 OnMouseDown 方法

1
2
3
4
5
6
7


public class SimpleClick : MonoBehaviour
{
 private void OnMouseDown()
 {
 Debug.Log("点击了: " + gameObject.name);
 }
}

6.3 事件系统（Event System）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


using UnityEngine.EventSystems;

// UI 物体点击
public class UIClickHandler : MonoBehaviour, IPointerClickHandler
{
 public void OnPointerClick(PointerEventData eventData)
 {
 Debug.Log("点击了 UI: " + gameObject.name);
 }
}

// 3D 物体点击（需添加 Physics Raycaster 到摄像机）
public class ObjectClickHandler : MonoBehaviour
{
 void Start()
 {
 EventTrigger trigger = gameObject.AddComponent<EventTrigger>();
 EventTrigger.Entry entry = new EventTrigger.Entry();
 entry.eventID = EventTriggerType.PointerClick;
 entry.callback.AddListener((data) => OnClick());
 trigger.triggers.Add(entry);
 }

 void OnClick()
 {
 Debug.Log("点击了物体: " + gameObject.name);
 }
}

七、委托与事件

7.1 委托（Delegate）

委托是方法的类型安全容器，支持多播（+= 注册多个方法）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 定义委托
public delegate void DeathHandler(string message);

public class Player
{
 public DeathHandler OnDeath;

 public void Die()
 {
 OnDeath?.Invoke("玩家死亡！");
 }
}

// 订阅
player.OnDeath += (msg) => Debug.Log(msg);

7.2 事件（Event）

事件是委托的封装，通过 event 关键字限制外部只能 += / -=，不能直接触发。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 定义事件
public class Enemy
{
 public event Action OnEnemyDeath; // 使用 Action 简化

 public void Die()
 {
 OnEnemyDeath?.Invoke(); // 只能在类内部触发
 }
}

// 订阅
enemy.OnEnemyDeath += HandleEnemyDeath;
// enemy.OnEnemyDeath?.Invoke(); // 编译错误！外部不能触发

委托 vs 事件的核心区别：

	委托	事件
外部触发	可以	不可以
外部赋值 (=)	可以（会覆盖其他订阅）	不可以
使用场景	回调、方法参数	发布-订阅模式

八、Unity GC 与优化

8.1 GC 工作机制

Unity 的 GC 采用分代回收策略：

代	特点
Gen 0	新分配的小对象，回收最频繁
Gen 1	Gen 0 幸存对象，回收次之
Gen 2	长期存活对象（如单例），极少回收

GC 触发条件：Gen 0 空间不足时自动触发，或手动调用 System.GC.Collect()（不推荐）。

GC 执行时主线程暂停，导致帧率骤降。

8.2 常见 GC 陷阱

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void Update()
{
 // ❌ 每帧产生新对象 → 频繁 GC
 Debug.Log("Position: " + transform.position); // 字符串拼接

 // ❌ 装箱
 object boxed = 123;

 // ❌ 每帧 GetComponent
 GetComponent<Rigidbody>().AddForce(Vector3.up);
}

8.3 GC 优化策略

（1）减少堆内存分配：

使用对象池管理高频创建的对象
避免装箱：用泛型集合替代非泛型
缓存组件引用

1
2
3
4


// ✅ 缓存组件引用
private Rigidbody rb;
void Start() => rb = GetComponent<Rigidbody>();
void Update() => rb.AddForce(Vector3.up);

（2）控制字符串操作：

1
2
3
4


// ✅ 使用 StringBuilder
StringBuilder sb = new StringBuilder(256);
sb.Append("HP: ").Append(currentHp);
string result = sb.ToString();

（3）使用非分配 API：

1
2
3
4
5


// ❌ 分配内存
Collider[] colliders = Physics.OverlapSphere(center, radius);

// ✅ 无分配
int count = Physics.OverlapSphereNonAlloc(center, radius, colliderBuffer);

（4）使用结构体代替类：

1
2
3
4
5


public struct BulletData // 值类型，不参与 GC
{
 public Vector3 Position;
 public float Speed;
}

8.4 背包系统设计概要

数据结构：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 静态数据（ScriptableObject 存储物品属性）
public abstract class ItemBase : ScriptableObject
{
 public int ItemID;
 public string ItemName;
 public Sprite Icon;
 public int MaxStack = 1;
 public ItemType Type; // Weapon, Consumable, Material...
}

// 动态数据（物品实例）
[System.Serializable]
public class ItemInstance
{
 public int ItemID;
 public int Count;
 public float Durability;
}

优化方向：

数据分离：静态属性与动态数据解耦
对象池：复用 UI 格子
虚拟列表：仅渲染可视区域内的物品
异步加载：图标按需加载

九、协程与异步

9.1 协程 vs async/await vs Awaitable

方式	GC 开销	适用场景
Coroutine	有	简单延迟、分帧操作
async/await	有（Task 分配）	网络请求、复杂异步
Awaitable（Unity 2022+）	无	性能敏感场景

9.2 async/await 在 Unity 中的使用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


using System.Threading.Tasks;

public class AsyncExample : MonoBehaviour
{
 async void Start()
 {
 string data = await LoadDataAsync();
 Debug.Log(data);
 }

 async Task<string> LoadDataAsync()
 {
 using var request = UnityWebRequest.Get("https://api.example.com");
 await request.SendWebRequest();
 return request.downloadHandler.text;
 }
}

async/await 的核心价值：

替代回调/协程，避免"回调地狱"
主线程友好：await 后自动回到主线程
无需手动检查状态

9.3 Unity 中的多线程

Unity 主线程独占 Unity API，子线程中不能调用 GameObject.Instantiate、Transform.position 等操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


using System.Threading;
using System.Threading.Tasks;

public class ThreadExample : MonoBehaviour
{
 void Start()
 {
 // 子线程执行耗时操作
 Thread thread = new Thread(() =>
 {
 int result = HeavyCalculation();
 // 子线程中不能调用 Unity API
 });
 thread.Start();
 }

 // Task 异步
 async void LoadData()
 {
 string data = await Task.Run(() =>
 {
 return System.IO.File.ReadAllText("data.txt");
 });
 // 回到主线程更新 UI
 Debug.Log(data);
 }
}

Unity 自动使用的多线程：

Job System：多线程并行计算
Burst Compiler：将代码编译为高度优化的机器码
物理引擎：默认在子线程处理碰撞检测
资源加载：Addressables 异步加载

十、Shader 基础

10.1 Shader 的概念

Shader 是一种运行在 GPU 上的程序，用来描述物体表面的外观，控制光照与渲染效果。GPU 并行处理大量顶点和像素，Shader 就是告诉 GPU"怎么画"的指令集。

Unity 渲染管线流程：

1

顶点数据 → 顶点着色器(Vertex) → 几何着色器 → 光栅化 → 片段着色器(Fragment) → 输出合并

Unity 中的 Shader 类型：

Surface Shader：Unity 特有的简化写法，自动处理光照计算。开发者只需定义属性（颜色、纹理等），Unity 自动生成完整的 Vertex/Fragment 代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// Surface Shader 示例
Shader "Custom/SimpleSurface"
{
 Properties
 {
 _MainTex ("Texture", 2D) = "white" {}
 _Glossiness ("Smoothness", Range(0,1)) = 0.5
 _Metallic ("Metallic", Range(0,1)) = 0.0
 }
 SubShader
 {
 Tags { "RenderType"="Opaque" }
 CGPROGRAM
 #pragma surface surf Standard fullforwardshadows
 // ... 表面函数
 ENDCG
 }
}

Vertex/Fragment Shader：提供精细控制，开发者自定义顶点和片段处理，适合复杂视觉效果（如溶解、扭曲、热浪）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


// 最简单的 Vertex/Fragment Shader
Shader "Custom/UnlitColor"
{
 Properties
 {
 _Color ("Color", Color) = (1,1,1,1)
 }
 SubShader
 {
 Pass
 {
 CGPROGRAM
 #pragma vertex vert
 #pragma fragment frag

 fixed4 _Color;

 struct appdata
 {
 float4 vertex : POSITION;
 };

 struct v2f
 {
 float4 position : SV_POSITION;
 };

 v2f vert(appdata v)
 {
 v2f o;
 o.position = UnityObjectToClipPos(v.vertex);
 return o;
 }

 fixed4 frag(v2f i) : SV_Target
 {
 return _Color;
 }
 ENDCG
 }
 }
}

10.2 四元数与旋转

四元数是 Unity 中表示旋转的数学工具，使用四个分量（x, y, z, w）表示三维空间中的旋转。

为什么不用欧拉角：

万向锁：当某个轴旋转 90 度时，另外两个轴失去自由度，导致旋转异常
插值不平滑：欧拉角插值会产生不自然的旋转路径

四元数的优点：

可进行增量旋转（旋转叠加）
避免万向锁
插值平滑（Slerp 球形插值）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 四元数常见操作
// 欧拉角 → 四元数
transform.rotation = Quaternion.Euler(0, 45, 0);

// 看向目标
transform.rotation = Quaternion.LookRotation(target.position - transform.position);

// 平滑旋转插值（Slerp = Spherical Linear Interpolation）
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, Time.deltaTime * 5f);

// 绕轴旋转
transform.rotation *= Quaternion.AngleAxis(90, Vector3.up);

// 获取当前旋转的欧拉角
Vector3 angles = transform.rotation.eulerAngles;

// 从旋转中提取方向向量
Vector3 forward = transform.rotation * Vector3.forward;

十一、寻路系统（NavMesh）

11.1 烘焙导航网格

NavMesh（Navigation Mesh）是 Unity 的自动寻路系统，通过将可行走区域烘焙为网格，让 AI 角色自动规划路径。

操作步骤：

标记场景中所有静态障碍物为 Navigation Static
打开 Window/AI/Navigation 面板
调整参数：
- Agent Radius：角色半径（决定能通过的最小通道）
- Agent Height：角色高度
- Max Slope：最大可爬坡度数
- Step Height：最大可跨越台阶高度
点击 Bake 生成 NavMesh

11.2 NavMeshAgent 组件

NavMeshAgent 是控制角色寻路的组件，提供路径计算、移动、避障等功能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


public class AIController : MonoBehaviour
{
 private NavMeshAgent agent;
 public Transform target;

 void Start()
 {
 agent = GetComponent<NavMeshAgent>();

 // 配置参数
 agent.speed = 5f; // 移动速度
 agent.angularSpeed = 120f; // 旋转速度
 agent.acceleration = 8f; // 加速度
 agent.stoppingDistance = 1.5f; // 停止距离（攻击范围）

 agent.SetDestination(target.position);
 }

 void Update()
 {
 // 状态检测
 if (!agent.pathPending && agent.remainingDistance <= agent.stoppingDistance)
 {
 // 到达目标，执行攻击逻辑
 Attack();
 }

 // 动态更新目标
 if (target.hasChanged)
 {
 agent.SetDestination(target.position);
 }
 }

 // 暂停/恢复寻路
 public void Pause() => agent.isStopped = true;
 public void Resume() => agent.isStopped = false;

 // 判断是否到达
 public bool HasReached => !agent.pathPending && agent.remainingDistance < 0.1f;
}

11.3 NavMeshAgent 参数详解

参数	作用
`speed`	最大移动速度
`angularSpeed`	旋转速度（度/秒）
`acceleration`	最大加速度
`stoppingDistance`	距离目标多远停止
`autoBraking`	到达时是否自动减速
`radius`	角色半径（用于避障）
`height`	角色高度
`obstacleAvoidanceType`	避障等级（NoObstacleAvoidance ~ All)

11.4 动态障碍物

场景中可移动的障碍物（如门、箱子）使用 NavMeshObstacle 组件：

静态障碍物：在烘焙时被纳入 NavMesh
动态障碍物：运行时通过 NavMeshObstacle 实时阻挡
- Carve：启用后动态切割 NavMesh，物体移走后恢复

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class DynamicDoor : MonoBehaviour
{
 private NavMeshObstacle obstacle;

 void Start()
 {
 obstacle = GetComponent<NavMeshObstacle>();
 obstacle.carving = true; // 启用动态切割
 }

 public void Open()
 {
 obstacle.carving = false; // 门打开，通行
 // 播放开门动画
 }

 public void Close()
 {
 obstacle.carving = true; // 门关闭，阻挡
 // 播放关门动画
 }
}

11.5 多层 NavMesh（跳跃/下落）

对于不同高度的平台，Unity 支持多层 NavMesh：

在 Navigation 面板添加 Layer（如"Ground"、“Roof”）
为不同高度的物体分配不同 Layer
AI 角色设置 agent.areaMask 控制可走区域

1
2


// 控制 AI 可走的区域（位掩码）
agent.areaMask = (1 << NavMesh.GetAreaFromName("Ground")); // 只能走地面

十二、相机系统

12.1 相机参数详解

Clear Flags：决定屏幕中未渲染区域的处理方式

Skybox：用天空盒填充（3D 场景默认）
Solid Color：用纯色填充（2D 游戏，适合像素风）
Depth Only：仅清除深度缓冲（用于多相机叠加，如主相机 + 武器相机）
Don’t Clear：不清除任何内容（需谨慎使用，会产生拖影效果）

Projection：投影模式

Perspective：透视投影，近大远小，适合 3D 游戏
- Field of View（FOV）：视野角度，默认 60°，FPS 游戏通常用 90°
Orthographic：正交投影，无视距离，适合 2D 游戏、UI 相机
- Size：视野高度的一半（单位：unity 单位）

Clipping Planes：

Near：近剪裁面，过小会导致物体被"挖穿"（z-fighting）
Far：远剪裁面，过大影响性能（深度精度下降）

进阶参数：

Viewport Rect：定义相机渲染的屏幕区域（分屏合作游戏）
- X=0, Y=0, W=0.5, H=1 → 左半屏（玩家1）
- X=0.5, Y=0, W=0.5, H=1 → 右半屏（玩家2）
Culling Mask：每层 32 位掩码，选择渲染哪些 Layer 的物体
Target Texture：将相机画面渲染到 Render Texture（小地图、监控摄像头）

12.2 多相机叠加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class WeaponCamera : MonoBehaviour
{
 private Camera weaponCam;

 void Start()
 {
 weaponCam = GetComponent<Camera>();
 // 武器相机：只渲染武器层，不清理背景
 weaponCam.clearFlags = CameraClearFlags.DepthOnly;
 weaponCam.cullingMask = 1 << LayerMask.NameToLayer("Weapon");
 }
}

12.3 相机常见实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


// 第三人称跟随
public class ThirdPersonCamera : MonoBehaviour
{
 public Transform target;
 public float distance = 10f;
 public float height = 5f;
 public float smoothSpeed = 5f;

 void LateUpdate()
 {
 Vector3 targetPos = target.position + Vector3.up * height - target.forward * distance;
 transform.position = Vector3.Lerp(transform.position, targetPos, smoothSpeed * Time.deltaTime);
 transform.LookAt(target.position + Vector3.up * 2f);
 }
}

// 第一人称相机
public class FirstPersonCamera : MonoBehaviour
{
 public Transform playerBody;
 public float mouseSensitivity = 100f;
 private float xRotation = 0f;

 void Start()
 {
 Cursor.lockState = CursorLockMode.Locked;
 }

 void Update()
 {
 float mouseX = Input.GetAxis("Mouse X") * mouseSensitivity * Time.deltaTime;
 float mouseY = Input.GetAxis("Mouse Y") * mouseSensitivity * Time.deltaTime;

 xRotation -= mouseY;
 xRotation = Mathf.Clamp(xRotation, -90f, 90f);

 transform.localRotation = Quaternion.Euler(xRotation, 0, 0);
 playerBody.Rotate(Vector3.up * mouseX);
 }
}

十三、Unity 常用架构

13.1 传统 MonoBehaviour 架构（面向对象）

每个脚本继承 MonoBehaviour，通过组件挂载到 GameObject 上，对象独立处理逻辑。

优点：直观易用，适合中小规模项目。

缺点：

性能瓶颈：大量 GameObject 的 Update 逐个执行，导致主线程卡顿
内存碎片化：频繁创建/销毁引发 GC
耦合度高：对象间引用关系复杂时难以维护

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class Player : MonoBehaviour
{
 public float speed = 5f;

 void Update()
 {
 float h = Input.GetAxis("Horizontal");
 transform.Translate(h * speed * Time.deltaTime, 0, 0);
 }
}

13.2 MVC 架构

将数据（Model）、显示（View）、逻辑（Controller） 分离，降低耦合度。

适用场景：UI 系统、网络同步、需要严格分层的项目。

1
2
3
4
5


用户输入 → Controller（逻辑控制）
 ↓
 Model（数据存储）→ 数据变更通知
 ↓
 View（界面更新）→ 反馈用户

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


// Model：纯数据，无 MonoBehaviour
[System.Serializable]
public class PlayerModel
{
 public int Health = 100;
 public Vector3 Position = Vector3.zero;
}

// View：只负责显示，不存数据
public class PlayerView : MonoBehaviour
{
 public void UpdatePosition(Vector3 pos) => transform.position = pos;
 public void UpdateHealthBar(int health) { /* UI 更新 */ }
}

// Controller：协调 Model 和 View
public class PlayerController : MonoBehaviour
{
 [SerializeField] private PlayerView view;
 private PlayerModel model = new PlayerModel();

 public void TakeDamage(int damage)
 {
 model.Health -= damage;
 view.UpdateHealthBar(model.Health);
 }

 public void Move(Vector3 delta)
 {
 model.Position += delta;
 view.UpdatePosition(model.Position);
 }
}

13.3 事件驱动架构

通过事件解耦模块间的通信，适合成就系统、音效触发等需要低耦合的场景。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


// 定义事件参数类（携带数据）
public class EnemyDiedEventArgs
{
 public Vector3 Position;
 public EnemyType Type;
 public int ScoreValue;
}

// 发布者
public class Enemy : MonoBehaviour
{
 // 使用 C# Action 事件
 public static event System.Action<EnemyDiedEventArgs> OnAnyEnemyDied;

 void Die()
 {
 OnAnyEnemyDied?.Invoke(new EnemyDiedEventArgs
 {
 Position = transform.position,
 Type = enemyType,
 ScoreValue = score
 });
 Destroy(gameObject);
 }
}

// 订阅者 1：成就系统
public class AchievementSystem : MonoBehaviour
{
 private int killCount;

 void OnEnable() => Enemy.OnAnyEnemyDied += OnEnemyKilled;
 void OnDisable() => Enemy.OnAnyEnemyDied -= OnEnemyKilled;

 void OnEnemyKilled(EnemyDiedEventArgs args)
 {
 killCount++;
 if (killCount >= 100)
 UnlockAchievement("百人斩");
 }
}

// 订阅者 2：音效系统
public class AudioManager : MonoBehaviour
{
 void OnEnable() => Enemy.OnAnyEnemyDied += (args) => PlayDeathSound();
 void OnDisable() => Enemy.OnAnyEnemyDied -= (args) => PlayDeathSound();
}

// 订阅者 3：UI 系统
public class ScoreUI : MonoBehaviour
{
 void OnEnable() => Enemy.OnAnyEnemyDied += (args) =>
 UpdateScore(args.ScoreValue);
}

13.4 ECS 架构（Entity-Component-System）

ECS 是数据导向的架构，将面向对象的"对象 = 数据 + 行为"拆分为纯数据和纯逻辑。

为什么需要 ECS：

传统 OOP 中，10000 个敌人各自执行 Update，CPU 缓存命中率低
ECS 将同类数据连续存储，CPU 遍历时按顺序读取，性能提升数倍

核心概念：

概念	说明	类比 OOP
Entity（实体）	唯一 ID，无数据无方法	GameObject
Component（组件）	纯数据结构	类的字段
System（系统）	处理特定组件组合的逻辑	类的方法

Archetype 与 Chunk：

Archetype：具有相同组件组合的 Entity 归为一类（如 Position+Velocity）
Chunk：每个 Archetype 的数据存储在连续的内存块中（每个 Chunk 16KB）

1
2
3
4
5
6
7


Archetype (Position + Velocity)
┌─────────────────────────────────┐
│ Chunk 1 │
│ [P1][V1] [P2][V2] [P3][V3] ... │ ← 连续内存，CPU 缓存友好
│ Chunk 2 │
│ [P11][V11][P12][V12] ... │
└─────────────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


using Unity.Entities;
using Unity.Burst;
using Unity.Jobs;
using Unity.Mathematics;

// Component：纯数据结构
public struct Position : IComponentData
{
 public float3 Value;
}

public struct Velocity : IComponentData
{
 public float3 Value;
}

// System：每帧处理所有具有 Position + Velocity 的 Entity
[BurstCompile]
public partial struct MovementSystem : ISystem
{
 [BurstCompile]
 public void OnUpdate(ref SystemState state)
 {
 // 查询所有拥有 Position 和 Velocity 的 Entity
 foreach (var (position, velocity) in
 SystemAPI.Query<RefRW<Position>, RefRO<Velocity>>())
 {
 // 更新位置：position += velocity * deltaTime
 position.ValueRW.Value += velocity.ValueRO.Value * SystemAPI.Time.DeltaTime;
 }
 }
}

// 创建 Entity 并添加组件
public class GameManager : MonoBehaviour
{
 void Start()
 {
 var world = World.DefaultGameObjectInjectionWorld;
 var entityManager = world.EntityManager;

 // 批量创建 10000 个移动实体
 for (int i = 0; i < 10000; i++)
 {
 Entity entity = entityManager.CreateEntity();
 entityManager.AddComponentData(entity, new Position { Value = float3.zero });
 entityManager.AddComponentData(entity, new Velocity { Value = new float3(1, 0, 0) });
 }
 }
}

ECS 性能优势：

特性	原理	效果
连续内存	同类型组件连续存储	CPU 缓存命中率提高 10x
多线程 Job System	自动将 System 逻辑分发到多核	充分利用多核 CPU
Burst Compiler	C# 编译为高度优化的原生代码	性能提升 5-10 倍

对比：100000 个移动物体

架构	CPU 耗时	GC 分配
MonoBehaviour	35ms	高频
ECS + Jobs + Burst	2ms	几乎为零

十四、Unity 移动射击动画融合

14.1 动画层（Animation Layers）

实现"边跑边射击"的核心技术是动画分层。将身体分为上下两层，分别播放不同动画。

实现步骤：

在 Animator Controller 中创建两个 Layer：
- Base Layer：处理移动动画（走、跑、跳跃）
- Upper Body Layer：处理上身动画（射击、换弹、投掷）
为 Upper Body Layer 设置 Avatar Mask：
- 创建 Avatar Mask 资产
- 仅勾选上半身骨骼（Spine、Chest、Left/Right Arm、Head）
- 下半身骨骼交由 Base Layer 控制
代码控制 Layer 权重：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


public class PlayerAnimator : MonoBehaviour
{
 private Animator animator;

 // 动画层索引
 private readonly int baseLayer = 0;
 private readonly int upperLayer = 1;

 void Start() => animator = GetComponent<Animator>();

 void Update()
 {
 // Base Layer：根据速度切换走/跑
 float speed = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical")).magnitude;
 animator.SetFloat("Speed", speed);

 // Upper Body Layer：射击时启用
 if (Input.GetButtonDown("Fire1"))
 {
 // 将 Upper Body 权重设为 1（完全覆盖上半身）
 animator.SetLayerWeight(upperLayer, 1f);
 animator.Play("Shoot", upperLayer, 0f);
 }

 // 射击结束后逐渐恢复权重为 0
 if (Input.GetButtonUp("Fire1"))
 {
 StartCoroutine(FadeOutLayer(upperLayer, 0.2f));
 }
 }

 IEnumerator FadeOutLayer(int layer, float duration)
 {
 float elapsed = 0;
 while (elapsed < duration)
 {
 elapsed += Time.deltaTime;
 animator.SetLayerWeight(layer, Mathf.Lerp(1, 0, elapsed / duration));
 yield return null;
 }
 animator.SetLayerWeight(layer, 0);
 }
}

14.2 动画参数与混合

常用动画参数类型：

参数类型	方法	用途
Float	`SetFloat("Speed", 5.5f)`	移动速度、转向角度
Int	`SetInteger("State", 2)`	状态枚举
Bool	`SetBool("IsGrounded", true)`	条件切换
Trigger	`SetTrigger("Jump")`	一次性触发（自动复位）

Blend Tree 混合：根据一个或多个参数平滑过渡动画（如根据速度混合 Idle → Walk → Run）。

1
2
3
4
5
6


// 1D Blend Tree 示例：Idle(0) → Walk(2) → Run(6)
animator.SetFloat("Speed", currentSpeed);

// 2D Blend Tree 示例：根据横向和纵向输入混合
animator.SetFloat("Horizontal", moveX);
animator.SetFloat("Vertical", moveY);

14.3 Animator 性能优化

减少层数：每增加一层都会额外计算
减少参数数量：参数变更会触发状态机重评估
使用 HasExitTime：确保动画播完再过渡，避免频繁打断
优化 Avatar Mask：只在需要的骨骼上启用遮罩

十五、Unity 序列化

15.1 什么是序列化

序列化将对象状态转换为可存储或可传输的格式（二进制、JSON、XML），反序列化则逆向还原。

Unity 中的序列化场景：

场景	说明
场景和预制体保存	Inspector 中修改的 `public` 变量自动序列化到 `.unity` / `.prefab` 文件
Inspector 面板显示	`[SerializeField]` 让私有变量显示在 Inspector 并序列化
ScriptableObject	创建可复用配置数据，保存为 `.asset` 文件
JSON 存档	使用 `JsonUtility` 序列化游戏存档
网络传输	序列化对象状态发送到服务器或其他客户端

15.2 序列化规则

Unity 自动序列化以下类型：

基本类型：int, float, string, bool, enum
Unity 结构体：Vector2/3/4, Quaternion, Color, Rect, Bounds
引用类型：GameObject, Component, ScriptableObject（序列化引用而非内容）
数组和 List<T>（T 必须是可序列化类型）
自定义类/结构体：需标记 [System.Serializable]

不会被序列化的成员：

静态变量
属性（Property，有 get/set 的成员）
委托和事件
接口类型
字典 Dictionary（需手动处理）

15.3 控制序列化的特性

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


[System.Serializable]
public class SaveData
{
 public int level;
 public float positionX;
 public List<string> unlockedItems = new List<string>();
}

public class Player : MonoBehaviour
{
 [SerializeField] private int health; // 私有字段显示在 Inspector

 [HideInInspector] public int debugValue; // 公开字段不在 Inspector 显示

 [NonSerialized] public int tempValue; // 不被序列化（不保存）

 [Range(0, 100)] public float speed; // Inspector 滑动条

 [Tooltip("当前角色等级")]
 public int level; // 鼠标悬停提示

 [Header("战斗属性")] // 分组标题
 public int attack;
 public int defense;
}

// ScriptableObject（可复用配置数据）
[CreateAssetMenu(menuName = "Game/ItemData")]
public class ItemData : ScriptableObject
{
 public int itemID;
 public string itemName;
 public Sprite icon;
 public int maxStack = 1;
}

// 使用 ScriptableObject
ItemData sword = ScriptableObject.CreateInstance<ItemData>();
sword.itemName = "铁剑";
AssetDatabase.CreateAsset(sword, "Assets/Data/Items/IronSword.asset");

15.4 JSON 序列化（存档）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


// 存档数据结构
[System.Serializable]
public class GameSaveData
{
 public int level;
 public float playerHealth;
 public Vector3 playerPosition;
 public List<string> inventoryItems;
 public Dictionary<string, int> stats; // 需要 ISerializationCallbackReceiver
}

// 保存存档
public class SaveManager : MonoBehaviour
{
 public void SaveGame(GameSaveData data)
 {
 string json = JsonUtility.ToJson(data, true); // true = 格式化输出
 File.WriteAllText(Application.persistentDataPath + "/save.json", json);
 }

 public GameSaveData LoadGame()
 {
 string path = Application.persistentDataPath + "/save.json";
 if (File.Exists(path))
 {
 string json = File.ReadAllText(path);
 return JsonUtility.FromJson<GameSaveData>(json);
 }
 return null;
 }
}

JsonUtility vs Newtonsoft.Json：

特性	JsonUtility	Newtonsoft.Json
性能	快（Unity 原生）	较慢
支持类型	MonoBehaviour、ScriptableObject	任意 .NET 类型
字典支持	不支持	支持
多态	不支持	支持
安装	内置	需安装 Package

15.5 ISerializationCallbackReceiver

用于序列化前后执行自定义逻辑，典型用途是处理字典序列化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


public class Inventory : MonoBehaviour, ISerializationCallbackReceiver
{
 // Dictionary 不会被 Unity 自动序列化
 [NonSerialized] public Dictionary<string, int> items = new Dictionary<string, int>();

 // 用列表中转存储
 [SerializeField] private List<string> _keys = new List<string>();
 [SerializeField] private List<int> _values = new List<int>();

 // 序列化前：字典 → 列表
 public void OnBeforeSerialize()
 {
 _keys.Clear();
 _values.Clear();
 foreach (var pair in items)
 {
 _keys.Add(pair.Key);
 _values.Add(pair.Value);
 }
 }

 // 反序列化后：列表 → 字典
 public void OnAfterDeserialize()
 {
 items.Clear();
 for (int i = 0; i < _keys.Count; i++)
 items[_keys[i]] = _values[i];
 }
}

15.6 序列化方案对比

方案	优点	缺点
Unity 默认序列化	自动处理组件引用、Inspector 显示	不支持字典、接口
JsonUtility	轻量、易读、支持 MonoBehaviour	性能较低、不支持多态
BinaryFormatter	高效、体积小	安全性差（已弃用）
第三方（MessagePack）	高性能、跨平台	需额外集成

十六、高性能开发建议

16.1 CPU 性能优化

（1）减少 Update 中的开销：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// ❌ 不好：每帧 GetComponent 和字符串拼接
void Update()
{
 GetComponent<Rigidbody>().AddForce(Vector3.up);
 Debug.Log("位置: " + transform.position);
}

// ✅ 好：缓存引用 + StringBuilder
private Rigidbody rb;
private StringBuilder sb = new StringBuilder(64);

void Start() => rb = GetComponent<Rigidbody>();

void Update()
{
 rb.AddForce(Vector3.up);
 sb.Clear();
 sb.Append("位置: ").Append(transform.position);
}

（2）使用对象池代替频繁 Instantiate/Destroy：

子弹、敌人、粒子特效等高频创建的对象使用对象池
避免 GC 压力，降低 CPU 峰值

（3）减少 Mono 调用：

每帧调用 Unity API（如 transform.position）有 native/managed 边界开销
缓存频繁访问的 Transform、Renderer 等组件引用

（4）LOD（Level of Detail）：

远处的物体使用低面数模型
Unity LOD Group 组件自动切换

16.2 GPU 性能优化

（1）合批（Batching）：

方式	条件	效果
Static Batching	标记为 Static 的物体	减少 Draw Call
Dynamic Batching	小物体（<900顶点）	CPU 换 GPU
GPU Instancing	相同 Mesh + Material 的物体	一次绘制多个

（2）减少 Draw Call：

使用图集（Sprite Atlas）合并纹理
尽可能共用材质
使用 Shader 变体控制功能开关

（3）纹理优化：

使用合适的纹理格式（ASTC/ETC2）
开启 Mipmap（远处用低分辨率）
控制最大纹理尺寸（手机 2048 足够）

16.3 内存优化

（1）资源管理：

1
2
3
4
5
6


// 不再使用的资源手动卸载
Resources.UnloadAsset(myTexture);
Resources.UnloadUnusedAssets();

// Addressables 引用计数自动管理
Addressables.Release(handle);

（2）音频优化：

短音效用 Decompress On Load（立即播放）
背景音乐用 Streaming（边播边加载）
合理设置 Force To Mono（立体声转单声道减半）

（3）避免内存泄漏：

事件订阅后记得取消（OnEnable 注册，OnDisable 注销）
协程在对象销毁后自动停止
DontDestroyOnLoad 对象谨慎使用

16.4 渲染性能 Profiling 工具

工具	用途
Profiler	分析 CPU/GPU/内存瓶颈
Frame Debugger	逐帧查看 Draw Call
Memory Profiler	分析内存分配详情
RenderDoc	深度 GPU 调试
Physics Debugger	碰撞体可视化

16.5 Unity 常用特性关键字

特性	作用
`[SerializeField]`	私有字段显示在 Inspector
`[Range(min, max)]`	滑动条限制数值范围
`[Tooltip("说明")]`	Inspector 中鼠标悬停提示
`[Header("标题")]`	Inspector 中分组标题
`[HideInInspector]`	公开字段不在 Inspector 显示
`[RequireComponent(typeof(X))]`	自动添加依赖组件
`[ExecuteInEditMode]`	编辑模式下也执行脚本
`[DisallowMultipleComponent]`	禁止挂载多个相同组件

本文涵盖 Unity 引擎从基础到进阶的核心知识点，适合 Unity 开发者系统复习和快速查阅。

C#知识点概要

Tue, 02 Jun 2026 15:15:42 +0800

一、基础语法

1.1 变量与数据类型

C# 是强类型语言，所有变量都有明确的类型。

值类型：直接存储数据，分配在栈上。

1
2
3
4
5
6


int age = 25; // 整型
float price = 19.99f; // 单精度浮点（需加 f 后缀）
double pi = 3.14159; // 双精度浮点
bool isActive = true; // 布尔值
char grade = 'A'; // 单个字符
decimal salary = 5000.00m; // 高精度十进制（财务计算用，需加 m 后缀）

引用类型：存储数据的引用（地址），数据在堆上。

1
2
3


string name = "张三"; // 字符串（不可变）
int[] numbers = { 1, 2, 3 }; // 数组
object obj = "任何类型"; // 所有类型的基类

类型转换：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 隐式转换（小范围 → 大范围）
int x = 10;
long y = x;

// 显式转换（大范围 → 小范围，可能丢失精度）
double d = 3.14;
int i = (int)d; // i = 3

// Convert 类（字符串 → 数值）
string text = "123";
int num = Convert.ToInt32(text);

// TryParse（安全转换，不会抛异常）
if (int.TryParse("456", out int result))
 Console.WriteLine(result);

1.2 运算符

C# 提供丰富的运算符用于数据处理。需要特别注意整数除法的截断行为和 null 条件运算符。

算术运算符：+ - * / %。整数相除会截断小数部分，取余 % 获取除法余数。

比较运算符：== != < > <= >=，返回 bool 值。

逻辑运算符：&& || !。&& 存在短路特性，左侧为 false 时右侧不执行。

null 处理运算符：

??（null 合并）：左侧不为 null 则取左侧，否则取右侧
?.（null 条件访问）：左侧为 null 时不执行后续操作，返回 null

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


int a = 10, b = 3;

// 算术运算
int sum = a + b; // 13
int div = a / b; // 3，整数除法结果截断
int mod = a % b; // 1，取余

// 比较运算
bool eq = a == b; // false
bool ne = a != b; // true

// 逻辑运算
bool and = true && false; // false，&& 左侧 false 则右侧不执行
bool or = true || false; // true
bool not = !true; // false

// null 处理运算符
string name = null;
string display = name ?? "默认值"; // name 为 null，取"默认值"
int? length = name?.Length; // name 为 null，length 也为 null

// 三元运算符
string result = a > b ? "更大" : "更小"; // 条件 ? 真值 : 假值

1.3 流程控制

C# 提供四种控制结构。if/else 用于范围判断，switch 用于多分支匹配，for/foreach/while 用于循环。

if/else：条件为 true 时执行对应分支，支持 else if 链式判断。

switch 语句：传统 switch 需要 break 跳出，C# 7+ 支持模式匹配可直接匹配类型。

switch 表达式：C# 8+ 新语法，用 => 取代 case:，更简洁，必须覆盖所有情况。

循环三兄弟：

for：知道次数时使用，需初始化、条件、迭代三部分
foreach：遍历集合元素，无需关心索引，不能修改集合结构
while：条件满足时重复执行，适合不确定次数的场景

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


// if/else
int score = 85;
if (score >= 90)
 Console.WriteLine("优秀");
else if (score >= 60)
 Console.WriteLine("及格");
else
 Console.WriteLine("不及格");

// switch 语句（支持模式匹配）
string status = "admin";
switch (status)
{
 case "admin":
 Console.WriteLine("管理员");
 break;
 case "user":
 Console.WriteLine("普通用户");
 break;
 default:
 Console.WriteLine("未知");
 break;
}

// switch 表达式（C# 8+ 新语法，更简洁）
string level = status switch
{
 "admin" => "管理员",
 "user" => "普通用户",
 _ => "未知" // _ 表示默认情况
};

// for 循环（已知次数时使用）
for (int i = 0; i < 5; i++)
 Console.WriteLine(i);

// foreach 循环（遍历集合，只读）
int[] arr = { 1, 2, 3 };
foreach (var item in arr)
 Console.WriteLine(item);

// while 循环（不确定次数时使用）
int n = 0;
while (n < 3)
{
 Console.WriteLine(n);
 n++;
}

1.4 字符串操作

C# 中 string 是引用类型，但具有不可变性——每次修改都会创建新对象。大量拼接时要用 StringBuilder。

字符串不可变：str += "x" 不是修改原字符串，而是创建新对象并让变量指向它。频繁操作会导致大量临时对象。

字符串插值：$"Hello {name}" 比 + 拼接更可读，推荐用于少量拼合。

StringBuilder：当循环内大量拼接时，用 StringBuilder 避免创建中间对象，显著提升性能。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


string s1 = "Hello";
string s2 = "World";

// 拼接字符串
string result = s1 + " " + s2; // Hello World，产生新字符串
string result2 = $"{s1} {s2}"; // 字符串插值，推荐写法

// StringBuilder（大量拼接时使用，避免 GC 压力）
var sb = new StringBuilder();
for (int i = 0; i < 100; i++)
 sb.Append(i).Append(", "); // 不会创建临时字符串
string big = sb.ToString();

// 常用方法
string text = " Hello World ";
text.Length; // 获取长度
text.Trim(); // 去除首尾空格
text.ToLower(); // 转小写
text.ToUpper(); // 转大写
text.Contains("World"); // 判断是否包含子串
text.StartsWith("Hello"); // 判断是否以指定字符开头
text.Replace("World", "C#"); // 替换子串
text.Split(' '); // 按字符分割为数组
text.Substring(2, 5); // 取子串，从索引 2 开始取 5 个字符

二、面向对象（OOP）

2.1 类与对象

类是 C# 面向对象的基本单位，包含字段、属性、方法、构造函数四种核心成员。

字段 vs 属性：字段是存储数据的变量，属性是对字段的封装（get/set），外部应通过属性访问而不是直接操作字段。自动属性 { get; set; } 由编译器自动生成背后字段。

构造函数：与类同名，创建对象时调用，用于初始化成员。如果不写，编译器提供无参默认构造。

静态成员：属于类本身而非实例，通过类名.成员名直接调用，所有实例共享一份。

只读属性：只提供 get 不提供 set，或如例中 { get; private set; } 外部只读。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


// 定义 Person 类
public class Person
{
 // 字段（私有，外部不可访问）
 private string name;

 // 属性（推荐用属性代替公开字段）
 public string Name { get; set; } // 自动属性，编译器生成背后字段
 public int Age { get; private set; } // 外部只能读，内部可设置

 // 表达式体属性（只读）
 public bool IsAdult => Age >= 18;

 // 构造函数（创建对象时初始化）
 public Person(string name, int age)
 {
 Name = name; // 通过属性赋值
 Age = age;
 }

 // 实例方法
 public void Introduce()
 {
 Console.WriteLine($"我是{Name}，{Age}岁");
 }

 // 静态成员（属于类，不属于对象）
 public static string Species = "人类";
}

// 使用类
var p = new Person("张三", 25); // new 创建实例，调用构造函数
p.Introduce(); // 调用实例方法
Console.WriteLine(Person.Species); // 通过类名访问静态成员

2.2 封装

封装是 OOP 三大特性之一，将数据和行为绑定，对外隐藏内部细节，通过访问修饰符控制外部访问权限。

封装的目的：保护数据不被外部随意修改，通过方法提供受控的操作入口。

属性访问器：

get 读取时执行，可包含逻辑（如计算字段）
set 写入时执行，参数 value 表示传入的值
可单独限制 get/set 的访问级别（如 private set）

带验证的属性：在 set 中添加检查逻辑，确保数据合法性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


public class BankAccount
{
 // 私有字段（外部无法直接访问 balance）
 private decimal balance;

 // 属性：提供受控的访问入口
 public decimal Balance
 {
 get { return balance; } // 读取时直接返回字段
 private set { balance = value; } // 写入权限限制为私有，外部不能改
 }

 // 带验证的属性
 private string accountNumber;
 public string AccountNumber
 {
 get => accountNumber; // 表达式体 get
 set
 {
 if (value.Length != 10)
 throw new ArgumentException("账号必须10位");
 accountNumber = value;
 }
 }

 // 通过公开方法暴露可受控的操作
 public void Deposit(decimal amount)
 {
 if (amount <= 0) return; // 业务规则校验
 balance += amount;
 }
}

2.3 继承

继承让子类复用父类的成员，形成层次关系。C# 支持单继承（一个类只能有一个父类），但支持多层传递。

关键字：

virtual：父类中标记可被子类重写的方法
override：子类重写父类的 virtual 方法
base：在子类中调用父类构造函数或方法
sealed：阻止进一步继承（类前加 sealed 则不可被继承）

构造链：创建子类对象时，先调用父类构造函数（通过 base），再执行子类构造函数。如果不写 base，隐式调用父类的无参构造。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


// 基类
public class Animal
{
 public string Name { get; set; }

 public Animal(string name) // 父类构造函数
 {
 Name = name;
 }

 // virtual 标记：子类可重写此方法
 public virtual void Speak()
 {
 Console.WriteLine("..."); // 默认实现
 }
}

// Dog 继承 Animal
public class Dog : Animal
{
 // base(name) 调用父类构造函数，传入 name
 public Dog(string name) : base(name) { }

 // override 重写父类的 Speak 方法
 public override void Speak()
 {
 Console.WriteLine("汪汪！");
 }
}

// sealed 类禁止被继承
public sealed class Cat : Animal
{
 public Cat(string name) : base(name) { }

 public override void Speak()
 {
 Console.WriteLine("喵~");
 }
}
// class Tiger : Cat { } // 编译错误，Cat 是 sealed

2.4 多态

多态指同一操作在不同对象上产生不同行为。C# 中分为两种：

方法重载（编译时多态）：同类中同名方法但参数不同，编译器根据参数类型和数量决定调用哪个版本。与返回值无关。

方法重写（运行时多态）：通过 virtual/override 实现，运行时根据对象实际类型调用对应方法，而非引用类型。

抽象类 vs 接口：

抽象类：用 abstract 标记，可包含实现和字段，用于"是什么"（is-a 关系）
接口：纯抽象契约，只能声明方法，可多实现，用于"能做什么"（can-do 关系）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


// 方法重载：同名方法，参数不同
public class Calculator
{
 public int Add(int a, int b) => a + b; // 两个 int
 public double Add(double a, double b) => a + b; // 两个 double
 public int Add(int a, int b, int c) => a + b + c; // 三个 int
}

// 抽象类：包含未实现的抽象方法
public abstract class Shape
{
 public abstract double GetArea(); // 抽象方法，子类必须 override
}

// 接口：纯方法声明
public interface IDrawable
{
 void Draw(); // 接口方法隐式 public abstract
}

// 一个类可同时继承抽象类并实现多个接口
public class Circle : Shape, IDrawable
{
 public double Radius { get; set; }

 public override double GetArea() => Math.PI * Radius * Radius;
 public void Draw() => Console.WriteLine("画圆形");
}

2.5 泛型

泛型允许在定义类/方法时将类型作为参数，避免为每种类型重复编写代码，同时保持类型安全。

为什么要用泛型：没有泛型时集合只能存 object，导致装箱拆箱和运行时类型错误。泛型在编译时确定类型，无需转换。

泛型类：用 <T> 声明类型参数，类内部所有使用 T 的地方都会被实际类型替换。

泛型方法：可单独给方法指定类型参数，不依赖所在类是否泛型。

泛型约束 where：限制类型参数必须具备的能力（如实现某接口、有无参构造）。

协变 out 与逆变 in：解决泛型接口的类型兼容问题。out 表示返回值类型（只出），in 表示参数类型（只进）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// 泛型类：T 是类型参数
public class Stack<T>
{
 private T[] items = new T[10];
 private int index = 0;

 public void Push(T item) => items[index++] = item;
 public T Pop() => items[--index];
}
// 使用：Stack<int> intStack = new Stack<int>(); // T 被替换为 int

// 泛型方法
public T Max<T>(T a, T b) where T : IComparable // T 必须实现 IComparable
{
 return a.CompareTo(b) > 0 ? a : b;
}

// 泛型约束
public class Repository<T> where T : class, new() // T 必须是引用类型且有无参构造
{
 public T Create() => new T(); // 因为 new() 约束，可安全调用 new T()
}

// 协变 out：T 只能出现在返回值（只读）
public interface IProducer<out T> { T Produce(); }
// IProducer<Dog> 可视为 IProducer<Animal>（Dog 是 Animal 的子类）

// 逆变 in：T 只能出现在参数（只写）
public interface IConsumer<in T> { void Consume(T item); }
// IConsumer<Animal> 可视为 IConsumer<Dog>（取 Animal 的消费者也能消费 Dog）

三、核心特性

3.1 委托与事件

委托是方法的类型安全引用，可以将方法当作变量传递。C# 提供预定义泛型委托 Action（无返回值）和 Func（有返回值），大部分场景无需自定义委托。

多播委托：同一个委托变量可通过 += 绑定多个方法，调用时会按注册顺序依次执行。

事件：基于委托的发布-订阅模式。和委托的关键区别是——事件只能在声明类内部 Invoke，外部只能 += / -=，更安全。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// 自定义委托（定义方法的"签名"）
public delegate void LogHandler(string message);

// 内置委托：无需自定义，直接用 Action/Func
Action<string> log = msg => Console.WriteLine(msg); // Action 无返回值
Func<int, int, int> add = (a, b) => a + b; // Func<in, in, out> 有返回值

// 多播委托：一个委托绑定多个方法
LogHandler handler = Console.WriteLine; // 第一个方法
handler += msg => File.WriteAllText("log.txt", msg); // 再追加一个
handler("执行完毕"); // 两个方法依次执行

// 事件：类内部触发，外部只能订阅/取消
public class Button
{
 public event EventHandler Clicked; // 声明事件

 public void Click()
 {
 Console.WriteLine("按钮被点击");
 Clicked?.Invoke(this, EventArgs.Empty); // 只能在类内部触发
 }
}

// 使用事件
var btn = new Button();
btn.Clicked += (sender, args) => Console.WriteLine("事件处理"); // 订阅
btn.Click(); // 触发事件
btn.Clicked -= (sender, args) => Console.WriteLine("事件处理"); // 取消订阅
// btn.Clicked?.Invoke(null, null); // 编译错误！事件不能在外部触发

3.2 Lambda 与 LINQ

Lambda 表达式：匿名函数的简洁写法。格式为 (参数) => 表达式，常用于 LINQ 查询和委托参数。

LINQ（Language Integrated Query）：C# 内置的集合查询能力，两种写法：

方法语法：通过链式调用扩展方法（Where、Select、OrderBy 等），更常用
查询语法：类似 SQL 的 from...where...select，编译器会转换为方法语法

延迟执行：LINQ 查询不会立即执行，只有在遍历结果时（如 foreach、.ToList()）才真正运算，多次遍历会多次执行。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


// Lambda 表达式
Func<int, int> square = x => x * x; // 单参数，省略括号
Func<int, int, bool> equals = (x, y) => x == y; // 多参数，需要括号

// LINQ 方法语法
int[] numbers = { 5, 2, 8, 1, 9, 3 };

var evenNumbers = numbers.Where(n => n % 2 == 0); // 筛选偶数 → [2, 8]
var sorted = numbers.OrderBy(n => n); // 升序排序
var top3 = numbers.OrderByDescending(n => n).Take(3); // 前3大 → [9, 8, 5]
var sum = numbers.Sum(); // 求和 → 28
var hasBig = numbers.Any(n => n > 7); // 是否有 >7 的元素 → true

// LINQ 查询语法（类 SQL，编译器转为方法语法）
var query = from n in numbers
 where n > 3
 orderby n descending
 select n;
// 等价于：numbers.Where(n => n > 3).OrderByDescending(n => n)

// 实际应用：对象集合复杂查询
var students = new List<Student>
{
 new Student { Name = "张三", Score = 85 },
 new Student { Name = "李四", Score = 92 },
 new Student { Name = "王五", Score = 67 }
};

var passed = students
 .Where(s => s.Score >= 60) // 筛选及格学生
 .OrderByDescending(s => s.Score) // 按分数降序
 .Select(s => $"{s.Name}: {s.Score}"); // 投影为字符串
// 结果：["李四: 92", "张三: 85", "王五: 67"]

3.3 异常处理

异常是程序运行时的错误，C# 通过 try-catch-finally 机制处理。原则是捕获你能处理的异常，不要吞掉不该吞的错误。

try-catch-finally 流程：

try：包裹可能出错的代码
catch：捕获并处理特定类型的异常，可按异常类型分层捕获（子类在前，父类在后）
finally：无论是否抛出异常都执行，通常用于释放资源

using 语句：语法糖，等价于 try-finally + Dispose()。用于确保 IDisposable 对象（文件流、数据库连接等）被及时释放。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


try
{
 int x = 10;
 int y = 0;
 int result = x / y; // 抛出 DivideByZeroException
}
catch (DivideByZeroException ex) // 先捕获具体异常
{
 Console.WriteLine($"除零异常：{ex.Message}");
}
catch (Exception ex) // 再捕获所有其他异常
{
 Console.WriteLine($"通用异常：{ex.Message}");
}
finally // 不管有没有异常都执行
{
 Console.WriteLine("清理资源：关闭文件、断开连接等");
}

// using 语句：自动释放非托管资源
using (var reader = new StreamReader("file.txt"))
{
 string content = reader.ReadToEnd();
} // 离开 using 块自动调用 reader.Dispose()

// using 声明（C# 8+）：更简洁的写法
using var writer = new StreamWriter("log.txt");
writer.WriteLine("日志内容");
// 离开作用域时自动释放，无需缩进嵌套

3.4 异步编程

异步编程让程序在等待 I/O 操作时不阻塞线程，提升响应性和吞吐量。核心关键字 async 和 await。

async/await 原理：await 碰到未完成的操作时，立即返回调用方，待操作完成后从断点继续执行。期间线程不会被占用，可处理其他请求。

async 方法命名约定：方法名应以 Async 结尾（如 GetDataAsync）。

Task.WhenAll / WhenAny：

WhenAll：等待所有任务完成，并行执行多个异步操作
WhenAny：任意一个完成就继续，可用于超时控制或最快响应

异步流 IAsyncEnumerable：C# 8+ 引入，用于异步地"逐个"产生数据，配合 await foreach 消费。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


// async/await 核心用法
public async Task<string> FetchDataAsync()
{
 using var client = new HttpClient();
 string result = await client.GetStringAsync("https://api.example.com");
 // await 期间线程不会被阻塞，可处理其他请求
 return result;
}

// 并行执行多个任务（比串行快一倍）
public async Task ProcessAllAsync()
{
 var task1 = FetchDataAsync(); // 任务已开始执行
 var task2 = FetchDataAsync(); // 第二个任务也开始了

 // 等待所有任务完成
 await Task.WhenAll(task1, task2);

 // 或等待任意一个先完成（如竞态请求）
 var first = await Task.WhenAny(task1, task2);
 Console.WriteLine(first.Result);
}

// 异步 Lambda
Button clickHandler = async (sender, args) =>
{
 await Task.Delay(1000); // 异步等待1秒，不阻塞 UI 线程
 Console.WriteLine("一秒后执行");
};

// 异步流：逐个异步产生数据项
public async IAsyncEnumerable<int> GenerateNumbersAsync()
{
 for (int i = 0; i < 10; i++)
 {
 await Task.Delay(100); // 模拟异步延迟
 yield return i; // 逐个返回
 }
}

// 消费异步流
await foreach (var num in GenerateNumbersAsync())
 Console.WriteLine(num); // 每100ms输出一个数字

四、进阶主题

4.1 反射与特性

反射：在运行时动态获取类型信息并操作对象的能力。通过 System.Reflection 命名空间中的类实现。常用于：ORM 框架、依赖注入容器、序列化工具、编辑器扩展。

Type：反射的核心类，代表一个类型。可通过 typeof() 或 .GetType() 获取。

Activator：动态创建类型的实例，不需要在编译时知道具体类型。

特性（Attribute）：给代码元素（类、方法、属性等）附加元数据。可通过反射在运行时读取。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


using System.Reflection;

// 获取 Type 对象的两种方式
Type type = typeof(Person); // 编译时已知类型
// Type type = obj.GetType(); // 运行时获取对象类型

// 遍历类型的公开属性
foreach (var prop in type.GetProperties())
 Console.WriteLine($"{prop.Name}: {prop.PropertyType}");

// 动态创建实例（无需编译时知道类型名）
object obj = Activator.CreateInstance(type);

// 动态调用方法
MethodInfo method = type.GetMethod("Introduce");
method.Invoke(obj, null); // 在 obj 上执行 Introduce()

// 自定义特性
[AttributeUsage(AttributeTargets.Class)] // 指定此特性可应用的目标
public class DisplayNameAttribute : Attribute
{
 public string Name { get; }
 public DisplayNameAttribute(string name) => Name = name;
}

// 使用自定义特性
[DisplayName("人员类")]
public class Employee { }

// 读取特性（运行时）
var attr = typeof(Employee).GetCustomAttribute<DisplayNameAttribute>();
Console.WriteLine(attr?.Name); // 输出 "人员类"

4.2 集合与数据结构

C# 集合分为泛型集合（System.Collections.Generic）和非泛型集合（System.Collections），优先使用泛型。

List：动态数组，支持索引访问，内部用数组实现，容量不足时自动2 倍扩容（将旧数据复制到新数组）。

Dictionary<K,V>：哈希表实现，键值对存储，查找 O(1)。内部通过 拉链法 解决哈希冲突，负载因子超 0.72 时自动扩容（2 倍质数，重哈希）。

HashSet：无序唯一集合，适合去重和集合运算（交集、并集、差集）。

Queue：先进先出，尾部入队、头部出队。适用于任务队列、BFS 算法。

Stack：后进先出，顶部压入、顶部弹出。适用于撤销操作、括号匹配、DFS 算法。

线程安全集合（System.Collections.Concurrent）：ConcurrentBag、ConcurrentDictionary、ConcurrentQueue 等，支持多线程安全操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


// List：动态数组，索引访问
List<string> names = new List<string> { "张三", "李四" };
names.Add("王五"); // 添加
names.Remove("李四"); // 移除
names[0] = "赵六"; // 索引访问

// Dictionary：键值对，快速查找
Dictionary<string, int> scores = new()
{
 ["张三"] = 85,
 ["李四"] = 92
};
scores.TryGetValue("张三", out int score); // 安全取值，不存在返回 false

// HashSet：唯一元素集合
HashSet<int> set = new() { 1, 2, 3, 3, 3 }; // 重复元素自动忽略 → { 1, 2, 3 }
set.Add(4);
bool exists = set.Contains(2); // true，O(1) 查找

// Queue：先进先出
Queue<string> queue = new();
queue.Enqueue("第一个");
queue.Enqueue("第二个");
string first = queue.Dequeue(); // "第一个"（先入先出）

// Stack：后进先出
Stack<string> stack = new();
stack.Push("底部");
stack.Push("顶部");
string top = stack.Pop(); // "顶部"（后入先出）

// 线程安全集合
ConcurrentBag<int> bag = new();
Parallel.For(0, 100, i => bag.Add(i)); // 多线程安全添加

4.3 内存管理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


// 值类型（struct）
public struct Point
{
 public int X { get; set; }
 public int Y { get; set; }
}
// 值类型赋值是复制：Point p2 = p1; // 独立副本

// 引用类型（class）
// 引用类型赋值是共享引用：Person p2 = p1; // 指向同一对象

// 弱引用（允许 GC 回收）
WeakReference weakRef = new WeakReference(new Person("临时", 1));

// IDisposable 模式
public class ResourceHolder : IDisposable
{
 private bool disposed = false;

 public void Dispose()
 {
 Dispose(true);
 GC.SuppressFinalize(this);
 }

 protected virtual void Dispose(bool disposing)
 {
 if (!disposed)
 {
 if (disposing)
 // 释放托管资源
 // 释放非托管资源
 disposed = true;
 }
 }
}

4.4 文件与 IO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// 读写文本文件
string content = File.ReadAllText("input.txt"); // 全部读取
string[] lines = File.ReadAllLines("input.txt"); // 按行读取
File.WriteAllText("output.txt", "新内容"); // 覆盖写入
File.AppendAllText("log.txt", "追加内容"); // 追加写入

// Stream 方式（适合大文件）
using (var reader = new StreamReader("bigfile.txt"))
{
 string line;
 while ((line = reader.ReadLine()) != null)
 Console.WriteLine(line);
}

// JSON 序列化（System.Text.Json）
var person = new Person { Name = "张三", Age = 25 };
string json = JsonSerializer.Serialize(person);
var restored = JsonSerializer.Deserialize<Person>(json);

// 传统 JSON 序列化（Newtonsoft.Json / Json.NET）
// string json = JsonConvert.SerializeObject(person);
// var restored = JsonConvert.DeserializeObject<Person>(json);

五、.NET 生态概要

5.1 常用框架

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


// ASP.NET Core Web API 最小示例
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/hello", () => "Hello World");
app.MapPost("/user", (User user) => Results.Created($"/user/{user.Id}", user));

app.Run();

// Entity Framework Core（ORM）
// 定义实体
public class Blog
{
 public int Id { get; set; }
 public string Title { get; set; }
 public List<Post> Posts { get; set; }
}

// 定义上下文
public class AppDbContext : DbContext
{
 public DbSet<Blog> Blogs { get; set; }

 protected override void OnConfiguring(DbContextOptionsBuilder options)
 => options.UseSqlServer("连接字符串");
}

// 使用 EF Core
using var db = new AppDbContext();
var blogs = db.Blogs.Where(b => b.Title.Contains("C#")).ToList();

5.2 依赖注入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 注册服务（ASP.NET Core 启动时）
builder.Services.AddSingleton<ILogger, FileLogger>(); // 单例（全局唯一）
builder.Services.AddScoped<IService, MyService>(); // 作用域（每次请求）
builder.Services.AddTransient<IHelper, MyHelper>(); // 临时（每次注入都创建）

// 构造函数注入
public class UserController
{
 private readonly IUserService userService;

 public UserController(IUserService userService)
 {
 this.userService = userService;
 }
}

// 配置读取
public class MyConfig
{
 public string ConnectionString { get; set; }
}

// 读取配置
var config = builder.Configuration
 .GetSection("Database")
 .Get<MyConfig>();

六、常见陷阱与最佳实践

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


// 1. foreach 中不要修改集合
var list = new List<int> { 1, 2, 3 };
// foreach (var i in list) list.Remove(i); // 抛异常！
for (int i = list.Count - 1; i >= 0; i--)
 list.RemoveAt(i); // 正确方式

// 2. 字符串拼接用 StringBuilder
// 错误：大量循环中用 += 拼接
string s = "";
for (int i = 0; i < 10000; i++)
 s += i.ToString(); // 性能极差！

// 正确：用 StringBuilder
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
 sb.Append(i);
string result = sb.ToString();

// 3. 异步方法命名约定
// 方法名以 Async 结尾
public async Task<int> CalculateAsync() { ... }

// 4. 避免 async void（事件处理除外）
// 错误：public async void DoSomething() { ... }
// 正确：public async Task DoSomething() { ... }

// 5. null 检查
string name = GetName();
// 旧写法
if (name != null) Console.WriteLine(name.Length);
// 新写法（C# 6+）
Console.WriteLine(name?.Length);
// 或者用模式匹配（C# 9+）
if (name is not null) Console.WriteLine(name.Length);

七、推荐学习路线

阶段	内容	目标
基础	变量、控制流、方法、类	能写简单控制台程序
进阶	继承、接口、泛型、委托、LINQ	理解面向对象和函数式编程
高级	异步、反射、DI、EF Core	能开发 Web 应用
实战	ASP.NET Core + EF Core	独立完成全栈项目

本文是对 C# 各知识点的系统性梳理，适合有一定编程基础的同学快速查阅和回顾。代码示例均基于 .NET 6+ 和 C# 10+ 语法。

八、高频面试题（八股文）

8.1 重载和重写的区别

	重载（Overload）	重写（Override）
发生位置	同一个类中	基类和派生类之间
方法名	相同	相同
参数列表	必须不同（个数/类型/顺序）	必须相同
关键字	无要求	`virtual` / `override`
返回值	可以不同	必须相同

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 重载：同类中同名不同参
public class Calc
{
 public int Add(int a, int b) => a + b;
 public double Add(double a, double b) => a + b;
}

// 重写：父子类同名同参
public class Animal { public virtual void Speak() => Console.WriteLine("..."); }
public class Dog : Animal { public override void Speak() => Console.WriteLine("汪汪"); }

8.2 OOP 三大特点

封装：将数据和操作数据的方法绑定在一起，隐藏内部实现，通过 private/public/protected 控制访问权限。

继承：子类继承父类的属性和方法，提高代码复用性。

传递性：C → B → A，C 拥有 A 的特性
单根性：C# 中一个类只能继承一个父类

多态：同一接口在不同对象上有不同表现。两种形式：

编译时多态 → 方法重载
运行时多态 → 方法重写（通过基类引用指向派生类对象实现动态绑定）

8.3 值类型和引用类型的区别

	值类型	引用类型
存储位置	栈上	栈存引用，堆存数据
赋值行为	复制数据	复制引用（指向同一对象）
基类	`System.ValueType`	`System.Object`
包含	`int, bool, char, float, struct, enum`	`string, class, interface, delegate, array`
访问速度	快	慢
GC 回收	不参与（出作用域即释放）	参与（由 GC 回收）

8.4 访问修饰符

修饰符	作用域
`public`	任何类都可以访问
`private`	仅当前类内部
`protected`	当前类 + 派生类
`internal`	同一程序集内
`protected internal`	同一程序集 + 派生类
`private protected`	同一程序集中的派生类

8..5 `ref` 和 `out` 的区别

	`ref`	`out`
变量初始化	调用前必须赋值	调用前可不赋值
函数内赋值	可读可写	必须赋值（返回前必须写）
语义	又进又出（传引用）	只出不进（输出参数）

1
2
3
4
5
6
7


void ModifyRef(ref int x) { x += 10; }
void SetOut(out int x) { x = 100; } // 必须赋值

int a = 5;
ModifyRef(ref a); // a = 15

SetOut(out int b); // b = 100，无需提前初始化

8.6 `ArrayList` 和 `List<T>` 的区别

	`ArrayList`	`List<T>`
类型	非泛型（存储 `object`）	泛型（强类型）
类型安全	不安全（可混存不同类型）	安全（编译时检查）
性能	低（装箱拆箱开销）	高（无需转换）
使用建议	避免使用（兼容旧代码）	推荐使用

8.7 GC 原理与优化

GC 产生原因：自动回收堆上不再被引用的对象，防止内存泄漏。

如何减少 GC 压力：

减少 new 产生对象的次数（对象池、复用）
使用 StringBuilder 代替字符串 +=
避免在频繁调用的方法中创建临时对象
使用结构体代替小对象（值类型不参与 GC）
使用 WeakReference 持有可重建对象

8.8 接口和抽象类的区别

	接口（interface）	抽象类（abstract class）
实现	完全抽象（无实现）	可包含部分实现
多继承	支持（一个类可实现多个接口）	不支持（单继承）
成员修饰符	默认 `public`，不能用其他修饰符	可⽤ `public/protected/private`
字段	不能包含字段	可以包含字段
构造函数	不能有	可以有
使用场景	定义契约/能力（能做什么）	定义基类共性（是什么）

8.9 `sealed` 关键字

1
2
3


sealed class FinalClass { } // 不可被继承
class Base { public virtual void Foo() { } }
class Derived : Base { sealed override void Foo() { } } // 派生类不可再重写

8.10 反射的实现原理

反射：在运行时动态获取程序集、类型、成员信息并调用的机制。

核心类（System.Reflection）：

类	作用
`Assembly`	描述程序集
`Type`	描述类/接口/结构体
`ConstructorInfo`	描述构造函数
`MethodInfo`	描述方法
`FieldInfo`	描述字段
`PropertyInfo`	描述属性

1
2
3
4


Type type = typeof(Person);
object obj = Activator.CreateInstance(type);
MethodInfo method = type.GetMethod("SayHello");
method.Invoke(obj, null);

8.11 静态构造函数

1
2
3
4
5
6
7


class MyClass
{
 static MyClass() // 静态构造函数，类首次被加载时执行一次
 {
 Console.WriteLine("静态初始化");
 }
}

无访问修饰符
不带参数
在类被加载到内存时自动调用，且只执行一次
用于初始化静态成员

8.12 委托和事件的区别

委托：方法的类型安全引用，可将方法作为参数传递。

事件：基于委托的发布-订阅机制。

1
2
3
4
5
6
7


// 委托：可任意 Invoke
public Action Notify;
Notify?.Invoke(); // 外部可以直接调用

// 事件：只能类内部 Invoke，外部只能 += / -=
public event Action Notified;
Notified?.Invoke(); // 仅限声明类内部调用

关键区别：

事件只能在声明它的类内部触发，外部只能注册/注销
委托可以在外部任意调用
事件是委托的封装，更安全

8.13 结构体和类的区别

	结构体（struct）	类（class）
类型	值类型	引用类型
存储	栈	堆
赋值	复制全部数据	复制引用
继承	不能继承（但可实现接口）	支持继承
构造函数	必须带参（无参构造 C# 10+ 才支持）	任意
默认值	不可为 null（除非 Nullable）	可为 null
适用场景	小数据对象（Point、Color）	复杂业务对象

8.14 装箱和拆箱

装箱：值类型 → 引用类型（object / 接口）

拆箱：引用类型 → 值类型

1
2
3
4
5
6


int i = 123;
object o = i; // 装箱：i 复制到堆上
int j = (int)o; // 拆箱：堆上数据复制回栈

// 性能开销：内存分配 + 复制
// 避免：使用泛型集合代替 ArrayList

8.15 `for`、`foreach`、迭代器遍历的区别

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// for：通过索引访问，可修改集合
for (int i = 0; i < list.Count; i++) { list[i] = ...; }

// foreach：通过迭代器只读遍历，不能修改集合结构
foreach (var item in list) { Console.WriteLine(item); }

// 迭代器原理
// 1. 集合实现 IEnumerable 接口，提供 GetEnumerator()
// 2. GetEnumerator() 返回 IEnumerator
// 3. 每次循环调用 MoveNext()，返回 true 则通过 Current 获取元素

foreach 本质：

1
2
3
4
5
6


var enumerator = list.GetEnumerator();
while (enumerator.MoveNext())
{
 var item = enumerator.Current;
 // 循环体
}

8.16 Dictionary 内部实现原理

数据结构：哈希表（拉链法解决冲突）

1
2
3
4
5
6
7
8
9


// 内部结构
private struct Entry {
 public int hashCode; // 哈希码（-1 表示空）
 public int next; // 链表下一节点索引
 public TKey key;
 public TValue value;
}
private int[] buckets; // 桶数组，存链表头索引
private Entry[] entries; // 所有键值对

工作原理：

通过键的 GetHashCode() 计算哈希值
取模定位到桶：buckets[hash % size]
遍历桶对应的链表查找键
插入/查找时间复杂度平均 O(1)

扩容机制：

负载因子超过阈值（默认 0.72）时自动扩容
新容量为原容量 2 倍（取质数）
所有元素重新哈希分配到新桶

8.17 泛型的作用

类型安全：编译时检查类型，避免运行时转型错误
性能提升：避免值类型的装箱拆箱
代码复用：一套代码适配多种类型

1
2
3
4
5
6
7
8
9


// 非泛型：需装箱拆箱
ArrayList list = new ArrayList();
list.Add(123); // 装箱
int val = (int)list[0]; // 拆箱 + 类型转换

// 泛型：无需转换
List<int> list = new List<int>();
list.Add(123);
int val = list[0];

8.18 泛型容器 vs 非泛型容器

泛型容器	非泛型容器	区别
`List<T>`	`ArrayList`	泛型安全无装箱
`Dictionary<K,V>`	`Hashtable`	泛型安全无装箱
`Queue<T>`	`Queue`	泛型安全
`Stack<T>`	`Stack`	泛型安全
`HashSet<T>`	无直接替代	唯一集合

8.19 `unsafe` 关键字

用于编写不安全代码（非托管代码），允许使用指针操作。

1
2
3
4
5


unsafe
{
 int* p = &x;
 *p = 100;
}

适用场景：

与 C/C++ 库互操作
高性能计算（图像处理、加密算法）
Unity 中的指针优化

8.20 堆和栈的区别

	栈	堆
存储内容	局部变量、方法参数、返回地址	对象实例、静态成员
分配速度	快（移动指针）	慢（查找空闲块）
释放方式	方法结束自动释放	GC 自动回收
大小	小（默认 ~1MB）	大（可用虚拟内存）
碎片	无碎片	可能产生内存碎片

8.21 MVC 架构

MVC（Model-View-Controller）：将业务逻辑、数据、界面分离的设计模式。

1
2
3
4
5


用户交互 → Controller（控制逻辑）
 ↓
 Model（数据处理）→ 数据库
 ↓
 View（界面显示）→ 响应用户

Model：数据和业务逻辑
View：界面展示（UI）
Controller：接收用户输入，协调 Model 和 View

8.22 引用类型的 `ref` 传递行为

1
2
3
4
5
6


void ModifyRef(ref Person p)
{
 p.Name = "新名字"; // 修改原对象属性
 p = new Person("新对象"); // 重新赋值后，形参指向新对象
}
// 方法结束后，实参还是指向原始对象，但原始对象的属性已被修改

总结：ref 传递引用类型时，方法内修改对象属性会影响原对象；但重新 new 并赋值不会改变原对象的引用地址。

九、Unity 相关 C# 知识点

9.1 MonoBehaviour 生命周期

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class Player : MonoBehaviour
{
 void Awake() { } // 对象加载时调用（仅一次），早于 Start
 void OnEnable() { } // 每次启用时调用
 void Start() { } // 第一次 Update 前调用（仅一次）
 void Update() { } // 每帧调用
 void FixedUpdate() { } // 固定时间间隔调用（物理更新）
 void LateUpdate() { } // 所有 Update 完成后调用
 void OnDisable() { } // 每次禁用时调用
 void OnDestroy() { } // 销毁时调用
}

执行顺序：Awake → OnEnable → Start → FixedUpdate → Update → LateUpdate → OnDisable → OnDestroy

Awake vs Start：

Awake：用于自身初始化，不依赖其他对象
Start：用于依赖其他对象的初始化（如获取其他组件）

9.2 常用协同程序（Coroutine）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


public class CoroutineExample : MonoBehaviour
{
 void Start()
 {
 StartCoroutine(DelayExecute());
 }

 IEnumerator DelayExecute()
 {
 Debug.Log("开始");
 yield return new WaitForSeconds(2f); // 等待2秒
 Debug.Log("2秒后执行");

 yield return new WaitForEndOfFrame(); // 等待帧结束
 yield return new WaitForFixedUpdate(); // 等待物理帧更新
 yield return null; // 等待下一帧
 }

 // 停止协程
 void Stop()
 {
 StopCoroutine("DelayExecute");
 StopAllCoroutines();
 }
}

协程本质：不是多线程，而是利用 yield return 将方法拆分为多个片段，在主线程上分时执行。

9.3 对象池（Object Pool）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


public class ObjectPool : MonoBehaviour
{
 [SerializeField] private GameObject prefab;
 private Queue<GameObject> pool = new Queue<GameObject>();

 public GameObject Get()
 {
 if (pool.Count > 0)
 {
 GameObject obj = pool.Dequeue();
 obj.SetActive(true);
 return obj;
 }
 return Instantiate(prefab);
 }

 public void Return(GameObject obj)
 {
 obj.SetActive(false);
 pool.Enqueue(obj); // 回收到池中
 }
}

为什么用对象池：

频繁 Instantiate/Destroy 会产生大量 GC 垃圾
对象池复用对象，减少 GC 压力
典型场景：子弹、敌人、特效

9.4 Unity 中的单例模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


// 普通单例
public class GameManager : MonoBehaviour
{
 public static GameManager Instance { get; private set; }

 private void Awake()
 {
 if (Instance != null && Instance != this)
 {
 Destroy(gameObject); // 保证全局唯一
 return;
 }
 Instance = this;
 DontDestroyOnLoad(gameObject); // 场景切换不销毁
 }
}

// 泛型单例基类
public class Singleton<T> : MonoBehaviour where T : Component
{
 public static T Instance { get; private set; }

 protected virtual void Awake()
 {
 if (Instance == null)
 {
 Instance = this as T;
 DontDestroyOnLoad(gameObject);
 }
 else
 {
 Destroy(gameObject);
 }
 }
}

9.5 Unity 中字符串拼接的性能陷阱

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// ❌ 错误：Update 中频繁拼接字符串产生大量 GC
void Update()
{
 string text = "HP: " + health + "/" + maxHealth;
 // 每次 Update 产生 3 个临时字符串对象
}

// ✅ 优化：使用 StringBuilder 或预先分配
private StringBuilder sb = new StringBuilder(64);

void Update()
{
 sb.Clear();
 sb.Append("HP: ").Append(health).Append("/").Append(maxHealth);
 text.text = sb.ToString();
}

// ✅ 或使用 string.Format（固定格式时）
text.text = $"HP: {health}/{maxHealth}";

Unity 特别提醒：Update 每帧调用，字符串操作不当会导致严重的 GC 问题。

9.6 Unity 中 foreach 的 GC 问题

1
2
3
4
5


// ❌ Unity 旧版本中 foreach 会产生 GC Alloc
foreach (var item in list) { }

// ✅ 改用 for 或 GetEnumerator 手动管理
for (int i = 0; i < list.Count; i++) { }

原因：Unity 旧版中 foreach 会生成 IEnumerator 临时对象，新版（2020+）已优化。

最佳实践：

高频调用的 Update/FixedUpdate 中用 for 代替 foreach
非高频位置（按钮点击、协程）可用 foreach，可读性更好

9.7 `SerializeField` 与序列化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class Player : MonoBehaviour
{
 [SerializeField] private int health; // 私有字段在 Inspector 中显示
 [SerializeField] private GameObject prefab;

 [Range(0, 100)] public float speed; // 滑动条限制范围
 [Tooltip("移动速度")] public float moveSpeed; // 鼠标悬停提示
 [Header("攻击设置")]
 public int attackPower;
 public float attackRange;

 [HideInInspector] public int debugValue; // 公开字段不在 Inspector 显示
}

9.8 `GetComponent` 性能优化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


public class Player : MonoBehaviour
{
 // ❌ 每次调用都查找
 void Update()
 {
 GetComponent<Rigidbody>().AddForce(Vector3.up);
 }

 // ✅ 缓存引用
 private Rigidbody rb;

 void Awake()
 {
 rb = GetComponent<Rigidbody>();
 }

 void Update()
 {
 rb.AddForce(Vector3.up);
 }
}

尽量使用 TryGetComponent（C# 7+ / Unity 2019+）：

1
2


if (TryGetComponent(out Rigidbody rb))
 rb.AddForce(Vector3.up);

性能对比：

方法	性能
`GetComponent<T>()`	较慢（抛出异常/隐式搜索）
`TryGetComponent<T>()`	较快（无异常开销）
缓存引用	最快（推荐）

9.9 Unity 中的事件系统

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


// C# 事件（解耦）
public class HealthSystem : MonoBehaviour
{
 public event Action<float> OnHealthChanged;
 public event Action OnPlayerDied;

 private float health = 100;

 public void TakeDamage(float damage)
 {
 health -= damage;
 OnHealthChanged?.Invoke(health);
 if (health <= 0) OnPlayerDied?.Invoke();
 }
}

// 订阅事件
public class UIManager : MonoBehaviour
{
 [SerializeField] private HealthSystem player;

 void Start()
 {
 player.OnHealthChanged += UpdateHealthBar;
 player.OnPlayerDied += ShowGameOver;
 }

 void UpdateHealthBar(float health) { /* 更新血条 */ }
 void ShowGameOver() { /* 显示游戏结束 */ }

 void OnDestroy()
 {
 // 记得取消订阅，防止内存泄漏
 player.OnHealthChanged -= UpdateHealthBar;
 player.OnPlayerDied -= ShowGameOver;
 }
}

UnityEvent（可在 Inspector 中绑定）：

1
2
3
4
5
6
7
8
9


public class Button : MonoBehaviour
{
 public UnityEvent onClick; // 可在编辑器拖拽绑定

 void OnMouseDown()
 {
 onClick?.Invoke();
 }
}

9.10 `Resources` 和 `Addressables` 加载

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


// Resources 加载（简单但性能差）
GameObject prefab = Resources.Load<GameObject>("Prefabs/Player");
Instantiate(prefab);

// Resources 注意事项：
// - 所有 Resources 文件夹中的资源都会被打包，增加包体
// - 加载是同步的，大资源会卡帧
// - 已过时，推荐用 Addressables

// Addressables 加载（异步、按需加载）
AsyncOperationHandle<GameObject> handle =
 Addressables.LoadAssetAsync<GameObject>("Player");
handle.Completed += (op) =>
{
 Instantiate(op.Result);
};

9.11 Unity 中的物理与碰撞

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


public class PhysicsExample : MonoBehaviour
{
 private Rigidbody rb;

 void Awake() => rb = GetComponent<Rigidbody>();

 // 触发检测（不产生物理力）
 void OnTriggerEnter(Collider other) { }
 void OnTriggerStay(Collider other) { }
 void OnTriggerExit(Collider other) { }

 // 碰撞检测（产生物理力）
 void OnCollisionEnter(Collision collision) { }
 void OnCollisionStay(Collision collision) { }
 void OnCollisionExit(Collision collision) { }

 // 射线检测
 void RaycastExample()
 {
 Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
 if (Physics.Raycast(ray, out RaycastHit hit, 100f))
 {
 Debug.Log($"击中: {hit.collider.name}");
 }
 }
}

Layer 和 LayerMask：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public LayerMask targetLayer;

void Shoot()
{
 int mask = 1 << LayerMask.NameToLayer("Enemy");
 if (Physics.Raycast(transform.position, transform.forward, out RaycastHit hit, 100f, mask))
 {
 // 只检测 Enemy 层的物体
 }
}

9.12 Unity 中常用的设计模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42


// 单例模式（全局管理者，参考 9.4）
// 对象池模式（减少频繁创建销毁，参考 9.3）
// 观察者模式（事件解耦，参考 9.9）

// 状态模式（角色状态切换）
public interface IState
{
 void Enter();
 void Update();
 void Exit();
}

public class PlayerStateMachine
{
 private Dictionary<System.Type, IState> states = new();
 private IState currentState;

 public void AddState(System.Type type, IState state) => states[type] = state;

 public void ChangeState(System.Type newStateType)
 {
 currentState?.Exit();
 currentState = states[newStateType];
 currentState.Enter();
 }

 public void Update() => currentState?.Update();
}

// 工厂模式（解耦对象创建）
public class EnemyFactory
{
 public enum EnemyType { Goblin, Slime, Dragon }

 public Enemy Create(EnemyType type) => type switch
 {
 EnemyType.Goblin => new Goblin(),
 EnemyType.Slime => new Slime(),
 EnemyType.Dragon => new Dragon(),
 _ => throw new ArgumentException()
 };
}

9.13 Unity 编辑器扩展基础

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


// 自定义 Inspector
[CustomEditor(typeof(Player))]
public class PlayerEditor : Editor
{
 public override void OnInspectorGUI()
 {
 base.OnInspectorGUI();
 Player player = (Player)target;

 if (GUILayout.Button("重置血量"))
 {
 player.ResetHealth();
 }
 }
}

// 自定义菜单项
public static class EditorTools
{
 [MenuItem("Tools/清除所有 PlayerPrefs")]
 public static void ClearPlayerPrefs()
 {
 PlayerPrefs.DeleteAll();
 Debug.Log("PlayerPrefs 已清除");
 }
}

9.14 Unity 中的协程与异步对比

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


// 协程（老旧但兼容性好）
IEnumerator LoadDataCoroutine()
{
 var request = UnityWebRequest.Get("https://api.example.com");
 yield return request.SendWebRequest();
 Debug.Log(request.downloadHandler.text);
}

// async/await（C# 原生，推荐，需 Unity 2018+）
async Task LoadDataAsync()
{
 var request = UnityWebRequest.Get("https://api.example.com");
 await request.SendWebRequest();
 Debug.Log(request.downloadHandler.text);
}

// Unity 2022+ 支持 Awaitable（零 GC）
async Awaitable LoadDataAwaitable()
{
 await Awaitable.WaitForSecondsAsync(1f);
 Debug.Log("一秒后执行，无 GC 开销");
}

方式	GC 开销	适用场景
Coroutine	有	旧项目、简单延迟
async/await	有（Task 分配）	网络请求、复杂异步
Awaitable	无	Unity 2022+，性能敏感

基于unity开发的简易任务列表

Sat, 03 Jan 2026 21:21:31 +0800

基于unity开发的简易任务列表

前言

这是我在系统性学完c#基础与核心之后，完全由自己构思，编写的作品。其中的很多内容是较为劣质低效的，而且有很多不需要的步骤。同时因为是对自己基础的一次检验，有许多不必要的语法和方式被故意使用。所以不建议当作正常的学习参考。

前期构建

ScriptableObject（SO）

先简单说一下SO是什么和SO的使用场景

ScriptableObject 是 Unity 特有的可序列化资产，数据存储在项目面板（Assets 文件夹）中，独立于场景对象，支持可视化编辑、多脚本共享引用，且非运行时实例化（内存占用低），这些特性决定了它的适用边界。

当你需要在多个脚本（跨场景、跨对象）中共享通用数据，且数据无需永久保存（游戏重启后恢复默认值）时，SO 是首选。

典型用途：

游戏全局配置：玩家初始血量 / 蓝量、移动速度、重力参数、音效音量默认值、关卡解锁规则；
全局状态标识：当前游戏难度（简单 / 中等 / 困难）、是否开启音效 / 震动、当前关卡编号；
通用常量集合：层掩码（LayerMask）、标签（Tag）、UI 显示层级、技能冷却时间常量等。

为什么不用其他方案：

替代单例：避免单例的生命周期混乱、难以调试、不易扩展的问题，SO 可直接在 Inspector 中修改参数，无需编译代码；
替代普通类：普通类无法可视化编辑，修改参数需改代码重新编译，SO 可直观调整数值，实时预览效果；
替代 PlayerPrefs：PlayerPrefs 用于本地持久化存储，不适合核心配置（易被篡改），SO 仅存储默认配置，更安全高效。

当项目中有大量同类对象（道具、敌人、技能等），且每个对象有固定属性集合时，用 SO 做模板配置，可实现 “一处定义、多处复用”，大幅提升开发效率。

典型用途：

道具配置：每个道具对应一个 SO，存储道具名称、图标、描述、价格、效果（回血 / 加攻击）、使用次数、预制体引用；
敌人模板：小兵 / 精英 / BOSS 的 SO，存储血量、攻击、防御、移动速度、攻击范围、掉落道具列表、预制体；
技能模板：每个技能对应一个 SO，存储技能名称、冷却时间、消耗蓝量、伤害值、特效预制体、释放动画、命中判定规则；
关卡模板：每个关卡的 SO，存储敌人刷新点、刷新数量、通关条件（消灭所有敌人 / 到达终点）、背景音乐、关卡奖励。

SO 支持自定义 Editor 脚本，可打造可视化、高易用性的编辑界面，解决复杂配置的编辑痛点，提升团队协作效率。

典型用途：

自定义复杂配置界面：比如技能的多段伤害、特效触发时机、条件判定（如 “血量低于 30% 时伤害翻倍”），通过自定义 Editor 将杂乱的参数整理为折叠面板、下拉选择、预览窗口，避免默认 Inspector 的混乱；批量数据管理：创建 “总表 SO”（如《道具总表》），引用所有道具 SO，方便编辑器下批量查找、筛选、导出（如导出 Excel 配置表）；
工具配置载体：将编辑器工具的参数（如批量烘焙光照的参数、资源打包的路径 / 规则、场景批量导出的配置）存储在 SO 中，方便保存和复用工具配置，无需每次打开工具重新设置。

场景中的游戏对象与场景强绑定（删除场景则对象消失，多场景共用需重复复制），而 SO 独立于场景，可有效降低场景耦合。

典型用途：

跨场景共用数据：如背景音乐列表、UI 文本配置（游戏标题、按钮文字）、通用材质库，无需在每个场景中创建对应的管理对象，只需在脚本中引用同一个 SO 即可；版本控制友好：SO 作为单独的文件存储，相比场景文件（.unity），其修改冲突更容易解决（场景文件包含大量对象信息，冲突后难以合并）；
资源解耦：将对象的 “数据” 与 “逻辑 / 视图” 分离，比如敌人的 “属性数据” 存在 SO 中，“移动 / 攻击逻辑” 存在脚本中，“模型 / 动画” 存在预制体中，便于单独修改数据或逻辑，互不影响。

在游戏运行时，需要在多个脚本间实时共享动态修改的数据，且方便编辑器调试时实时查看 / 修改数值，SO 是理想载体。

典型用途：

实时状态共享：当前玩家金币数量、已收集道具列表、任务完成进度，多个脚本（玩家控制器、商店 UI、任务面板）可直接读取 / 修改 SO 中的数据，无需通过消息传递（如 EventSystem）间接通信；
调试便捷性：在编辑器运行模式下，可直接在 Inspector 中修改 SO 的参数（如临时调高玩家血量、修改技能伤害），实时看到游戏效果，无需停止运行修改代码，大幅提升调试效率。

SO是否适用于任务系统

任务信息中的固定不变 / 可复用的静态数据，是 SO 的核心适用场景，这部分数据完全可以存储在 SO 中。
任务信息的「动态运行时状态」：不适合直接存入 SO。

适合的部分

这些数据是任务的「模板属性」，一旦定义后基本无需频繁修改，或修改后需全局生效：

基础标识与描述：任务 ID、任务名称（如 “消灭 10 只野猪”）、任务描述文本、任务类型（主线 / 支线 / 日常 / 限时）、接取等级要求；
任务目标：目标类型（击杀 / 收集 / 护送 / 探索）、目标对象（野猪 SO / 草药 SO/NPC 预制体）、目标数量（10 只 / 5 个）、目标场景（新手村 / 森林副本）；
任务奖励：金币数量、经验值、道具列表（对应道具 SO 数组）、装备 SO、解锁内容（新关卡 / 新技能）；
接取与提交条件：接取 NPC（名称 / 预制体）、提交 NPC、前置任务 SO（需完成某任务才能接取）、特殊条件（如 “血量高于 50% 时接取”）。

不适合的部分

这些数据是每个玩家 / 角色的专属状态，具有唯一性和临时性：

任务进度：是否已接取、当前完成数量（如已消灭 3 只野猪）、是否达成完成条件、是否已提交；
玩家专属标记：接取任务的角色 ID、任务接取时间（日常任务重置用）、是否放弃过该任务。

核心代码

在SO构建时，必须继承ScriptableObject类，且必须手动标注[CreateAssetMenu]特性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;


[CreateAssetMenu(fileName = "NewTaskDate", menuName = "Task/TaskDate")]
public class TaskDate : ScriptableObject
{
 [Header("基础信息")]
 [SerializeField] public string taskId; // 任务唯一ID
 [SerializeField] public string taskTitle; // 任务标题
 [SerializeField] public string taskLittleTitle;
 [SerializeField] public string taskName;
 [SerializeField] public string positionTxte;
 [SerializeField] public string describeText;
 [SerializeField] public Sprite[] images;//奖励
 [SerializeField] public TaskType taskType;
 [SerializeField] public TaskDate[] nextTask;

 [SerializeField] public bool isSecess =false;//不建议将胜利条件写在SO中

 public enum TaskType
 {
 MainStoryline,
 BranchStoryline,
 }

 public enum Task
 {
 CollectItem,
 KillEnemy,
 TriggerTarget,
 Timing
 }
}

保存脚本后，我们就可以在面板中手动创建SO或者在脚本中动态创建。

注：因为我只制作了任务列表的内容，并未添加具体任务类型，所以索性将任务完成的判断条件扔到SO中，在正常游戏开发中不建议这么设计。

稍微介绍一下 CreateAsset Menu中的参数，fileName的内容时创建SO的默认名字，menuName时右键创建的路径。

任务列表UI构建

我们已经可以将任务信息储存到了SO中，此时需要在unity中创建一个UI界面来表示我们的任务信息，这个UI界面必须要包括任务列表与任务细节。

其中任务列表中应该先分出任务类型，如主线任务，支线任务。然后在分出具体的任务。而这个具体的任务，应该有任务名字，任务地点。

至于任务细节，也应该有任务的名字，地点等，同时还需要详细的描述以及任务奖励的Image。

列表框的构建

列表的构建选取了UI系统中的Scroll View，但是由于Scroll View是横向和纵向的，而任务列表中是纵向的，所以要删除横向的Scrollbar Horizontal，同时给Viewport下的Content新增Vertical Layout Group组件，此时Content的子物体会以列表的形式自动排序，但是排序方式可能会略显奇怪，不是我们需要的精密排列。可以调整Vertical Layout Group中的Spacing的值或者Content Size Fitter的选项来达到想要的效果。

一级列表

一级列表代表了任务系统中的主线任务，支线任务这种任务类型的分类。

当不存在支线任务或主线任务是，我们不许要将其一级列表展示出来，而且一级列表之间的复用性很高，所以直接创建一个通用的一级列表预制体，在需要的时候直接实例化即可。

一级列表的功能应该是点击展开二级列表，再次点击收起二级列表，所以我们使用UI组件中的Toggle组件。相较于Botton的点击触发效果，Toggle的勾选与未勾选两种状态可以很好的的区分收起和展开的功能。同时为了美观，要删去Toggle自带的文字，将勾选框也改为列表的样式。

在Toggle下的Background下再创建Text等组件，用于展现基本信息，根据实际情况修改即可。

由于一级列表下存在二级列表，所以我们要仿照列表框中Content的方式，再一级列表下添加Content Size Fitter组件和Vertical Layout Group组件，用以排序二级列表。

相同的操作可以做出多个不同任务类型的预制体，如主线预制体，支线预制体。

二级列表

二级列表一般表示大概任务内容，譬如任务名字，任务地点等等。与一级列表不同的是它在点击后的作用只有显示任务的详细内容。所以我们直接使用Botton而不是Toggle，因为Toggle的两种状态可能出现需要多次点击才会修改内容的情况。

TaskDescribe

任务详细内容UI根据自己喜好拼出即可。

使用脚本将SO与UI联系起来

我们的首要问题是将SO中的初始任务给分配到UI中。

观察到我们SO中有写了任务完成后应该解锁的下一个任务的数组

1
2
3


 ......
 [SerializeField] public TaskDate[] nextTask;
 ......

我们直接创建UIManager脚本，在TaskManager中创建一个数组来随时接受已解锁的任务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


 public static UIManager _instance;


 public static UIManager Instance
 {
 get
 {
 if (_instance == null)
 {
 _instance = FindObjectOfType<UIManager>();
 }
 return _instance;
 }
 }
 [SerializeField] public TaskDate[] allDates;
 ......

我们会在遍历这个allDates数组的时候实例化一级列表和二级列表的预制体，同时要将一级列表放在前面创建的Scroll View下的content下，所以要提前引入所有一级的类型，二级列表预制体，以及content。

1
2
3
4
5
6


 ......
 [SerializeField] private GameObject MainLineMenu;
 [SerializeField] private GameObject content;
 [SerializeField] private GameObject seconedMenu;
 [SerializeField] private GameObject otherMenu;
 ......

一个储存当前任务的List

1
2
3


 ......
 [SerializeField] private List<GameObject> FirstMenuGB;
 ......

我们在写入这些变量后就可以着手写遍历与实例化列表了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43



 private GameObject newFirstMenu;

 private int mainNumber = 0;
 private int branchNumber = 0;

 private void InstantiateMenu(GameObject menu,int i ,ref int number ,TaskDate taskDate)
 {
 if (number == 0)
 {
 newFirstMenu = Instantiate(menu);
 newFirstMenu.transform.SetParent(content.transform, true);
 FirstMenuGB.Add(newFirstMenu);
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);

 }
 else
 {
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);

 }
 number++;
 Debug.Log(number);
 }

 public void CreatMune()
 {
 for (int i = 0; i < allDates.Length; i++)
 {
 switch (allDates[i].taskType)
 {
 case TaskDate.TaskType.MainStoryline:
 InstantiateMenu(MainLineMenu,i,ref mainNumber, allDates[i]);
 break;
 case TaskDate.TaskType.BranchStoryline:
 InstantiateMenu(otherMenu,i,ref branchNumber, allDates[i]);
 break;
 }
 }
 Debug.Log("已刷新列表");
 }

这样我们的脚本就基本具有了实例化其所持有的所有任务了。

列表状态的刷新

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32



 [SerializeField] private TMP_Text nameText;
 [SerializeField] private TMP_Text describeText;

 public GameObject imageHolder;

 public void UpdateAllMenu()
 {
 for(int i = FirstMenuGB.Count - 1; i >= 0; i--)
 {
 if(FirstMenuGB[i] != null)
 {
 Destroy(FirstMenuGB[i]);
 }

 FirstMenuGB.RemoveAt(i);
 }
 mainNumber = 0;
 branchNumber = 0;
 UpdatesTaskDescribe();
 CreatMune();
 }
 public void UpdatesTaskDescribe()
 {
 for (int i = imageHolder.transform.childCount - 1; i >= 0; i--)
 {
 Transform childImage = imageHolder.transform.GetChild(i);
 Destroy(childImage.gameObject);
 }
 nameText.text = "";
 describeText.text = "";
 }

新建一个ItemEntity脚本，在这个脚本中我们将处理具体脚本的详细信息，也就是二级列表（任务本体）与任务详细描述。

首先新建所需要的一些变量

1
2
3
4
5
6


 public TaskDate currentTaskData;
 [SerializeField] private TMP_Text TaskName;
 [SerializeField] private TMP_Text PositionName;
 [SerializeField] private TMP_Text taskTitle;
 [SerializeField] private TMP_Text taskLittleTitle;
 [SerializeField] private TMP_Text describeText;

然后就是将UIManager中示例化的时候给预制体新增ItemEntity脚本并且将当前的SO赋值给ItemEntity中的currentTaskDaTa。修改UIManager 中的InstantiateMenu方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


 private void InstantiateMenu(GameObject menu,int i ,ref int number ,TaskDate taskDate)
 {
 if (number == 0)
 {
 newFirstMenu = Instantiate(menu);
 newFirstMenu.transform.SetParent(content.transform, true);
 FirstMenuGB.Add(newFirstMenu);
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);
 ItemEntity itemEntity = newSeconedMenu.GetComponent<ItemEntity>();
 itemEntity.currentTaskData = allDates[i];
 }
 else
 {
 GameObject newSeconedMenu = Instantiate(seconedMenu);
 newSeconedMenu.transform.SetParent(newFirstMenu.transform, true);
 ItemEntity itemEntity = newSeconedMenu.GetComponent<ItemEntity>();
 itemEntity.currentTaskData = allDates[i];
 }
 number++;
 Debug.Log(number);
 }

赋值之后回到ItemEntity中，之后就可以得到的SO的信息放到每个变量中，以及达到选中当前任务显示此任务信息的功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


 public void UpdateTaskDate()
 {
 if (currentTaskData != null)
 {
 TaskName.text = currentTaskData.taskName;
 PositionName.text = currentTaskData.positionTxte;
 Debug.Log("更新");
 }
 }

 private void Update()
 {
 if (TaskName.text != currentTaskData.taskName&&PositionName.text != currentTaskData.positionTxte)
 {
 UpdateTaskDate();
 }
 if(taskHolder == null)
 {
 UpdateTaskDescribe();
 }
 GetNewTask();
 }

 private void UpdateTaskDescribe()
 {
 taskHolder = GetComponentInParent<TaskHolder>();
 taskHolder.taskTitle.text = currentTaskData.taskTitle;
 taskHolder.taskLittleTitle.text = currentTaskData.taskLittleTitle;
 }

 public void SelectTask()
 {
 taskHolder.describeText.text = currentTaskData.describeText;
 taskHolder.taskName.text = currentTaskData.taskName;
 UpdateImage();
 }

 private void UpdateImage()
 {
 for(int i = imageHolder.transform.childCount -1; i>=0;i--)
 {
 Transform childImage = imageHolder.transform.GetChild(i);
 Destroy(childImage.gameObject);
 }

 for(int i = 0; i<currentTaskData.images.Length; i++)
 {
 GameObject newImagePrefab = Instantiate(imagePrefab);
 newImagePrefab.transform.SetParent(imageHolder.transform,true);
 Image image = newImagePrefab.GetComponent<Image>();
 image.sprite = currentTaskData.images[i];
 }
 }

 private void GetNewTask()
 {
 if(currentTaskData.isSecess == true)
 {
 for(int i = 0; i < UIManager._instance.allDates.Length; i++)
 {
 if(currentTaskData.taskId == UIManager._instance.allDates[i].taskId)
 {
 for(int j = 0; j < currentTaskData.nextTask.Length; j++)
 {
 UIManager._instance.allDates = ScriptArrayTool.AddScript(UIManager._instance.allDates, currentTaskData.nextTask[j]);
 }
 UIManager._instance.allDates = ScriptArrayTool.RemoveScriptByCondition(UIManager._instance.allDates,
 s=>s!=null&& s.taskId == currentTaskData.taskId );
 }
 }
 UIManager._instance.UpdateAllMenu();


 }
 }

外附一个关于数组的功能类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


 public static class ScriptArrayTool
 {
 /// <summary>
 /// 给脚本数组添加单个脚本实例
 /// </summary>
 /// <typeparam name="T">脚本类型（自定义普通类/MonoBehaviour类）</typeparam>
 /// <param name="originalArray">原脚本数组</param>
 /// <param name="newScript">新脚本实例</param>
 /// <returns>添加后的新脚本数组</returns>
 public static T[] AddScript<T>(T[] originalArray, T newScript) where T : class
 {
 if (originalArray == null)
 {
 return new T[] { newScript };
 }

 List<T> scriptList = new List<T>(originalArray);
 if (newScript != null) // 避免添加null实例
 {
 scriptList.Add(newScript);
 }
 return scriptList.ToArray();
 }

 /// <summary>
 /// 按自定义条件移除脚本数组中的元素
 /// </summary>
 /// <typeparam name="T">脚本类型</typeparam>
 /// <param name="originalArray">原脚本数组</param>
 /// <param name="condition">移除条件（Lambda表达式）</param>
 /// <returns>移除后的新脚本数组</returns>
 public static T[] RemoveScriptByCondition<T>(T[] originalArray, System.Predicate<T> condition) where T : class
 {
 if (originalArray == null || originalArray.Length == 0 || condition == null)
 {
 return originalArray;
 }

 List<T> scriptList = new List<T>(originalArray);
 scriptList.RemoveAll(condition);
 return scriptList.ToArray();
 }

 /// <summary>
 /// 按引用移除脚本数组中的单个脚本实例
 /// </summary>
 /// <typeparam name="T">脚本类型</typeparam>
 /// <param name="originalArray">原脚本数组</param>
 /// <param name="targetScript">目标脚本实例</param>
 /// <returns>移除后的新脚本数组</returns>
 public static T[] RemoveScriptByReference<T>(T[] originalArray, T targetScript) where T : class
 {
 if (originalArray == null || originalArray.Length == 0 || targetScript == null)
 {
 return originalArray;
 }

 List<T> scriptList = new List<T>(originalArray);
 scriptList.Remove(targetScript);
 return scriptList.ToArray();
 }
 }

以及一个TaskHolder脚本和TaskManager脚本来方便扩展

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


public class TaskHolder : MonoBehaviour
{
 [SerializeField] public TMP_Text taskTitle; // 任务标题
 [SerializeField] public TMP_Text taskLittleTitle;
 [SerializeField] public TMP_Text taskName;
 [SerializeField] public TMP_Text describeText;
 [SerializeField] public Sprite[] images;

 private TaskDate taskDate;

 private void Awake()
 {
 GameObject taskName = GameObject.Find("Name Text");
 GameObject describeText = GameObject.Find("DescribeText");
 this.taskName = taskName.GetComponent<TMP_Text>();
 this.describeText = describeText.GetComponent<TMP_Text>();
 }

}

1
2
3
4


public class TaskManager : MonoBehaviour
{
 public TaskDate[] nowTaskDates;
}