Unity 3D MVC 框架

最新推荐文章于 2024-05-30 16:35:29 发布
最新推荐文章于 2024-05-30 16:35:29 发布
阅读量435 收藏 3
点赞数
分类专栏： Unity 3D UI管理 整理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songhuanfei2017/article/details/102373227
版权

 UIManager

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

namespace MyMVC
{
    public enum UILayerRoot
    {
        None = 0,
        BaseLayer,
        PopWindowLayer,
        TopLayer,
        Count,
    }
    public class UIManager
    {
        private static GameObject canvasObj;
        private static Camera uiCamera;
        private static Canvas canvas;
        private static CanvasScaler canvasScaler;
        private static GObjectFindTool findTool;
        private static Dictionary<UILayerRoot, RectTransform> layerRoots = new Dictionary<UILayerRoot, RectTransform>();
        private static Dictionary<Type, UIBase> openUIs = new Dictionary<Type, UIBase>();
        private static Dictionary<Type, UIBase> closeUIs = new Dictionary<Type, UIBase>();
        private static Dictionary<UILayerRoot, List<UIBase>> openUIsOnLayer = new Dictionary<UILayerRoot, List<UIBase>>();
        private static Dictionary<UIBase, UIMediatorBase> uiAndMediators = new Dictionary<UIBase, UIMediatorBase>();

        public static void Init()
        {
            canvasObj = GameObject.Find("Canvas");
            if (canvasObj == null)
            {
                return;
            }
            UnityEngine.Object.DontDestroyOnLoad(canvasObj);
            findTool = GObjectFindTool.Create(canvasObj);
            uiCamera = findTool.GetComponent<Camera>("UICamera");
            uiCamera.clearFlags = CameraClearFlags.Depth;
            canvas = findTool.GetComponent<Canvas>("Canvas");
            canvasScaler = findTool.GetComponent<CanvasScaler>("Canvas");
            canvasScaler.screenMatchMode = CanvasScaler.ScreenMatchMode.MatchWidthOrHeight;
            //float sw = canvas.pixelRect.width / canvas.scaleFactor;
            //float sh = canvas.pixelRect.height / canvas.scaleFactor;
            //if (sw != 0 && sh != 0)
            //{
                //float f = sw > sh ? sh / sw : sw / sh;
                //canvasScaler.matchWidthOrHeight = f;
            //}
            float o_ratio = canvasScaler.referenceResolution.x / canvasScaler.referenceResolution.y;
            float cur_ratio = (float)Screen.width / Screen.height;
            canvasScaler.matchWidthOrHeight = cur_ratio < o_ratio ? 0 : 1;
            InitUILayerRoots();
        }
        private static void InitUILayerRoots()
        {
            AddOnUILayerRoot(UILayerRoot.BaseLayer, findTool.GetComponent<RectTransform>("BaseLayer"), 0);
            AddOnUILayerRoot(UILayerRoot.PopWindowLayer, findTool.GetComponent<RectTransform>("PopWindowLayer"), -2000);
            AddOnUILayerRoot(UILayerRoot.TopLayer, findTool.GetComponent<RectTransform>("TopLayer"), -4000);
        }
        private static void AddOnUILayerRoot(UILayerRoot layerType, RectTransform tra, float z)
        {
            layerRoots[layerType] = tra;
            Vector3 pos = tra.anchoredPosition3D;
            tra.anchoredPosition3D = new Vector3(pos.x, pos.y, z);
        }
        public static void OnDestroy()
        {
            layerRoots.Clear();
            openUIs.Clear();
            closeUIs.Clear();
            openUIsOnLayer.Clear();
            uiAndMediators.Clear();
        }
        public static UIBase Show<TUI, TMediator>(UILayerRoot layer = UILayerRoot.BaseLayer) where TUI : UIBase where TMediator : UIMediatorBase
        {
            return Show(typeof(TUI), typeof(TMediator), layer);
        }
        private static UIBase Show(Type uiType, Type mediatorType, UILayerRoot layer)
        {
            UIBase ui;
            if (openUIs.TryGetValue(uiType, out ui))
            {
                return ui;
            }
            if (!closeUIs.TryGetValue(uiType, out ui))
            {
                ui = CreateUI(uiType);
            }
            ui.gameObject.transform.SetParent(layerRoots[layer], false);
            InitUIBase(uiType, ui, mediatorType);
            UpdateLayer(layer, ui);
            return ui;
        }
        public static UIBase CreateUI(Type uiType)
        {
            UIBase ui;
            string path = uiType.GetField("ResourcesPath").GetValue(null).ToString();
            GameObject prefab = ResourcesMgr.LoadPrefab("UIPrefabs/" + path);
            if (prefab == null)
            {
                Debug.Log("Cannot find " + path);
                return null;
            }
            GameObject go = UnityEngine.Object.Instantiate(prefab);
            go.name = path;
            ui = go.AddComponent(uiType) as UIBase;
            return ui;
        }
        private static void InitUIBase(Type uiType, UIBase ui, Type mediatorType)
        {
            openUIs[uiType] = ui;
            UIMediatorBase mediator = BindMediator(ui, mediatorType);
            ui.gameObject.SetActive(true);
            mediator.OnShow();
        }
        private static UIMediatorBase BindMediator(UIBase ui, Type mediatorType)
        {
            UIMediatorBase mediator = Activator.CreateInstance(mediatorType, new object[] { ui }) as UIMediatorBase;
            uiAndMediators[ui] = mediator;
            return mediator;
        }
        private static void UnBindMediator(UIBase ui)
        {
            UIMediatorBase mediator;
            if (uiAndMediators.TryGetValue(ui, out mediator))
            {
                MessageManager.UnRegister(mediator);
            }
            uiAndMediators.Remove(ui);
        }
        private static void UpdateLayer(UILayerRoot layer, UIBase ui, bool isShow = true)
        {
            ui.SetUILayerRoot(layer);
            if (!openUIsOnLayer.ContainsKey(layer))
            {
                openUIsOnLayer[layer] = new List<UIBase>();
            }
            List<UIBase> uis;
            if (openUIsOnLayer.TryGetValue(layer, out uis))
            {
                if (isShow)
                {
                    if (!uis.Contains(ui))
                    {
                        uis.Add(ui);
                    }
                    else
                    {
                        uis.Remove(ui);
                        uis.Add(ui);
                    }
                }
                else
                {
                    uis.Remove(ui);
                }
                for (int i = 0; i < uis.Count; i++)
                {
                    uis[i].SetSiblingIndex(i);
                }
            }
        }
        public static void CloseUI<TUI>() where TUI : UIBase
        {
            CloseUI(typeof(TUI));
        }
        private static void CloseUI(Type uiType)
        {
            UIBase ui;
            if (openUIs.TryGetValue(uiType, out ui))
            {
                openUIs.Remove(uiType);
                ui.gameObject.SetActive(false);
                UnBindMediator(ui);
                closeUIs[uiType] = ui;
                UpdateLayer(ui.GetUILayerRoot(), ui, false);
            }
        }
        public static void DestroyAllUI()
        {
            Debug.LogError("UIManager.DestroyAllUI!");

            CloseAllOpenUI();
            foreach (var item in closeUIs)
            {
                UnityEngine.Object.Destroy(item.Value.gameObject);
            }
            closeUIs.Clear();
            openUIsOnLayer.Clear();
        }

        public static bool IsUIOpen<TUI>() where TUI : UIBase
        {
            Type uiT = typeof(TUI);
            if (openUIs.ContainsKey(uiT))
            {
                return true;
            }
            return false;
        }

        public static void CloseAllOpenUI()
        {
            List<Type> allOpenUI = new List<Type>(openUIs.Count);
            allOpenUI.AddRange(openUIs.Keys);
            for (int i = 0; i < allOpenUI.Count; i++)
            {
                CloseUINow(allOpenUI[i]);
            }
        }
    }
}

UIBase

using System;
using System.Collections.Generic;
using System.Reflection;
using UnityEngine;
using UnityEngine.EventSystems;

namespace MyMVC
{
    public class UIBase : MonoBehaviour
    {
        public const string ResourcesPath = "";
        private int siblingIndex;
        private UILayerRoot uiLayer = UILayerRoot.BaseLayer;
        private GObjectFindTool findTool;

        protected GObjectFindTool FindTool
        {
            get
            {
                if (findTool == null)
                {
                    findTool = GObjectFindTool.Create(gameObject);
                }
                return findTool;
            }
        }
        protected GameObject GetObj(string objName)
        {
            return FindTool.GetObject(objName);
        }
        protected T GetCom<T>(string objName) where T : Component
        {
            return FindTool.GetComponent<T>(objName);
        }
        private void OnEnable()
        {
            StartCoroutine(OnStart()); 
        }
        private IEnumerator OnStart()
        {
            yield return new WaitForEndOfFrame();
            OnShow();
        }
        protected virtual void OnShow() { }
        public virtual void InitUI() { }
        public void BindButtons(object mediatorObj, List<string> btnNames, string methodPre = "OnClick")
        {
            Type objType = mediatorObj.GetType();
            for (int i = 0; i < btnNames.Count; i++)
            {
                string btnName = btnNames[i];
                GameObject btnObj = FindTool.GetObject(btnName);
                if (btnObj == null)
                {
                    Debug.Log("Cannot find " + btnName);
                    continue;
                }
                string methodName = methodPre + btnName;
                if (objType.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) == null)
                {
                    Debug.Log("Cannot find " + methodName);
                    continue;
                }
                Action<PointerEventData> func = (Action<PointerEventData>)Delegate.CreateDelegate(typeof(Action<PointerEventData>), mediatorObj, methodName, true, false);
                if (func == null)
                {
                    Debug.Log("Cannot CreateDelegate Action<PointerEventData> " + methodName);
                    continue;
                }
                UIEvent.Get(btnObj).OnPointerClickCallBack = func;
            }
        }
        public void UnBindButtons()
        {
            UIEvent[] uIEvents = GetComponentsInChildren<UIEvent>();
            for (int i = 0; i < uIEvents.Length; i++)
            {
                uIEvents[i].OnPointerClickCallBack = null;
            }
        }
        public void SetSiblingIndex(int index)
        {
            siblingIndex = index;
            if (transform.GetSiblingIndex() != siblingIndex)
            {
                transform.SetSiblingIndex(siblingIndex);
            }
        }
        public void SetUILayerRoot(UILayerRoot layer)
        {
            uiLayer = layer;
        }
        public UILayerRoot GetUILayerRoot()
        {
            return uiLayer;
        }
    }
}

 组件获取工具类 GObjectFindTool

using System.Collections.Generic;
using UnityEngine;

namespace MyMVC
{
    public class GObjectFindTool
    {
        private Dictionary<string, GameObject> objectDic = new Dictionary<string, GameObject>();

        public GObjectFindTool(GameObject obj)
        {
            RegObject(obj);
        }

        public static GObjectFindTool Create(GameObject obj)
        {
            return new GObjectFindTool(obj);
        }

        public void RegObject(GameObject obj)
        {
            Transform[] trs = obj.GetComponentsInChildren<Transform>(true);
            for (int i = 0; i < trs.Length; i++)
            {
                Transform item = trs[i];
                objectDic[item.name.ToLower()] = item.gameObject;
            }
            string sn = obj.name.ToLower();
            if (sn.Contains("(clone)"))
            {
                sn.Replace("(clone)", "");
            }
            objectDic[sn] = obj;
        }

        public static Transform GetObject(GameObject obj, string findName)
        {
            Transform[] trs = obj.GetComponentsInChildren<Transform>(true);
            for (int i = 0; i < trs.Length; i++)
            {
                Transform item = trs[i];
                if (item.name == findName)
                {
                    return item;
                }
            }
            return null;
        }

        public bool HasObject(string objName)
        {
            if (string.IsNullOrEmpty(objName))
            {
                return false;
            }
            objName = objName.ToLower();
            return objectDic.ContainsKey(objName);
        }

        public GameObject GetObject(string objName)
        {
            if (string.IsNullOrEmpty(objName))
            {
                return null;
            }
            objName = objName.ToLower();
            GameObject obj = null;
            if (objectDic.TryGetValue(objName, out obj))
            {
                return obj;
            }
            return null;
        }

        public T GetComponent<T>(string objName) where T : Component
        {
            if (string.IsNullOrEmpty(objName))
            {
                return null;
            }
            GameObject cobj = GetObject(objName);
            if (cobj == null)
            {
                return null;
            }
            return cobj.GetComponent<T>();
        }
    }
}

 加载类 ResourcesMgr

using System.Collections.Generic;
using UnityEngine;

namespace MyMVC
{
    public class ResourcesMgr
    {
        private static Dictionary<string, object> pool = new Dictionary<string, object>();
        private static T Load<T>(string path) where T : Object
        {
            if (pool.ContainsKey(path))
            {
                return pool[path] as T;
            }
            T obj = Resources.Load<T>(path);
            pool[path] = obj;
            return obj;
        }
        public static T LoadObj<T>(string path) where T : Object
        {
            return Load<T>(path);
        }
        public static GameObject LoadPrefab(string path)
        {
            return Object.Instantiate(Load<GameObject>(path));
        }
        public static void ClearPool()
        {
            pool.Clear();
        }
    }
}

 按钮注册相关 UIEvent

using System;
using UnityEngine;
using UnityEngine.EventSystems;

namespace MyMVC
{
    public class UIEvent : EventTrigger
    {
        public static UIEvent Get(GameObject obj)
        {
            UIEvent e = obj.GetComponent<UIEvent>();
            if (e == null)
            {
                e = obj.AddComponent<UIEvent>();
            }
            return e;
        }

        public Action<PointerEventData> OnPointerClickCallBack;
        public Action<PointerEventData> OnPointerDownCallBack;
        public Action<PointerEventData> OnPointerUpCallBack;
        public Action<PointerEventData> OnBeginDragCallBack;
        public Action<PointerEventData> OnDragCallBack;
        public Action<PointerEventData> OnEndDragCallBack;

        public override void OnPointerClick(PointerEventData eventData)
        {
            if (OnPointerClickCallBack != null)
            {
                OnPointerClickCallBack(eventData);
            }
        }
        public override void OnPointerDown(PointerEventData eventData)
        {
            if (OnPointerDownCallBack != null)
            {
                OnPointerDownCallBack(eventData);
            }
        }
        public override void OnPointerUp(PointerEventData eventData)
        {
            if (OnPointerUpCallBack != null)
            {
                OnPointerUpCallBack(eventData);
            }
        }
        public override void OnBeginDrag(PointerEventData eventData)
        {
            if (OnBeginDragCallBack != null)
            {
                OnBeginDragCallBack(eventData);
            }
        }
        public override void OnDrag(PointerEventData eventData)
        {
            if (OnDragCallBack != null)
            {
                OnDragCallBack(eventData);
            }
        }
        public override void OnEndDrag(PointerEventData eventData)
        {
            if (OnEndDragCallBack != null)
            {
                OnEndDragCallBack(eventData);
            }
        }
    }
}

UIMediatorBase

using System.Collections.Generic;

namespace MyMVC
{
    public interface IMediator
    {
        List<string> GetMessageCodes();
        void HandleMessage(IMessage msg);
    }
    public class UIMediatorBase : IMediator
    {
        public UIMediatorBase(UIBase ui)
        {
            ui.InitUI();
            Register();
        }
        public virtual void OnShow() { }
        public virtual List<string> GetMessageCodes() { return null; }
        public virtual void HandleMessage(IMessage msg) { }
        private void Register()
        {
            MessageManager.Register(this);
        }
    }
}

消息注册相关 MessageManager

using System.Collections.Generic;

namespace MyMVC
{
    public class MessageManager
    {
        private static Dictionary<string, List<IMediator>> CodeMessages = new Dictionary<string, List<IMediator>>();
        private static Queue<IMessage> messagesQueue = new Queue<IMessage>();
        private static readonly int perFrameMaxMessage = 10;
        public static void Register(IMediator mediator)
        {
            List<string> codes = mediator.GetMessageCodes();
            if (codes == null)
            {
                return;
            }
            for (int i = 0; i < codes.Count; i++)
            {
                string code = codes[i];
                if (!CodeMessages.ContainsKey(code))
                {
                    CodeMessages[code] = new List<IMediator>();
                }
                CodeMessages[code].Add(mediator);
            }
        }
        public static void UnRegister(IMediator mediator)
        {
            foreach (var item in CodeMessages.Values)
            {
                item.Remove(mediator);
            }
        }
        public static void SendMessage(string codeName, object body = null)
        {
            if (CodeMessages.ContainsKey(codeName))
            {
                IMessage msg = new IMessage
                {
                    Code = codeName,
                    Body = body
                };
                messagesQueue.Enqueue(msg);
            }
        }
        public static void UpdateMessages()
        {
            if (messagesQueue.Count > 0)
            {
                for (int i = 0; i < perFrameMaxMessage; i++)
                {
                    IMessage msg = messagesQueue.Dequeue();
                    HandleMessage(msg);
                    if (messagesQueue.Count == 0)
                    {
                        break;
                    }
                }
            }
        }
        private static void HandleMessage(IMessage msg)
        {
            List<IMediator> mediators;
            if (CodeMessages.TryGetValue(msg.Code, out mediators))
            {
                for (int i = 0; i < mediators.Count; i++)
                {
                    mediators[i].HandleMessage(msg);
                }
            }
        }
    }
}

消息体 IMessage

namespace MyMVC
{
    public class IMessage
    {
        public string Code = "";
        public object Body;
    }
}

UIManager 初始化 MessageManager 消息更新 相关 UITestMono

using UnityEngine;

namespace MyMVC
{
    public class UITestMono : MonoBehaviour
    {
        private void Awake()
        {
            UIManager.Init();
            UIManager.Show<Test01UI, Test01UIMediator>();
        }
        private void Update()
        {
            MessageManager.UpdateMessages();
        }
    }
}

消息代码常量定义 MessageConstCodes

namespace MyMVC
{
    public class MessageConstCodes
    {
        public const string TheTestMessageCode = "TheTestMessageCode";
    }
}

应用例子说明

using UnityEngine.UI;

namespace MyMVC
{
    public class Test01UI : UIBase
    {
        public new const string ResourcesPath = "Test01UI";

        private Text messageText;
        public override void InitUI()
        {
            base.InitUI();
            messageText = GetCom<Text>("Text");
        }
        public void SetText(string msg)
        {
            messageText.text = msg;
        }
    }
}
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;

namespace MyMVC
{
    public class Test01UIMediator : UIMediatorBase
    {
        private Test01UI ui;
        public Test01UIMediator(UIBase ui) : base(ui)
        {
            this.ui = (Test01UI)ui;
            ui.BindButtons(this, new List<string>()
            {
                "SendBtn",
                "Open02UIBtn",
            });
        }
        public override void OnShow()
        {
            base.OnShow();
            Debug.Log("Test01UI show");
        }
        public override List<string> GetMessageCodes()
        {
            return new List<string>()
            {
                MessageConstCodes.TheTestMessageCode,
            };
        }
        public override void HandleMessage(IMessage msg)
        {
            if (msg.Code.Equals(MessageConstCodes.TheTestMessageCode))
            {
                ui.SetText(msg.Body.ToString());
            }
        }
        public void OnClickSendBtn(PointerEventData e)
        {
            MessageManager.SendMessage(MessageConstCodes.TheTestMessageCode, e.clickTime.ToString());
        }
        public void OnClickOpen02UIBtn(PointerEventData e)
        {
            UIManager.Show<Test02UI, Test02UIMediator>();
        }
    }
}

 

码农小飞飞
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity基于MVC的ui框架
01-17
《unity基于MVC的ui框架》博客的资源，请到这里下载。自己写的框架用了几年了，也做了几个游戏，应该是经受住项目考验了吧，现在分享下简本。
【框架设计】Unity 基于MVC的UI框架
ProSWhite的博客
08-24 581
（1）对于程序、策划、美术可以一起流畅的工作；（2）代码维护便捷、维护成本低；（3）降低开发的难度；（4）有较好的游戏更新机制与版本管理；（5）打包发布方便；（6）打空包；（7）制作工具：路径编辑工具 + 地图编辑器 + Excel表格解析 …
Unity | 框架MVC
该用户还没想到好的昵称的博客
05-21 1735
MVC框架总结
【Unity3D日常开发】Unity3d中使用MVC框架
热门推荐
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
11-06 2万+
一、前言 MVC是一种比较常见的设计框架，是一种将代码的功能进行划分的一种设计框架，主要原理就是将软件用户界面和业务逻辑分离，以使代码可扩展性、可复用性、可维护性、灵活性加强。 MVC在桌面应用程序，以及网页架构上面用的比较多，那么怎么应用到Unity3d中呢，下面就带大家去了解这个设计框架，以及如何在Unity中应用。 二、MVC介绍 简介 MVC全名是Model View Controller...
【Unity3D】MVC框架在Unity项目中的理解与使用
MHGO的博客
04-30 4760
推荐阅读 CSDN主页GitHub开源地址Unity3D插件分享简书地址我的个人博客QQ群：1040082875 一、前言 MVC是一种比较常见的设计框架，是一种将代码的功能进行划分的一种设计框架，主要原理就是将软件用户界面和业务逻辑分离，以使代码可扩展性、可复用性、可维护性、灵活性加强。 MVC在桌面应用程序，以及...
【Unity】Unity中MVC框架的应用
葫芦娃子救我的博客
07-19 900
Unity中MVC框架的应用
unity3d mvc框架
12-17
unity3d mvc框架， Code Control v1.2.unitypackage，代码控制器
Unity一键生成MVC框架
09-17
懒得创建GameObject，懒得创建Tag，懒得设置Tag，懒得添加脚本，懒得每次都要获取引用的懒癌患者福音
Unity3D客户端PureMVC框架视屏讲解
12-20
Unity3D客户端PureMVC框架视屏讲解是一个深入解析如何在Unity3D环境中应用PureMVC框架的教学资源。PureMVC是一种轻量级、模块化的前端框架，它为游戏开发提供了一种组织代码的结构，使得项目更易于维护和扩展。在...
MVC框架 c#unity3d
08-10
综上所述，MVC框架在Unity3D中的应用可以显著提高代码结构的清晰度和可维护性。通过合理地划分模型、视图和控制器，开发者可以更好地管理和扩展游戏的UI部分，同时保持业务逻辑的整洁。无论选择NGUI还是UGUI，关键...
SpriteMVC：Unity lua热更新mvc框架
02-03
本框架工程基于Unity 2018.3.5 + UGUI + tolua构建 作为国内最初版本的ulua和SimpleFrameWork的用户与追随者，由衷感谢ulua / tolua以及LuaFramework的创建者与开发者为国产游戏热更新方案做出的贡献，同时对slua与...
Unity使用MVC架构的UI框架搭建
u012863565的博客
08-10 1066
概念： MVC架构可以让程序更加规范，从而使项目更加稳定。 原理就是让数据、逻辑、视图三个模块 各自进行分工，从而耦合低，代码灵活高。 问题： 美工总喜欢改界面，所以我的代码就得迁就他。每次搞得我头疼，好想跟他打一架呦！ 解析： 你把代码写进UI界面里面肯定会头疼的，因为你没有实现逻辑和界面的分离。 这里被写死的，所以一旦界面被删掉，或改动的时候，代码就得进行更改。 程序员：“如果有一份代码，无论界面怎么变动都能完美的运行程序改多好啊~” 比如说，有个按钮A，代码已经写好了事件也已经绑定上
Unity中的MVC、MVP、MVVE框架
qq_54476817的博客
08-26 3494
本文结合一个小案例，讲解MVC、MVP和MVVE在Unity中的相关应用MVC思想最初来自网页和软件开发，并不是为了游戏开发而生，在游戏开发中主要用在大型商业游戏中，小项目使用反而会带来更多麻烦，请酌情使用。
Unity3D基础UI框架，Unity MVVM
Soso
03-05 2万+
unity ui框架 游戏框架
【Unity】MVC框架
两水先木示的博客
06-21 1万+
一、介绍MVC       MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用...
Unity 中带你写MVC架构
yueh0607
09-11 4154
在Unity内教你理解MVC并写一个简单的MVC框架
Unity之MVC思想（通过普通方法和使用MVC思想完成同一个小案例：掌握MVC简单框架）
m0_61490399的博客
08-21 1812
Unity~UI MVC思想
Unity中的MVC框架
最新发布
m0_61939767的博客
05-30 1260
好处1.各司其职，互不干涉 --编程思路更清晰2.有利开发中的分工 -- 多人协同开发时，同步并行3.有利于组件重用 -- 项目换皮时，功能变化小时，提高开发效率坏处1.增加了程序文件的体量 -- 脚本由一变三2.增加了结构的复杂性 --对于不清楚MVC原理的人不友好3.效率相对较低 -- 对象之间的相互跳转，始终伴随着一定开销铁打的M和V，流水的X数据和界面是必备的内容我们可以通过改变X元素来优化原本的MVC也就是改变联系和处理M(数据)和V(界面)的方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值