Tengine游戏框架之单例模式

已于 2023-04-22 15:28:28 修改
阅读量559 收藏 2
点赞数
分类专栏： TEngine游戏框架 文章标签： 单例模式 游戏 unity TEngine框架
于 2023-04-22 12:59:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wlqchengzhangji/article/details/130303452
版权
这篇文章介绍了在Unity游戏引擎中实现单例模式的方法，包括基于MonoBehaviour的游戏对象单例和普通的单例对象，以及一个统一的单例管理器SingletonMgr，用于注册、释放和管理这些单例。单例模式在游戏开发中常用于确保某些对象在整个应用生命周期内只存在一个实例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

using UnityEngine;

namespace TEngine.Runtime
{
    /// <summary>
    /// 具备Unity完整生命周期的单例
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class UnitySingleton<T> : MonoBehaviour,IUpdateSystem where T : MonoBehaviour
    {

        private static T _instance;

        /// <summary>
        /// 单例
        /// </summary>
        public static T Instance
        {
            get
            {
                if (_instance == null)
                {
                    var ins = UnityEngine.Object.FindObjectOfType<T>();
                    if (ins != null)
                    {
                        ins.gameObject.name = typeof(T).Name;
                        _instance = ins;
                        SingletonMgr.Retain(ins.gameObject);
                        return Instance;
                    }

                    System.Type thisType = typeof(T);
                    string instName = thisType.Name;
                    GameObject go = SingletonMgr.GetGameObject(instName);
                    if (go == null)
                    {
                        go = GameObject.Find($"{instName}");
                        if (go == null)
                        {
                            go = new GameObject(instName);
                            go.transform.position = Vector3.zero;
                        }
                    }

                    _instance = go.GetComponent<T>();
                    if (_instance == null)
                    {
                        _instance = go.AddComponent<T>();
                    }

                    if (_instance == null)
                    {
                        TLogger.LogError($"Can't create UnitySingleton<{typeof(T)}>");
                    }
                }
                return _instance;
            }
        }


        /// <summary>
        /// 单例对象获取
        /// </summary>
        /// <returns></returns>
        public static T Active()
        {
            return Instance;
        }


        /// <summary>
        /// 单例是否有效
        /// </summary>
        public static bool IsValid
        {
            get
            {
                return _instance != null;
            }
        }


        /// <summary>
        /// 检查单例
        /// </summary>
        /// <returns></returns>
        private bool CheckInstance()
        {
            if (this == Instance)
            {
                return true;
            }
            GameObject.Destroy(gameObject);
            return false;
        }


        /// <summary>
        /// 加载
        /// </summary>
        protected virtual void OnLoad()
        {

        }

        /// <summary>
        /// 初始化
        /// </summary>
        public virtual void Awake()
        {
            if (CheckInstance())
            {
                UpdateInstance.Instance.Retain(this);
                OnLoad();
            }
#if UNITY_EDITOR
            TLogger.LogInfo($"UnitySingleton Instance:{typeof(T).Name}");
#endif
            GameObject tEngine = SingletonMgr.Root;
            if (tEngine != null)
            {
                this.gameObject.transform.SetParent(tEngine.transform);
            }
        }

        /// <summary>
        /// 获取游戏框架模块优先级。实现Interface
        /// </summary>
        /// <returns></returns>
        /// <remarks>优先级较高的模块会优先轮询，并且关闭操作会后进行。</remarks>
        public int GetPriority()
        {
            return Priority;
        }
        
        /// <summary>
        /// 获取游戏框架模块优先级。
        /// </summary>
        /// <remarks>优先级较高的模块会优先轮询，并且关闭操作会后进行。</remarks>
        public virtual int Priority
        {
            get
            {
                return 1;
            }
        }


        /// <summary>
        /// OnUpdate通过TEngine统一驱动,舍弃Unity的Update
        /// </summary>
        /// <param name="elapseSeconds"></param>
        /// <param name="realElapseSeconds"></param>
        public virtual void OnUpdate(float elapseSeconds, float realElapseSeconds)
        {
            
        }


        /// <summary>
        /// 单例销毁
        /// </summary>
        public virtual void OnDestroy()
        {
            UpdateInstance.Instance.Release(this);
            Release();
        }


        /// <summary>
        /// 单例释放
        /// </summary>
        public static void Release()
        {
            if (_instance != null)
            {
                SingletonMgr.Release(_instance.gameObject);
                _instance = null;
            }
        }
    }
}

上面是MonoBehavior单例游戏对象脚本；

    /// <summary>
    /// 单例接口
    /// </summary>
    public interface ISingleton
    {
        /// <summary>
        /// 激活
        /// </summary>
        void Active();

        /// <summary>
        /// 释放
        /// </summary>
        void Release();
    }    

    /// <summary>
    /// 全局单例对象（非线程安全）
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class TSingleton<T> : ISingleton where T : TSingleton<T>, new()
    {
        protected static T _instance = default(T);

        /// <summary>
        /// 单例对象
        /// </summary>
        public static T Instance
        {
            get
            {
                if (null == _instance)
                {
                    _instance = new T();
                    _instance.Init();
#if UNITY_EDITOR
                    TLogger.LogInfo($"TSingleton Instance:{typeof(T).Name}");
#endif
                    SingletonMgr.Retain(_instance);
                }
                return _instance;
            }
        }


        /// <summary>
        /// 是否有效
        /// </summary>
        public static bool IsValid
        {
            get
            {
                return _instance != null;
            }
        }

        protected TSingleton()
        {

        }


        /// <summary>
        /// 初始化
        /// </summary>
        protected virtual void Init()
        {

        }


        /// <summary>
        /// 激活
        /// </summary>
        public virtual void Active()
        {

        }


        /// <summary>
        /// 单例释放
        /// </summary>
        public virtual void Release()
        {
            if (_instance != null)
            {
                SingletonMgr.Release(_instance);
                _instance = null;
            }
        }
    }

上面是普通的单例对象脚本。

/// <summary>
    /// 单例管理器(统一化持久和释放)
    /// </summary>
    public static class SingletonMgr
    {
        /// <summary>
        /// 单例对象列表
        /// </summary>
        private static List<ISingleton> _iSingletonList;
        /// <summary>
        /// 单例游戏对象字典
        /// </summary>
        private static Dictionary<string, GameObject> _gameObjects;

        private static GameObject _root;

        /// <summary>
        /// 单例游戏对象的父级
        /// </summary>
        public static GameObject Root
        {
            get
            {
                if (_root == null)
                {
                    _root = GameObject.Find("TEngineMgr");

                    if (_root == null)
                    {
                        _root = new GameObject("TEngineMgr");

                        _root.transform.position = Vector3.zero;
                    }

                    UnityEngine.Object.DontDestroyOnLoad(_root);
                }

                return _root;
            }
        }


        /// <summary>
        /// 单例对象注册
        /// </summary>
        /// <param name="go"></param>
        public static void Retain(ISingleton go)
        {
            if (_iSingletonList == null)
            {
                _iSingletonList = new List<ISingleton>();
            }
            _iSingletonList.Add(go);
        }

        /// <summary>
        /// 单例游戏对象注册
        /// </summary>
        /// <param name="go"></param>
        public static void Retain(GameObject go)
        {
            if (_gameObjects == null)
            {
                _gameObjects = new Dictionary<string, GameObject>();
            }

            if (!_gameObjects.ContainsKey(go.name))
            {
                _gameObjects.Add(go.name, go);
            }
        }


        /// <summary>
        /// 单例游戏对象释放销毁
        /// </summary>
        /// <param name="go"></param>
        public static void Release(GameObject go)
        {
            if (_gameObjects != null && _gameObjects.ContainsKey(go.name))
            {
                _gameObjects.Remove(go.name);
                UnityEngine.Object.Destroy(go);
            }
        }

        /// <summary>
        /// 单例对象释放
        /// </summary>
        /// <param name="go"></param>
        public static void Release(ISingleton go)
        {
            if (_iSingletonList != null && _iSingletonList.Contains(go))
            {
                _iSingletonList.Remove(go);
            }
        }



        /// <summary>
        /// 所有的单例释放销毁
        /// </summary>
        public static void Release()
        {
            if (_gameObjects != null)
            {
                foreach (var item in _gameObjects)
                {
                    UnityEngine.Object.Destroy(item.Value);
                }

                _gameObjects.Clear();
            }

            if (_iSingletonList != null)
            {
                for (int i = 0; i < _iSingletonList.Count; ++i)
                {
                    _iSingletonList[i].Release();
                }

                _iSingletonList.Clear();
            }

            Resources.UnloadUnusedAssets();
        }

        /// <summary>
        /// 根据名字获得单例游戏对象
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static GameObject GetGameObject(string name)
        {
            GameObject go = null;
            if (_gameObjects != null)
            {
                _gameObjects.TryGetValue(name, out go);
            }

            return go;
        }

        /// <summary>
        /// 检查是否有该单例游戏对象
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        internal static bool ContainsKey(string name)
        {
            if (_gameObjects != null)
            {
                return _gameObjects.ContainsKey(name);
            }

            return false;

        }


        /// <summary>
        /// 根据名字获取该单例对象
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        internal static ISingleton GetSingleton(string name)
        {
            for (int i = 0; i < _iSingletonList.Count; ++i)
            {
                if (_iSingletonList[i].ToString() == name)
                {
                    return _iSingletonList[i];
                }
            }

            return null;
        }

        /// <summary>
        /// 释放所有单例【游戏重启可以使用】
        /// </summary>
        public static void ReStart()
        {
            Release();
            SceneManager.LoadScene(0);
        }
    }

上面是游戏中的所有单例对象，不管是普通单例或者是MonBehaviour单例的统一管理器。

Tengine AIFramework框架
吴建明wujianming_110117
04-18 319
Tengine AIFramework框架 在开源大势下，以数据、算力、算法为三驾马车的人工智能实现了初级阶段的产业化落地。任何一个技术领域成熟的标志是从应用到平台的成功迭代，AI 也不例外，最终引导 AI 走向成熟的必将是软件平台。 以史为鉴，回看过往 PC 时代，Windows 的普及，带来海量差异化业务应用的繁荣，迎来了互联网的快速发展；移动互联网时代，Android、iOS 二分天下，让移动应用开发者得以乘风破浪，千万级的 APP 充实了生活的各个场景，便捷愉悦的同时，业态升级随之而来。那么，在万亿
Unity TEngine开源框架 Luban篇
最新发布
小博君
02-18 584
比如你放到TEngine目录下，对应需要减少一个../弹出控制台，第一次会让你选文件还是目录，我选的文件。先光讲简单运用，后续再说。
TEngine框架的导入与运行
成长ing中的w的专栏
11-13 2866
Tengine游戏的导入与运行
TEngine 安装和配置指南
gitblog_07248的博客
09-13 683
TEngine 安装和配置指南 TEngine Unity框架解决方案-支持HybridCLR(最好的次时代热更)与YooAssets(优秀商业级资源框架)。 项目地址: https://gitcode.com/gh_mirror...
TEngine框架关于系统逻辑生命周期的接口的封装
成长ing中的w的专栏
04-22 1402
自定义的一些直接需要直接继承自MonoBehaviour组件的脚本，可以通过BehaviourSingleton达到同样的效果，而且避免多个MonoBehaviour之间控制问顺序题，各自模块的Update顺序由各模块定义的优先级决定，这样能做到执行顺序可控。上面是对所有Behaviour单例对象的整体管理控制：注册、注销、以及各生命周期接口的统一调用。上面是对所有系统的注册、注销以及系统各生命周期阶段的接口的实现。上面是对系统的逻辑生命周期接口的是现实。上面是关于系统的逻辑生命周期的接口封装。
Tengine:在C＃中从头开始制作引擎
03-31
Tengine:在C＃中从头开始制作引擎
Unity TEngine开源框架 学习记录 四、模块介绍（更新中）
小博君
11-12 2694
高效且无GC的事件系统GameEvent，可以指定事件ID/事件String监听和分发事件。通过事件来驱动模块，如战斗的角色身上的事件流、UI和网络以及Model的数据流、开发中的绝大部分情况都可以通过事件来进行驱动。(配合UI模块或者拓展的战斗模块实现MVE[Model - View - Event]事件驱动架构)事件模块支持string和int作为事件Id，但推荐是使用int因为可以避免事件字典的哈希碰撞。这里实现了StringId.StringToHash的方法来定义事件ID达到事件系统的最佳性能。
tengine 推理框架，win10 cmake 编译
08-25
编译好的文件 ---- ------------- ------ ---- -a---- 2022/8/25 下午 08:06 416256 tm_alphapose.exe -a---- 2022/8/25 下午 08:06 388096 tm_apollo_smoke.exe -a---- 2022/8/25 下午 08:06 304640 tm_...
Tengine for windows
05-22
Tengine web server for windows ，兼容nginx Tengine 使用cygwin编译适用于windows x64，编译了健康检查模块，health check check interval=3000 rise=2 fall=2 timeout=1000 type=http; check_...
Tengine（tengine-2.3.3.tar.gz）
03-31
8. **故障转移与备份**：Tengine支持主备模式，当主服务器出现问题时，可以自动切换到备用服务器，保证服务的连续性。 9. **安全性**：Tengine提供了多种安全特性，包括SSL/TLS加密、HTTP/2支持、防止跨站脚本攻击...
tengine2.1.2
03-05
Tengine是淘宝团队基于Nginx开发的一款高性能的Web服务器/反向代理服务器，它包含了Nginx的所有功能，并在性能、稳定性和功能扩展性上进行了优化。标题提到的"Tengine2.1.2"是该软件的一个特定版本，这个版本包含了...
Unity TEngine开源框架 学习记录 三、热更新
小博君
11-06 1616
资源模块
Unity中 单例模式
qq_74158527的博客
07-23 3523
在`Awake()`方法中，如果`instance`为`null`，则将当前实例赋值给`instance`，否则销毁重复的实例。如果该实例不存在，它将在内部被创建，否则直接返回已有的实例。请注意，使用这种方式时，确保在调用`GameManager.instance`之前，`GameManager`类的实例已经被正确初始化。在游戏开发中，特别是使用Unity引擎时，单例模式经常用于管理全局的状态、资源、设置或其他对象，以确保它们在整个游戏中始终只存在一个实例，从而避免不必要的重复创建和管理实例。
unity客户端开源框架
weixin_44192860的博客
04-04 2316
unity客户端开源框架整理.
Unity 设计模式-单例模式（Singleton）详解
从易到难，从入门到精通
11-23 1901
单例模式 (Singleton Pattern) 是一种创建型设计模式，保证一个类只有一个实例，并提供一个全局访问点来获取该实例。它通过控制类的实例化过程，确保系统中只有一个该类的对象存在。
【Unity技巧】使用单例模式Singleton
weixin_33922672的博客
09-03 1692
这几天想把在实习里碰到的一些好的技巧写在这里，也算是对实习的一个总结。好啦，今天要讲的是在Unity里应用一种非常有名的设计模式——单例模式。开场白单例模式的简单介绍请看前面的链接，当然网上还有很多更详细的介绍，有兴趣的童靴可以了解一下。其实设计模式对于一个程序员来说还是非常有用的，这点随着学习的深入感受越来越深。好啦，现在说一下Unity里的单例模式。什么时候需要使用单例模式呢？正如它的名字...
Unity单例模式最佳实践（附代码）
问渠哪得清如许，为有源头活水来
01-09 8183
笔者系统地整理了下在Unity中实现单例的若干种方案。 分析各种方案优劣，给出了推荐的优雅写法。 针对两类情况分别提供了实现方案： 1. 继承自MonoBehaviour(7种) 2. 纯C#实现(3种)
Unity TEngine开源框架 学习记录 二、运行框架（更新中）
小博君
10-30 1312
运行框架
unity tengine框架
02-06
### 关于 Unity 和 TEngine 框架的使用教程 #### 一、简介 TEngine 是一个面向 Unity 开发者的框架，集成了 HybridCLR 和 YooAssets 等先进技术组件，旨在提供高效的热更新能力和优秀的资源管理系统[^1]。此框架设计简洁易懂，适合新手快速上手的同时也满足了专业开发者的需求[^2]。 #### 二、环境搭建指南 为了开始使用 TEngine 进行开发工作，首先需要完成必要的前期准备工作： - 安装最新版本的 Unity 编辑器； - 下载并导入 TEngine 插件包到项目中； - 配置好所需的依赖项和服务端口设置； 这些操作可以通过访问官方仓库获取详细的安装指导文档以及示例工程来辅助理解如何正确地集成该框架至个人或团队的工作流当中。 #### 三、核心功能解析 ##### （一）资源配置管理 TEngine 支持多种类型的配置文件用于定义不同方面的参数，默认情况下会寻找扩展名为 `.conf` 的文件作为全局设定的一部分[^3]。对于游戏内资产而言，则借助 YooAssets 实现了高度灵活且可靠的加载策略，能够有效减少打包体积并优化运行效率。 ##### （二）热更新实现方式 通过引入 HybridCLR 技术方案，使得应用程序可以在不重新部署整个程序的情况下动态替换部分逻辑代码片段，从而极大地方便了后期维护和技术债务清理过程中的灵活性需求[^4]。 #### 四、实践案例分享 下面给出一段简单的 C# 脚本样例，展示了怎样利用 TEngine 提供的功能接口创建一个基本的游戏对象实例: ```csharp using UnityEngine; using TEngine; public class Example : MonoBehaviour { void Start() { // 初始化 TEngine 组件 GameEntry.Initialize(); // 加载预制体资源 GameObject prefab = Resources.Load<GameObject>("ExamplePrefab"); // 创建新的游戏物体 Instantiate(prefab); Debug.Log("TEngine 已成功初始化！"); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Data菌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值