设计模式在 Unity 中的应用:单例、观察者、命令、状态、工厂、策略等

2703 字
14 分钟
设计模式在 Unity 中的应用:单例、观察者、命令、状态、工厂、策略等

设计模式是面向对象设计原则的具体应用,原则部分见 面向对象。本文只挑游戏开发中真正常用的模式,并结合 Unity 说明。

总览#

模式解决什么问题Unity 中的典型应用
单例全局唯一、全局访问各种 Manager
观察者一对多的通知,发送方不关心接收方事件、事件中心、数据变化通知 UI
命令把”操作”变成对象输入映射、撤销、回放、技能队列
状态根据状态改变行为角色状态、AI、游戏流程
对象池复用对象,避免频繁创建销毁子弹、特效、列表项
工厂封装创建过程根据配置创建怪物、道具、界面
策略可替换的算法伤害计算、移动方式、AI 行为
模板方法固定流程,子类填充步骤技能释放流程、关卡流程
享元共享不变的数据ScriptableObject 配置
外观简化复杂子系统的接口SDK 封装、音频管理器
服务定位器 / 依赖注入获取依赖,降低耦合替代满天飞的单例
MVC / MVP / MVVM界面与数据分离UI 架构

一、单例#

两种写法#

普通 C# 单例(不需要挂在场景中):

public sealed class SaveManager
{
public static SaveManager Instance { get; } = new SaveManager();
SaveManager() { }
}

静态字段的初始化由运行时保证线程安全,而且只执行一次,这是最简单可靠的写法(静态构造的原理见 访问修饰符与类型修饰符)。

MonoBehaviour 单例(需要用到 Update、协程、Inspector 配置):

public class AudioManager : MonoBehaviour
{
public static AudioManager Instance { get; private set; }
void Awake()
{
if (Instance != null && Instance != this) { Destroy(gameObject); return; } // 防止切场景后出现重复
Instance = this;
DontDestroyOnLoad(gameObject);
}
}

陷阱#

  • 初始化顺序:多个单例在 Awake 中互相访问,顺序不确定(见 生命周期)。最好由一个统一的启动流程按顺序初始化。
  • 重复实例:场景中预先放置了单例对象,切换回这个场景时会再创建一个,需要像上面那样检查并销毁。
  • 退出时访问已销毁的单例:游戏退出时,各个对象的销毁顺序不确定,在 OnDestroy 中访问另一个单例可能出错。
  • 滥用:什么都做成单例,等于把所有东西变成了全局变量,模块之间到处直接引用,难以测试,也难以替换。另外,关闭 Domain Reload 后静态字段不会重置,要手动处理。

二、观察者#

一个对象的状态变化时,通知所有关心它的对象,发送方不需要知道接收方是谁。

C# 的 event 就是观察者模式的语言级实现:

public class Player
{
public event Action<int> OnHpChanged;
public void TakeDamage(int d) { hp -= d; OnHpChanged?.Invoke(hp); }
}
hpBar: player.OnHpChanged += UpdateBar;
音效系统: player.OnHpChanged += PlayHurtSound;

模块多了以后,常用一个全局的事件中心让模块之间通过事件通信。委托与事件的原理、取消订阅导致的内存泄漏,见 委托、事件与 Lambda。

三、命令#

把一个”操作”封装成一个对象:

public interface ICommand
{
void Execute();
void Undo();
}
public class MoveCommand : ICommand
{
readonly Unit _unit; readonly Vector2Int _from, _to;
public MoveCommand(Unit unit, Vector2Int to) { _unit = unit; _from = unit.Pos; _to = to; }
public void Execute() => _unit.MoveTo(_to);
public void Undo() => _unit.MoveTo(_from);
}
// 执行并记录
var cmd = new MoveCommand(unit, target);
cmd.Execute();
_history.Push(cmd);
// 撤销
_history.Pop().Undo();

操作变成对象之后,就可以存储、排队、撤销、重放、发送:

应用说明
撤销 / 重做消除类、解谜类、编辑器工具中,用两个栈保存已执行和已撤销的命令
输入映射按键对应的是命令,而不是直接写死的函数,支持玩家自定义按键
回放记录每帧的命令序列,重放时按顺序执行(帧同步的基础,见 帧同步与状态同步)
技能、指令队列策略游戏中给单位下达一串指令,依次执行
网络命令序列化后发给服务器

四、状态#

对象的行为随内部状态改变时,把每个状态的行为封装成独立的类,而不是在一个方法中写一大堆 if / switch:

// 不好:所有状态的逻辑混在一起
void Update()
{
switch (state)
{
case State.Idle: ... break;
case State.Run: ... break;
case State.Jump: ... break;
// 每加一个状态都要修改这里
}
}

改成状态模式后,每个状态一个类,有自己的 Enter、Update、Exit,新增状态只需新增一个类。完整的实现和它在 AI 中的应用见 有限状态机。

五、对象池#

复用频繁创建、销毁的对象,减少 Instantiate / Destroy 的开销和 GC。见 对象池与引用池。

六、工厂#

把对象的创建过程封装起来,调用方只说”要什么”,不关心”怎么造”:

public class EnemyFactory
{
readonly Dictionary<int, EnemyConfig> _configs;
public Enemy Create(int enemyId, Vector3 position)
{
var config = _configs[enemyId];
var go = ObjectPool.Spawn(config.Prefab, position); // 从对象池取
var enemy = go.GetComponent<Enemy>();
enemy.Init(config.Hp, config.Speed, config.Skills); // 按配置初始化
if (config.IsElite) go.AddComponent<EliteAura>(); // 按配置组合额外的组件
return enemy;
}
}
  • 创建逻辑集中在一处:使用对象池、读取配置、组装组件、注册到管理器,调用方不需要重复这些步骤。
  • 新增怪物类型只需要加配置,调用方的代码不用改(开闭原则)。

七、策略#

把一组可以互相替换的算法分别封装,运行时选择使用哪一个:

public interface IDamageFormula { int Calc(Unit attacker, Unit target); }
public class PhysicalDamage : IDamageFormula { public int Calc(Unit a, Unit t) => Math.Max(1, a.Atk - t.Def); }
public class MagicDamage : IDamageFormula { public int Calc(Unit a, Unit t) => (int)(a.Matk * (1 - t.Mres)); }
public class TrueDamage : IDamageFormula { public int Calc(Unit a, Unit t) => a.Atk; }
skill.Formula = config.DamageType switch
{
DamageType.Physical => new PhysicalDamage(),
DamageType.Magic => new MagicDamage(),
_ => new TrueDamage(),
};

和状态模式的结构很像,区别在于意图:状态模式中,状态之间会自己切换;策略模式中,算法由外部选择,彼此之间没有转换关系。

八、模板方法#

父类定义一个固定的流程,其中某些步骤留给子类实现:

public abstract class Skill
{
public void Cast() // 流程固定,不允许子类修改
{
if (!CanCast()) return;
ConsumeCost();
PlayCastAnimation();
OnCast(); // 每个技能不同的部分
StartCooldown();
}
protected virtual bool CanCast() => !IsCoolingDown && Owner.Mp >= Cost;
protected abstract void OnCast();
}
public class Fireball : Skill
{
protected override void OnCast() => SpawnProjectile("Fireball");
}

所有技能都遵循同一个释放流程,检查、消耗、冷却不会被某个技能漏掉;子类只关心自己的效果。Unity 中父类用 virtual 的 Awake、子类 override 并调用 base 的写法,也是这个思路(见 继承与多态)。

九、享元#

大量对象共享不变的那部分数据,每个对象只保存自己独有的部分:

1000 个哥布林
共享(一份):模型、贴图、最大血量、攻击力、技能列表 ← ScriptableObject 配置
各自(1000 份):当前位置、当前血量、当前目标

Unity 中,ScriptableObject 就是天然的享元:所有实例引用同一份配置资源(见 ScriptableObject)。材质、网格的共享也是同一个思想。

十、外观#

为一个复杂的子系统提供一个简单的统一接口:

public static class Analytics // 业务代码只调用这一个类
{
public static void LogEvent(string name, Dictionary<string, object> args)
{
FirebaseSdk.Log(name, args); // 内部转发给多个 SDK,处理各自的格式差异
AppsFlyerSdk.Track(name, args);
}
}

接入第三方 SDK 时尤其重要:广告、支付、统计、登录,都用一层自己的接口包起来。将来更换或新增 SDK 时,只需要修改这一层,业务代码完全不受影响。

十一、服务定位器与依赖注入#

单例的问题是:代码中到处写 XxxManager.Instance,直接依赖具体的类。

服务定位器:所有服务注册到一个中心,使用者通过接口获取:

Services.Register<IAudioService>(new AudioService());
Services.Get<IAudioService>().Play("click");

依赖的是接口,可以在测试中替换成假的实现,也可以在不同平台注册不同的实现。

依赖注入更进一步:对象不主动去获取依赖,而是由外部在创建时传进来(通过构造函数或字段),对象自己完全不知道服务从哪里来。Unity 中有 VContainer、Zenject 等依赖注入框架。依赖注入背后的原则见 依赖倒置原则。

十二、MVC、MVP、MVVM#

都是把界面和数据、逻辑分开的架构,区别在于界面和数据之间如何连接:

MVCMVPMVVM
组成Model、View、ControllerModel、View、PresenterModel、View、ViewModel
连接方式Controller 处理输入,更新 Model;View 读取 Model 显示View 只负责显示,所有逻辑在 Presenter 中,Presenter 主动更新 ViewView 与 ViewModel 通过数据绑定自动同步
View 与 ModelView 可能直接读取 Model完全隔离完全隔离
在 Unity 中职责边界常常模糊最常用,不需要额外的框架需要数据绑定框架,或者 UI Toolkit 的绑定功能

休闲游戏中常用的”数据层 + 事件 + 界面刷新”,就是简化版的 MVP(见 界面与数据分离)。

常见追问#

单例有什么问题? 初始化顺序不确定、可能出现重复实例、退出时访问已销毁的对象;滥用会造成全局耦合、难以测试和替换。可以用统一的启动流程、服务定位器或依赖注入改善。

观察者模式在 Unity 中怎么用?要注意什么? 用 C# 事件或事件中心实现一对多的通知。订阅后必须在对象销毁或禁用时取消订阅,否则会内存泄漏,或者调用到已销毁的对象。

命令模式有什么用? 把操作封装成对象,从而可以排队、撤销、重放、序列化。用于撤销功能、输入映射、回放、帧同步、指令队列。

状态模式和策略模式有什么区别? 结构相似,意图不同:状态模式中状态会自己切换;策略模式中算法由外部选择,彼此之间没有转换。

工厂模式有什么好处? 把创建过程集中封装:使用对象池、读取配置、组装组件,调用方只需要说要什么;新增类型时调用方不用修改。

享元模式在 Unity 中有什么例子? ScriptableObject 配置被大量实例共享,共享的材质和网格。

为什么要用外观模式封装 SDK? 业务代码只依赖自己的接口,更换或新增 SDK 时只需要修改封装层。

MVC、MVP、MVVM 有什么区别? MVC 中 View 可能直接读取 Model;MVP 中 View 只负责显示,由 Presenter 驱动;MVVM 通过数据绑定让 View 和 ViewModel 自动同步。Unity 中最常用 MVP。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

设计模式在 Unity 中的应用:单例、观察者、命令、状态、工厂、策略等
https://xslab.cloud/posts/csharp/oop/design-patterns/
作者
LuxFire
发布于
2026-10-14
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
面向对象:三大特性、设计原则与组合优于继承
C#底层/面向对象 封装、继承、多态分别解决什么问题;抽象类与接口如何选择;面向对象七大设计原则(SOLID、迪米特法则、合成复用)的含义与示例;以及为什么 Unity 的组件系统是"组合优于继承"的典型。
2
C# GC 原理:从 .NET 分代回收到 Unity 的 Boehm GC
C#底层/内存 GC 如何判断对象可以回收;.NET CLR 的分代、大对象堆和写屏障;Finalizer 与 Dispose 模式;以及 Unity 使用的 Boehm GC 为什么不分代、不压缩,增量 GC 和手动控制 GC 的做法。
3
C# 关键字速查
C#底层/关键字 按类别整理 C# 常用关键字,每个一两句话说明用途和要点,复杂的关键字链接到专题文章。适合复习时快速过一遍。
4
Unity 动画系统:Animator 状态机、混合树、Root Motion、动画事件与性能
Unity底层/基础 Animation 与 Animator 的区别;Animator Controller 的状态、过渡、参数、Has Exit Time、动画层与遮罩;混合树;Humanoid 与 Generic、动画重定向;Root Motion;动画事件与 StateMachineBehaviour;Override Controller;以及 Animator 的性能问题与优化方案。
5
Unity 中的数学与 Transform:点乘叉乘、四元数、万向节锁与插值
Unity底层/基础 向量的长度与归一化;点乘与叉乘的几何意义和在游戏中的应用(前后、左右、夹角、视野判断);本地坐标与世界坐标的转换;欧拉角、万向节锁与四元数;四元数的乘法顺序与常用 API;Lerp、Slerp、MoveTowards、SmoothDamp 的区别。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录