<think>我们正在讨论
Unity中的
单例模式实现方法。根据引用资料，
Unity单例模式有多种实现方式，主要分为两类：继承MonoBehaviour的
单例和不继承MonoBehaviour的纯C#
单例。同时，还要考虑是否跨场景、是否自动
创建等问题。
根据引用[3]和引用[4]以及引用[5]，我们可以总结如下：
1. 继承MonoBehaviour的
单例：通常需要挂载到游戏物体上，可以处理
Unity的生命周期方法，并且可以跨场景不销毁（通过DontDestroyOnLoad）。这种
单例需要手动挂载到场景中的一个游戏物体上，或者通过代码在运行时
创建。
2. 不继承MonoBehaviour的纯C#
单例：使用传统的
单例模式实现，通过私有构造函数和静态实
例属性来实现。这种
单例在第一次访问时自动
创建，且不依赖于
Unity的游戏物体。但是，它不能直接使用
Unity的生命周期方法（如Start、Update等）。
3. 泛型
单例：可以封装一个泛型
单例基类，方便复用。
下面分别给出几种实现方式：
一、继承MonoBehaviour的
单例（不自动
创建，需手动挂载）
这种
单例模式适用于需要挂载到游戏物体上，并且希望跨场景存在的管理器。
例如：
```csharp
using
UnityEngine;
public class MusicManager : MonoBehaviour
{
public static MusicManager Instance { get; private set; }
private void Awake()
{
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
DontDestroyOnLoad(gameObject); // 如果需要跨场景
}
}
// 其他方法和属性
public float value;
public void SetValue(float a)
{
value = a;
}
}
```
在场景中
创建一个空物体，将MusicManager脚本挂载上去。这样，在别的脚本中可以通过`MusicManager.Instance`来访问。
二、继承MonoBehaviour的
单例（自动
创建）
如果希望当场景中没有该
单例时自动
创建一个，可以修改如下：
```csharp
using
UnityEngine;
public class MusicManager : MonoBehaviour
{
private static MusicManager _instance;
public static MusicManager Instance
{
get
{
if (_instance == null)
{
// 在场景中查找是否已经存在
_instance = FindObjectOfType<MusicManager>();
if (_instance == null)
{
//
创建一个新的游戏物体并挂载
GameObject go = new GameObject("MusicManager");
_instance = go.AddComponent<MusicManager>();
DontDestroyOnLoad(go); // 如果需要跨场景
}
}
return _instance;
}
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(gameObject);
}
else
{
_instance = this;
// 如果希望跨场景，则在这里调用DontDestroyOnLoad
// DontDestroyOnLoad(gameObject);
}
}
}
```
注意：这种方式在第一次访问Instance属性时，如果不存在则自动
创建。但是，如果游戏中有多个场景，并且希望
单例在切换场景时不销毁，则使用DontDestroyOnLoad。同时，在Awake中处理重复实
例的销毁。
三、泛型MonoBehaviour
单例（自动
创建）
为了方便复用，我们可以写一个泛型基类：
```csharp
using
UnityEngine;
public class SingletonMono<T> : MonoBehaviour where T : MonoBehaviour
{
private static T _instance;
public static T Instance
{
get
{
if (_instance == null)
{
_instance = FindObjectOfType<T>();
if (_instance == null)
{
GameObject go = new GameObject(typeof(T).Name);
_instance = go.AddComponent<T>();
}
}
return _instance;
}
}
protected virtual void Awake()
{
if (_instance != null && _instance != this as T)
{
Destroy(gameObject);
}
else
{
_instance = this as T;
// 如果希望跨场景，则在这里调用
// DontDestroyOnLoad(gameObject);
}
}
}
```
然后，具体的
单例类可以继承这个基类：
```csharp
public class MusicManager : SingletonMono<MusicManager>
{
public float value;
public void SetValue(float a)
{
value = a;
}
}
```
这样，我们只需要在MusicManager中关注业务逻辑，而
单例的实现由基类完成。
四、不继承MonoBehaviour的纯C#
单例
这种
单例不依赖于
Unity的游戏物体，适合不需要使用
Unity生命周期的方法的工具类或管理器。
基本实现：
```csharp
public class ConfigManager
{
private static ConfigManager _instance;
// 私有构造函数防止外部实
例化
private ConfigManager()
{
// 初始化
}
public static ConfigManager Instance
{
get
{
if (_instance == null)
{
_instance = new ConfigManager();
}
return _instance;
}
}
// 其他方法
}
```
或者使用更简洁的表达式体属性（C# 6.0及以上）：
```csharp
public class ConfigManager
{
private static ConfigManager _instance;
public static ConfigManager Instance => _instance ?? (_instance = new ConfigManager());
private ConfigManager()
{
// 初始化
}
}
```
五、线程安全的纯C#
单例（使用锁）
如果考虑多线程，可以使用双重检查锁：
```csharp
public class Singleton<T> where T : class, new()
{
private static T _instance;
private static readonly object _lock = new object();
public static T Instance
{
get
{
if (_instance == null)
{
lock (_lock)
{
if (_instance == null)
{
_instance = new T();
}
}
}
return _instance;
}
}
}
```
然后，具体的
单例类可以这样写：
```csharp
public class ConfigManager : Singleton<ConfigManager>
{
// 注意：这里构造函数必须是public，因为new T()需要可访问，但我们可以通过不提供公共构造函数来防止外部实
例化？
// 但是这样写的话，要求T必须有一个公共的无参构造函数。如果希望构造函数非公共，可以使用反射
创建实
例（如引用[4]中所示）。
// 但是，如果使用反射，可以修改为：
// _instance = Activator.CreateInstance<T>(); // 这样即使构造函数是私有的也可以
创建
// 因此，我们可以将构造函数设为私有，然后使用反射
创建。
// 不过，在
Unity中，主线程是唯一的，通常不需要考虑多线程，所以简
单实现即可。
}
```
但是，引用[4]中给出了使用反射的示
例，这样即使构造函数是私有的也可以
创建。不过，在
Unity中，我们通常在主线程操作，所以简
单实现即可。
总结：
在
Unity中实现
单例模式，根据需求选择：
- 如果需要使用
Unity的生命周期方法，或者需要挂载到游戏物体上，则选择继承MonoBehaviour的方式。
- 如果只是工具类，不需要挂载，则选择纯C#
单例。
同时，考虑是否跨场景：对于MonoBehaviour
单例，如果需要跨场景，则使用DontDestroyOnLoad。
另外，注意防止重复
创建和线程安全（在
Unity中通常主线程操作，所以一般不需要考虑线程安全，除非使用多线程）。
最后，根据引用[5]的总结表格，我们可以清晰地选择：
| 类型 | 是否MonoBehaviour | 是否跨场景 | 是否自动
创建 |
|------|-------------------|------------|--------------|
| 简
单单例 | 是 | 是（需DontDestroyOnLoad） | 否（需手动挂载） |
| 泛型
单例（Mono） | 是 | 是（需DontDestroyOnLoad） | 是 |
| 纯逻辑
单例 | 否 | 是（在内存中） | 是 |
根据实际需求选择适合的
单例实现。
参考文献：
[^3]:
Unity单例模式实现跨场景通讯
[^4]:
Unity单例模式
[^5]:
Unity单例模式完全指南
相关问题：
1. 在
Unity中，如何实现一个跨场景的
单例？
2.
单例模式在
Unity中有什么潜在的风险？
3. 如何避免
单例模式在
Unity场景切换时被重复
创建？
4. 在
Unity中使用
单例模式管理游戏状态的最佳实践是什么？</think>###
Unity 单例模式实现方法详解
在
Unity 中实现
单例模式主要有三种方式，根据是否继承 `MonoBehaviour` 和是否支持跨场景，可以选择最适合的方案：
---
#### 一、继承 MonoBehaviour 的基础
单例（需手动挂载）
```csharp
public class GameManager : MonoBehaviour
{
public static GameManager Instance; // 静态实
例引用
void Awake()
{
// 确保只有一个实
例存在
if (Instance != null && Instance != this)
{
Destroy(gameObject);
}
else
{
Instance = this;
DontDestroyOnLoad(gameObject); // 跨场景不销毁
}
}
// 示
例方法
public void LoadLevel(int levelId)
{
// 关卡加载逻辑
}
}
```
**特点**：
1. 需要手动挂载到场景 GameObject
2. 支持
Unity 生命周期方法（Awake/Update 等）
3. 通过 `DontDestroyOnLoad` 实现跨场景[^3]
4. 适用于游戏管理器、场景控制器等
---
#### 二、泛型自动
创建单例（继承 MonoBehaviour）
```csharp
public abstract class SingletonMono<T> : MonoBehaviour where T : MonoBehaviour
{
private static T _instance;
private static readonly object _lock = new object();
public static T Instance
{
get
{
lock (_lock)
{
if (_instance == null)
{
// 场景中查找现有实
例
_instance = FindObjectOfType<T>();
// 不存在则
创建新对象
if (_instance == null)
{
GameObject obj = new GameObject(typeof(T).Name);
_instance = obj.AddComponent<T>();
DontDestroyOnLoad(obj); // 跨场景保留
}
}
return _instance;
}
}
}
protected virtual void Awake()
{
// 防止重复
创建
if (_instance != null && _instance != this)
{
Destroy(gameObject);
}
}
}
// 使用示
例
public class AudioManager : SingletonMono<AudioManager>
{
public void PlaySound(string clipName)
{
// 音频播放逻辑
}
}
```
**优势**：
1. 自动
创建实
例对象
2. 线程安全（通过 lock 实现）[^4]
3. 支持跨场景持久化
4. 可复用性强（通过继承使用）
---
#### 三、纯 C#
单例（不继承 MonoBehaviour）
```csharp
public class ConfigManager
{
private static ConfigManager _instance;
// 私有构造函数防止外部实
例化
private ConfigManager()
{
// 初始化逻辑
}
public static ConfigManager Instance =>
_instance ?? (_instance = new ConfigManager());
// 示
例方法
public string GetConfig(string key)
{
// 配置读取逻辑
return "value";
}
}
```
**适用场景**：
1. 工具类、算法类等无需
Unity 依赖的模块[^5]
2. 数据管理器、配置加载器等
3. 不需要
Unity 生命周期事件的对象
---
### 三种实现方式对比
| 类型 | 继承 MonoBehaviour | 跨场景支持 | 自动
创建 | 适用场景 |
|------|--------------------|------------|----------|----------|
| 基础
单例 | ✅ | ✅ | ❌ | 游戏核心管理器 |
| 泛型
单例 | ✅ | ✅ | ✅ | 音频/资源管理器 |
| 纯C#
单例 | ❌ | ✅ | ✅ | 工具类/配置类 |
---
### 最佳实践建议
1. **线程安全**：多线程环境使用 `lock` 确保
单例唯一性[^4]
2. **场景切换**：使用 `DontDestroyOnLoad` 保持跨场景状态[^3]
3. **初始化时机**：在 `Awake` 中初始化而非 `Start`，确保其他脚本可用
4. **访问控制**：将构造函数设为 `private` 防止外部实
例化
5. **资源释放**：实现 `OnDestroy` 清理资源，避免内存泄漏
>
单例模式虽然方便全局访问，但过度使用会导致代码耦合度高。建议仅用于真正需要全局唯一性的管理器类[^5]。
---
### 使用示
例
```csharp
// 调用音频管理器
AudioManager.Instance.PlaySound("Explosion");
// 访问游戏配置
string playerSpeed = ConfigManager.Instance.GetConfig("PlayerSpeed");
```
扫一扫
4810
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
