【MVC界面框架搭建 二】

已于 2023-04-21 10:35:40 修改
阅读量162 收藏
点赞数 1
分类专栏： Unity 游戏 文章标签： mvc java unity
于 2023-04-21 10:34:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MoonWinding/article/details/130282325
版权
游戏 同时被 2 个专栏收录
27 篇文章 6 订阅
订阅专栏
Unity
21 篇文章 1 订阅
订阅专栏

打开界面策略：
PolicyStack 栈式打开策略 同一时间只允许一个打开操作

using UnityEngine;

namespace UIFrameWork
{
    /// <summary>
    /// 栈式打开策略 同一时间只允许一个打开操作
    /// </summary>
    public class PolicyStack : PolicyBase
    {
        public PolicyStack(GameObject pRoot, int pStartZ, int pOffZ)
        {
            this.Root = pRoot;
            startZ = pStartZ;
            offZ = pOffZ;
        }

        public override void OpenCtrl(UICtrlBase pCtrlBase, System.Action pOnFinish, LastPanelOp pLastPanelOp = LastPanelOp.None, object pData = null)
        {
            pCtrlBase.SetParent(Root);
            var performData = new PerformData(){
                ctrlBase = pCtrlBase,
                data = pData,
                onFinish = pOnFinish,
                lastPanelOp = pLastPanelOp
            };
            if (curPerformData == null)
            {
                curPerformData = performData;
                OpenCtrlInternal(curPerformData, () => {
                    curPerformData = null;
                    LoopOpenAllCathePerfroms(null);
                });
            }
            else
            {
                performCatchDatas.Add(performData);
            }
        }
    }
}

PolicySingle 打开单独界面 有界面的时候，不会再打开其他界面 比例系统级别的提示弹窗 ,
加载界面等

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

namespace UIFrameWork
{
    /// <summary>
    /// 打开单独界面 有界面的时候，不会再打开其他界面 比例系统级别的提示弹窗 ,加载界面等
    /// </summary>
    public class PolicySingle : PolicyBase
    {
        public PolicySingle(GameObject pRoot, int pStartZ, int pOffZ)
        {
            this.Root = pRoot;
            startZ = pStartZ;
            offZ = pOffZ;
        }

        public override void OpenCtrl(UICtrlBase pCtrlBase, System.Action pOnFinish, LastPanelOp pLastPanelOp = LastPanelOp.None, object pData = null)
        {
            if (curPerformData == null && ctrlBases.Count < 1)
            {
                var performData = new PerformData()
                {
                    ctrlBase = pCtrlBase,
                    data = pData,
                    onFinish = pOnFinish,
                    lastPanelOp = pLastPanelOp
                };
                curPerformData = performData;
                OpenCtrlInternal(curPerformData, () =>
                {
                    curPerformData = null;
                });
            }
            else {
                Debug.LogWarning($" is exist one single panel or have one panel is loading !");
            }
        }
    }
}

PolicyMul /// 同时可以打开多个界面

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

namespace UIFrameWork
{
    /// <summary>
    /// 同时可以打开多个界面
    /// </summary>
    public class PolicyMul : PolicyBase
    {
        public override void OpenCtrl(UICtrlBase pCtrlBase, System.Action pOnFinish, LastPanelOp pLastPanelOp = LastPanelOp.None, object pData = null){
            var performData = new PerformData(){
                ctrlBase = pCtrlBase,
                data = pData,
                onFinish = pOnFinish,
                lastPanelOp = pLastPanelOp
            };
            OpenCtrlInternal(performData, null);
        }
    }
}

当然可以根据项目需求自由扩展自己打开的扩展需求

界面管理类 UIManager

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace UIFrameWork {
    public class UIManager
    {
        private static UIManager instance;

        public static UIManager Instance { get { if (instance == null) instance = new UIManager(); return instance; } }

        public PolicyStack loginPolicy;     //登录场景界面的策略
        public PolicyStack mainPolicy;      //主界面场景的策略
        public PolicyStack battlePolicy;    //战斗界面的策略

        public PolicySingle tipPolicy;      //玩家的基本提示 确定弹窗等
        public PolicySingle systemPolicy;   //系统级的提示 高等级 断开链接，报错，等系统级的提示策略
        public PolicySingle loadPolicy;     //加载界面

        private GameObject canvas;

        private GameObject mainRoot;
        private GameObject systemRoot;
        private GameObject loadRoot;

        private bool isInit = false;
        private string canvasName = "Canvas/UIRoot";

        public static void SetFrameRoot(string mainName,GameObject mainRoot,string subName,GameObject subRoot,System.Action<GameObject,GameObject> pOnFinish) {
            if (mainRoot == null){
                mainRoot = GameObject.Find(mainName);
            }
            if (mainRoot == null) {
                Debug.LogWarning($"mainRoot is nil {mainName}");
                pOnFinish?.Invoke(null,null);
                return;
            }
            if (subRoot == null) {
                var subRootTrans = mainRoot.transform.Find(subName);
                if (subRootTrans != null)
                {
                    subRoot = subRootTrans.gameObject;
                }
                else
                {
                    subRoot = new GameObject(subName);
                    subRoot.transform.parent = mainRoot.transform;
                    subRoot.transform.SetPositionAndRotation(Vector3.zero,Quaternion.identity);
                    subRoot.transform.localScale = Vector3.one;
                    subRoot.transform.localPosition = Vector3.zero;
                }
                var rectTransform = subRoot.GetComponent<RectTransform>();
                if (rectTransform == null) {
                    rectTransform = subRoot.AddComponent<RectTransform>();
                }
                //rectTransform.pivot = new Vector2(0.5f,0.5f);
                rectTransform.anchorMin = Vector2.zero;
                rectTransform.anchorMax = Vector2.one;
                rectTransform.sizeDelta = Vector2.zero; // new (Screen.width,Screen.height);// (RectTransform.Axis.Horizontal,Screen.width);
                //rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, Screen.height);
            }
            pOnFinish?.Invoke(mainRoot, subRoot);
        }
        public void OnInit()
        {
            if (isInit)
                return;
            isInit = true;

            SetFrameRoot(canvasName, canvas,"MainRoot", mainRoot,(oMianRoot,oSubRoot)=> { canvas = oMianRoot; mainRoot = oSubRoot; });
            SetFrameRoot(canvasName, canvas, "LoadRoot", loadRoot, (oMianRoot, oSubRoot) => { canvas = oMianRoot; loadRoot = oSubRoot; });
            SetFrameRoot(canvasName, canvas, "SystemRoot", systemRoot, (oMianRoot, oSubRoot) => { canvas = oMianRoot; systemRoot = oSubRoot; });

            //SetFrameRoot(canvasName, canvas, "LoadRoot", loadRoot);
            //SetFrameRoot(canvasName, canvas, "SystemRoot", systemRoot);
            
            loginPolicy = new PolicyStack(mainRoot, 10,100);
            mainPolicy = new PolicyStack(mainRoot, 10, 100);
            battlePolicy = new PolicyStack(mainRoot,10,100);

            systemPolicy = new PolicySingle(systemRoot, 0,100);
            loadPolicy = new PolicySingle(loadRoot,0,100);
        }

        public void OnDispose() {
            isInit = false;
        }
    }
}

下面是View 层代码：
View 层代码比较简单 ，主要是实现显示的功能和自动生成Ctrl 和View 层代码的逻辑
ViewReference 界面的mono 物件挂载者

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

[System.Serializable]
public class UIElementBinder {
    public string key;
    public ComponentType type;
    public GameObject go;
}

public class ViewReference : MonoBehaviour
{
    public List<UIElementBinder> binders = new List<UIElementBinder>();

#if UNITY_EDITOR
    public UIModelType modelType = UIModelType.Login; //属于哪个模块的
    public string subType;                            //自定义的子模块
    public CtrlType cltrType = CtrlType.PanelCtrl;    //控制类型

    private bool CheckValid(){
        var regex = new System.Text.RegularExpressions.Regex(@"^[a-zA-Z0-9_]+$");
        if (!regex.IsMatch(gameObject.name)){
            Debug.LogError("创建脚本失败 名字中包含非法字符 (请检查预制体名字之后是否多出一个空格):" + gameObject.name);
            return false;
        }
        return true;
    }
    private void AddComponent(GameObject pTarget, ComponentType pType)
    {
        var componentSet = UIDef.ComponentSettings.Find((oInfo)=> {
            return oInfo.type == pType;
        });
        if (componentSet != null)
        {
            var csComponent = componentSet.CompName;
            if (pTarget.GetComponent(csComponent) != null){
                var elementBinder = new UIElementBinder();
                elementBinder.go = pTarget;
                elementBinder.type = pType;
                elementBinder.key = pTarget.name;
                binders.Add(elementBinder);
            }
            else {
                Debug.LogError($"get component is null type is : {pType} name is :{pTarget .name}");
            }
        }
        else
        {
            Debug.LogError($"is not exist component type is {pType}");
        }
    }
    private Transform[] AddTargetComponents(GameObject pTarget)
    {
        if (!ignoreList.Contains(pTarget))
        {
            var nameT = pTarget.name;
            if (nameT.StartsWith(UIDef.dynamicEleKey))
            {
                for (var i = 0; i < UIDef.ComponentSettings.Count; i++)
                {
                    var temp = UIDef.ComponentSettings[i];
                    if (nameT.Contains(temp.key))
                    {
                        AddComponent(pTarget, temp.type);
                        if (temp.isIngoreChild)
                        {
                            var childs = pTarget.GetComponentsInChildren<Transform>(true);
                            var viewReference_ = pTarget.GetComponentInChildren<ViewReference>(true);
                            if (viewReference_ != null)
                            {
                                viewReference_.PickAllComponent();
                            }
                            return childs;
                        }
                        break;
                    }
                    else
                    {
                        var csComponent = temp.CompName;
                        var com = pTarget.GetComponent(csComponent);
                        //Debug.LogError($"csComponent{csComponent}");
                        //if (csComponent == "UnityEngine.Transform") {
                        //    Debug.LogError("11");
                        //}
                        if (com != null)
                        {
                          
                            AddComponent(pTarget, temp.type);
                            if (temp.isIngoreChild)
                            {
                                var childs = pTarget.GetComponentsInChildren<Transform>(true);
                                var viewReference_ = pTarget.GetComponentInChildren<ViewReference>(true);
                                if (viewReference_ != null)
                                {
                                    viewReference_.PickAllComponent();
                                }
                                return childs;
                            }
                            break;
                        }
                    }
                }
            }
        }
        return null;
    }
    private List<GameObject> ignoreList = new List<GameObject>();
    [NaughtyAttributes.Button("绑定动态节点信息")]
    private void PickAllComponent() {
        binders.Clear();
        ignoreList.Clear();
        ignoreList.Add(this.gameObject);
        var nameT = this.gameObject.name;
        foreach (var temp in UIDef.ComponentSettings)
        {
            if (nameT.Contains(temp.key))
            {
                AddComponent(this.gameObject, temp.type);
            }
        }
        var childs = this.gameObject.GetComponentsInChildren<Transform>(true);
        foreach (var temp in childs)
        {
            var childs_ = AddTargetComponents(temp.gameObject);
            if (childs_ != null)
            {
                foreach (var temp_ in childs_)
                {
                    ignoreList.Add(temp_.gameObject);
                }
            }
        }
    }
    [NaughtyAttributes.Button("生成ViewBase.cs")]
    private void GenViewCsFile() {
        if (!CheckValid())
            return;
        var filePath = GetCsFilePath();
        CSGenerater.GenerateUIViewCSFile(filePath, this);
    }
    [NaughtyAttributes.Button("生成ViewBaseCtrl.cs")]
    private void GenViewCsCtrlFile()
    {
        if (!CheckValid())
            return;
        var filePath = GetCsFilePath();
        CSGenerater.GenerateUIBaseCtrlCSFile(filePath, this, cltrType);
    }

    private string GetCsFilePath() {
        var gameName = gameObject.name;
        if (gameName.StartsWith(UIDef.dynamicEleKey))
        {
            gameName = gameName.Substring(1, gameName.Length - 1);
        }
        string filePath = $"{modelType}/{gameName}";// gameObject.name;
        if (!string.IsNullOrEmpty(subType))
        {
            filePath = $"{modelType}/{subType}/{gameName}";
        }
        return filePath;
    }
    [NaughtyAttributes.Button("<<定位ViewBase.cs>>")]
    private void PingViewCsFile() { 
        var pFilePath = GetCsFilePath();
        var filePath = Application.dataPath + "/" + UIDef.uiRootPanel + pFilePath + ".cs";
        if (System.IO.File.Exists(filePath)){
            var assetPath = "Assets/" + UIDef.uiRootPanel + pFilePath + ".cs";
            var assetObj = UnityEditor.AssetDatabase.LoadAssetAtPath<TextAsset>(assetPath);
            UnityEditor.EditorGUIUtility.PingObject(assetObj);
            //UnityEditor.Selection.activeObject = assetObj;
        }
        else {
            Debug.LogError($"file is not exist path is {filePath}");
        }
    }
    [NaughtyAttributes.Button("<<定位ViewBaseCtrl.cs>>")]
    private void PingViewCsCtrlFile()
    {
        var pFilePath = GetCsFilePath();
        var filePath = Application.dataPath + "/" + UIDef.uiRootPanel + pFilePath + "Ctrl.cs";
        if (System.IO.File.Exists(filePath))
        {
            var assetPath =  "Assets/" + UIDef.uiRootPanel + pFilePath + "Ctrl.cs";
            var assetObj = UnityEditor.AssetDatabase.LoadAssetAtPath<TextAsset>(assetPath);
            //UnityEditor.Selection.objects = new UnityEngine.Object[1] { assetObj };
            UnityEditor.EditorGUIUtility.PingObject(assetObj);
            //UnityEditor.Selection.activeObject = assetObj;
        }
        else
        {
            Debug.LogError($"file is not exist path is {filePath}");
        }
    }
#endif
}

界面的显示逻辑

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


public class UIViewBase
{
    protected ViewReference viewReference;
    protected EventG.StringObjectEvent ctrlEvent;

    public void SetCtrlEvnet(EventG.StringObjectEvent pCtrlEvent) {
        ctrlEvent = pCtrlEvent;
    }
    public virtual void SetViewReference(ViewReference pViewReference) {
        viewReference = pViewReference;
    }
    public T GetComponent<T>(int index)  where T : Component
    {
        if (this.viewReference != null && this.viewReference.binders.Count > index)
        {
            return this.viewReference.binders[index].go.GetComponent<T>();
        }
        return null;
    }

    public virtual void OnInit() 
    {     
    }
    public virtual void OnForward() 
    {
    }
    public virtual void OnBackground() 
    { 
    }
    public virtual void OnDestroy() 
    {   
    }
}

自动构建代码逻辑

#if UNITY_EDITOR
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UIFrameWork;
using UnityEditor;
using UnityEngine;

public static class CSGenerater
{
    private static string modelViewName = "XUIView";
    private static string modelCtrlName = "XViewCtrl";

    public static void GenerateUIBaseCtrlCSFile(string pFilePath, ViewReference pViewRef, CtrlType pCtrlType)
    {
        var rootPath = Application.dataPath + "/" + UIDef.uiRootModel;
        var modeulFilepath = $"{rootPath}{modelCtrlName}.cs"; //Application.dataPath + "/ZFrameWork/Scripts/UI/Model/XPanelCtrl.cs";
        pFilePath = pFilePath.Replace("\\", "/");

        var filepath = Application.dataPath + "/" + UIDef.uiRootPanel + pFilePath + "Ctrl.cs";
        var fileName = filepath.Substring(filepath.LastIndexOf("/") + 1);
        fileName = fileName.Replace(".cs", "");
        //var releatePath = pFilePath.Replace("UI/Exts/", "");
        //releatePath = releatePath.Replace("Ctrl", "");
        if (File.Exists(filepath))
        {
            if (UnityEditor.EditorUtility.DisplayDialog("面板的LuaCtrl文件已经存在", "是否删除重新生成 ?", "确定", "取消"))
            {
                File.Delete(filepath);
                StartGeneralCtrlCS(pViewRef, modeulFilepath, fileName, filepath, pCtrlType);
            }
        }
        else
        {
            StartGeneralCtrlCS(pViewRef, modeulFilepath, fileName, filepath, pCtrlType);
        }
    }
    private static void StartGeneralCtrlCS(ViewReference pViewRef, string modeulFilepath, string fileName, string filepath, CtrlType pCtrlType)
    {
        var modeulContext = ReadModel(modeulFilepath);
        Debug.Log(fileName);
        modeulContext = modeulContext.Replace(modelCtrlName, fileName);
        //var assetPath = AssetDatabase.GetAssetPath(pComponent.gameObject);
        var assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(pViewRef.gameObject);
        switch (pCtrlType) {
            case CtrlType.SubCtrl:
                modeulContext = modeulContext.Replace("UICtrlPanel", "UICtrlSub");
                break;
            case CtrlType.ItemCtrl:
                modeulContext = modeulContext.Replace("UICtrlPanel", "UICtrlItem");
                break;
        }
        modeulContext = modeulContext.Replace("--respath--", assetPath);
        modeulContext = modeulContext.Replace("--resname--", pViewRef.gameObject.name);
        
        //fillviewinit
        var initViewContent = GetCSCtrlInitViewContent(pViewRef,out string oViewName);
        modeulContext = modeulContext.Replace("uiViewBase", oViewName.ToLower());
        //modeulContext = modeulContext.Replace("UIViewBase", oViewName);


        modeulContext = modeulContext.Replace("//fillviewinit", initViewContent);
        //filladdevents
        var addEventContent = GetCSCtrlAddEventsContent(pViewRef);
        modeulContext = modeulContext.Replace("//filladdevents", addEventContent);
        //fillremoveevents
        var removeEventContent = GetCSCtrlRemoveEventsContent(pViewRef);
        modeulContext = modeulContext.Replace("//fillremoveevents", removeEventContent);
        //fillevents
        var eventContent = GetCsCtrlEventContent(pViewRef);
        modeulContext = modeulContext.Replace("//fillevents", eventContent);
        WriteFile(filepath, modeulContext);
    }

    private static string GetCsCtrlEventContent(ViewReference pViewRef) {
        string result = "";
        var binds = pViewRef.binders;
        int addCount = 0;
        for (var i = 0; i < binds.Count; i++)
        {
            var eleBiner = binds[i];
            var comType = eleBiner.type;
            if (comType == ComponentType.Button)
            {
                if (addCount > 0)
                {
                    result += "\n";
                }
                var conet = "\tprivate void OnClick"+ eleBiner .key+ "(System.Object obj) \n\t{\n\t\t//TODO finish this event \n\t}";
                result += conet;
                addCount += 1;
            }
        }
        return result;
    }
    private static string GetCSCtrlRemoveEventsContent(ViewReference pViewRef)
    {
        string result = "";
        var binds = pViewRef.binders;
        int addCount = 0;
        for (var i = 0; i < binds.Count; i++)
        {
            var eleBiner = binds[i];
            var comType = eleBiner.type;
            if (comType == ComponentType.Button)
            {
                if (addCount > 0)
                {
                    result += "\n";
                }
                var conet = $"\t\tRemoveCtrlEvent(\"onClick{eleBiner.key}\", OnClick{eleBiner.key});";
                result += conet;
                addCount += 1;
            }
        }
        return result;
    }
    private static string GetCSCtrlAddEventsContent(ViewReference pViewRef)
    {
        string result = "";
        var binds = pViewRef.binders;
        int addCount = 0;
        for (var i = 0; i < binds.Count; i++)
        {
            var eleBiner = binds[i];
            var comType = eleBiner.type;
            if (comType == ComponentType.Button) {
                if (addCount > 0) {
                    result += "\n";
                }
                var conet = $"\t\tAddCtrlEvent(\"onClick{eleBiner.key}\", OnClick{eleBiner.key});";
                result += conet;
                addCount+=1;
            }
        }
        return result;
    }
    private static string GetCSCtrlInitViewContent(ViewReference pViewRef,out string oViewName) {
        var viewName = pViewRef.name;
        if (viewName.StartsWith("_")) {
            viewName = viewName.Substring(1, viewName.Length - 1);
        }
        oViewName = viewName;
        var lowerViewName = oViewName.ToLower();
        string reuslt = $"\t\t{lowerViewName} = new {viewName}();\n";
        reuslt += $"\t\t{lowerViewName}.SetViewReference(viewReference);\n";
        reuslt += $"\t\t{lowerViewName}.OnInit();\n";
        reuslt += $"\t\tSetUIViewBase({lowerViewName});";
        //uiViewBase.SetViewReference(viewReference);
        //uiViewBase.OnInit();
        //SetUIViewBase(uiViewBase);
        return reuslt;
    }
    
    public static void GenerateUIViewCSFile(string pFilePath, ViewReference pComponent)
    {
        var rootPath = Application.dataPath + "/"+UIDef.uiRootModel;
        var modeulFilepath = $"{rootPath}{modelViewName}.cs";
        pFilePath = pFilePath.Replace("\\", "/");
        var filepath = Application.dataPath + "/"+ UIDef.uiRootPanel + pFilePath + ".cs";
        var fileName = filepath.Substring(filepath.LastIndexOf("/") + 1);
        fileName = fileName.Replace(".cs", "");
        if (File.Exists(filepath)){
            if (UnityEditor.EditorUtility.DisplayDialog("面板的cs文件已经存在", "是否删除重新生成 ?", "确定", "取消")){
                File.Delete(filepath);
                StartGeneralCsFile(pComponent, modeulFilepath, fileName, filepath);
            }
        }
        else{
            StartGeneralCsFile(pComponent, modeulFilepath, fileName, filepath);
        }
    }
    private static void StartGeneralCsFile(ViewReference pViewRef, string modeulFilepath, string fileName, string filepath)
    {
        var modeulContext = ReadModel(modeulFilepath);
        Debug.Log(fileName);
        
        modeulContext = modeulContext.Replace(modelViewName, fileName);
        var csLoclString = GetCsLocalString(pViewRef);
        modeulContext = modeulContext.Replace("//Local Compnent", csLoclString);
        var csInitString = GetCsInitString(pViewRef);
        modeulContext = modeulContext.Replace("//Init Component", csInitString);
        var csForwardText = GetCsForwardString(pViewRef);
        modeulContext = modeulContext.Replace("//On Forward", csForwardText);
        WriteFile(filepath, modeulContext);
    }
    private static string GetCsForwardString(ViewReference pViewRef) {
        var result = "";
        var binds = pViewRef.binders;
        for (var i = 0; i < binds.Count; i++)
        {
            var eleBiner = binds[i];
            var comType = eleBiner.type;
            var compoentTypeInfo = UIDef.GetComponentTypeInfoByType(comType);
            var defaultValue = compoentTypeInfo.CompValue;
            if(comType == ComponentType.Text)
            {
                var textValue = eleBiner.go.GetComponent<UnityEngine.UI.Text>();
                defaultValue = $".text = \"{textValue.text}\"";
            }
            if (!defaultValue.IsNullOrEmpty()) {
                var conent = $"\t\tthis.{eleBiner.key}{defaultValue};";
                if (i < binds.Count - 1)
                {
                    conent += "\n";
                }
                result += conent;
            }
        }
        return result;
    }
    private static string GetCsLocalString(ViewReference pViewRef){
        var result = "";
        var binds = pViewRef.binders;
        for (var i = 0; i < binds.Count; i++) {
            var eleBiner = binds[i];
            var comType = eleBiner.type;
            var compoentTypeInfo = UIDef.GetComponentTypeInfoByType(comType);
            var csCom = compoentTypeInfo.CompSName;
            var conent = $"\tprivate {csCom} {eleBiner.key};";
            if (i < binds.Count - 1) {
                conent += "\n";
            }
            result += conent;
        }
        return result;
    }
    private static string GetCsInitString(ViewReference pViewRef) {
        var result = "";
        var binds = pViewRef.binders;
        for (var i = 0; i < binds.Count; i++)
        {
            var eleBiner = binds[i];
            var comType = eleBiner.type;
            var compoentTypeInfo = UIDef.GetComponentTypeInfoByType(comType);
            var csCom = compoentTypeInfo.CompSName;     
            var conent = $"\t\tthis.{eleBiner.key} = this.viewReference.binders[{i}].go.GetComponent<{csCom}>();";
            if (comType == ComponentType.Button)
            {
                conent += "\n";
                var clickEventMsg = $"onClick{eleBiner.key}";
                var CsComponentEx = "\t\tthis." + eleBiner.key + ".onClick.AddListener(() => { ctrlEvent.SendMessage(" + "\"" + clickEventMsg + "\"" + ", null); });";
                conent += CsComponentEx;
            }
            else if (comType == ComponentType.GameObject) {
                conent = $"\t\tthis.{eleBiner.key} = this.viewReference.binders[{i}].go;";
            }
            if(i < binds.Count-1){
                conent += "\n";
            }
            result += conent;
        }
        return result;
    }
    
    public static string ReadModel(string pFilePath)
    {
        StreamReader streamReader = new StreamReader(pFilePath, Encoding.UTF8);
        string context = streamReader.ReadToEnd();
        streamReader.Close();
        return context;
    }
    public static void WriteFile(string pFilePath, string pContext)
    {
        pFilePath.CreateDirectoryIfNotExists();
        FileStream fs = new FileStream(pFilePath, FileMode.Create, FileAccess.Write);//创建写入文件 
        StreamWriter streamWriter = new StreamWriter(fs);
        streamWriter.WriteLine(pContext);
        streamWriter.Close();
        fs.Close();
        UnityEditor.AssetDatabase.Refresh();
        Debug.Log(string.Format("File has created at path :------{0}.", pFilePath));
    }

}
#endif

上面都是框架层代码，后面会介绍使用实例

c#创建画布_添加项目到画布Unity C＃
weixin_42364391的博客
01-14 197
I am trying to add items to my Canvas dynamicly in C#.Here is what I am trying to dopublic class MyScript : MonoBehaviour{private List _buttons;private GameObject _canvas;public MyScript(){_buttons = ...
SpringMVC搭建框架
m0_68648030的博客
06-09 1517
MVC就是一个分层架构模式:springMVC它是spring框架的一个分支，该springMVC框架主要完成的功能是:==接收浏览器的请求响应，对数据进行处理，然后返回页面进行显示== 可以把它理解为和Servlet干的工作是一样的。.........
canvas实现pdf的展示与生成pdf
weixin_47359038的博客
04-27 6621
文章目录前言pdf.js引入项目使用构建包构建包的使用jsPDF 前言 这里主要使用到了两个库，pdf的展示是开源库pdf.js，和canvas结合使用；生成pdf的开源库是jsPDF。 pdf展示的demo: http://121.4.85.237/ pdf.js 这个开源库很牛的，详细内容看官网就行了，我这里就简单的贴一些例子和pdf.js的两种使用方式。 官网：https://github.com/mozilla/pdf.js 这个pdf.js还是有一个官网demo的可以玩一下。 http
Unity 读取本地文件夹图片
Liam's blog
04-10 7610
下面脚本实现的功能： 1.将本地图片（PNG和JPG）加载到UGUI上的Button的Image 2.用Scroll View组件自动排列 using System.Collections; using System.Collections.Generic; using UnityEngine; using System.IO; using UnityEngine.UI; public ...
Unity MVC框架的搭建和使用
weixin_43839583的博客
12-08 2036
什么是MVC MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中...
ASP.NET - MVC框架及搭建教程
热门推荐
u011555996的博客
12-17 1万+
一、MVC简介 MVC：Model-View-Controller（模型-视图-控制器），MVC是一种软件开发架构模式。 1、模型（Model） 模型对象是实现应用程序数据域逻辑的应用程序部件。通常，模型对象会检索模型状态并将其存储在数据库中。例如，Product对象可能会从数据库中检索信息，操作该信息，然后将更新的信息写回到数据库内的Product表中。 2、视图（View） 视图是显示应用程序用户界面(UI)的组件。通常，此UI是用模型数据创建的。Product表的编辑视图便...
Spring MVC 框架
whs_8792的博客
07-26 915
是一种用于。MVC模式通过将，使得应用程序的开发和维护变得更加容易。）：模型代表一个存取数据的对象或Java POJO（Plain Old Java Object），是业务逻辑的载体。模型拥有最多的处理任务，被模型返回的数据是中立的，与数据格式无关，因此一个模型能为多个视图提供数据。）：视图代表模型包含的数据的可视化，是用户看到并与之交互的界面。视图负责展示数据，但不包含业务逻辑。l）：控制器作用于模型和视图上，它控制数据流向模型对象，并在数据变化时更新视图。
ASP.Net MVC框架搭建
浩浩的博客
04-21 736
一.框架搭建的初衷： 1.平时工作就是敲代码，做了N多个项目，每上一个项目都要重新修改一些重复性的代码（这些代码完全可以省略，通过继承，反射等等的方式简化开发量）。 2.项目成员不固定，水平参差不齐，没有固定的规范，通过纯SQL的方式写数据库操作逻辑，代码量很大，让新的项目成员难于下手，导致各自为营，框架越来越臃肿。 3.C/S模式界面跟不上时代...
ASP.NET.cord的MVC的简单使用和EF框架搭建的
qq_66720214的博客
06-21 687
对于 C# 和 .NET 开发者来说，学习 Entity Framework 框架相对较容易，因为它是基于面向对象的概念构建的，与传统的关系型数据库构建集合的方式相比，它的学习曲线要平坦得多。总之，Entity Framework 框架是一种强大的 ORM 框架，它简化了与关系型数据库的交互，并提供了更高级别的抽象。在博客应用程序中，我们需要为博客创建一个控制器，使用户能够进行各种博客相关的操作，如查阅博客、添加博客、删除博客等。：这是指定要连接的 SQL Server 数据库的连接字符串。
Node.js VSMVC：快速搭建轻量级MVC应用框架
最新发布
weixin_34581040的博客
09-06 1350
本文还有配套的精品资源，点击获取 简介：Node.js VSMVC是一个专为JavaScript开发者设计的轻量级MVC（Model-View-Controller）框架，简化了在Node.js环境中构建Web应用程序的过程。其核心特性包括简洁易用、模块化设计、路由管理、中间件支持以及支持多种模板引擎。本框架适合初学者和有经验的开发者，可进行各种扩展，如集成第三方库、使用O...
C# MVC5框架搭建 MVC5+SQL数据库+KenDoUI
05-24
**C# MVC5框架搭建与应用** C# MVC5是一个基于.NET Framework的Web应用程序开发框架，它结合了Model-View-Controller（MVC）设计模式，提供了强大的开发工具和丰富的功能，适合构建可维护性和扩展性高的Web应用程序...
Spring+Spring MVC+Mybatis框架搭建
02-26
通过学习和实践这个SSM框架搭建项目，开发者可以深入理解这三个框架的使用方式和相互配合的机制，提升Java Web开发技能。同时，也可以根据项目需求，灵活调整和扩展框架配置，实现更复杂的应用场景。
MVC原生框架一步步搭建
06-02
下面我们将详细探讨如何一步步搭建基于PHP的MVC原生框架。 1. **理解MVC模式** - Model：模型层，负责处理业务逻辑和数据操作，通常与数据库交互。 - View：视图层，展示给用户看到的页面内容。 - Controller：...
Spring MVC 框架搭建及详解
09-14
Spring MVC 是一个强大的Java Web应用程序开发框架，它提供了一个模型-视图-控制器（MVC）架构，使得开发者可以将业务逻辑、数据处理和用户界面分离，提高代码的可维护性和可扩展性。Spring MVC 是Spring框架的重要...
ASP.NET 之 MVC框架及搭建教程(推荐)
10-18
ASP.NET MVC框架是一种用于构建动态网站的开源框架，它基于模型-视图-控制器（MVC）设计模式，为开发者提供了高效且灵活的开发环境。本文将深入介绍MVC的基本概念，探讨其优缺点，并逐步指导如何搭建一个ASP.NET MVC...
unity Mirror使用心得一（玩家角色创建，控制，及其攻击其他玩家的血量同步设置）
MoonWinding的博客
11-25 5967
先分享下个人mirrordemo 的github : https://github.com/IsaWinding/MirrorDemo.git mirror 的官方下载地址： https://assetstore.unity.com/packages/tools/network/mirror-129321 1.添加NetworkManager 2.添加NetworkMangerHud 3.制作玩家角色预制体并添加mirror 相关组件 networkTransform 和networkAnimator
unity Mirror使用心得二（服务器端的怪物创建，及其怪物AI的行为）
MoonWinding的博客
11-25 5188
1.怪物必须由服务器创建： 创建代码： using Mirror; using System.Collections; using System.Collections.Generic; using UnityEngine; public class MonsterCreater : NetworkBehaviour { public Vector3 Pos; public GameObject projectilePrefab; private NetworkIdentity i
Unity MlAgent 使用介绍
MoonWinding的博客
12-14 3365
分享github 工程：https://github.com/IsaWinding/mlagent02.git 1.本文介绍要一个战斗中，英雄Ai行为操作用MlAgent来训练操作 图中为英雄训练的次数，生成的不同.onnx 文件。 训练次数较少的时候，训练的英雄会随机在周围的墙边移动 随着训练次数变多，训练的英雄会直接奔向敌方小兵的位置，进行攻击操作。 英雄行为脚本： using System.Collections; using System.Collections.Generic; using U
unity Addressable系统及其Xlua脚本热更新全过程详细解析（-）
MoonWinding的博客
12-03 2188
1.本来关于Addressable 的文章已经写了2篇了，但对这个addressable系统有些地方还是不清楚怎么用，这次就用来记录一下结合xlua 实现资源和代码的全更新方案。 列取一下一开始遇到的问题： 1.xlua 开发的时候我们用的都是.lua 文件，这个是unity 无法识别的文件这个要怎么解决？ 2.xlua 读取文件的bytes 都是同步读取方式，最新的addressable 很多的同步读取方式都已经弃用。怎么解决这个同步读取问题？ 带着这些问题，下面介绍我提供的解决方案。 分享一下个人Dem
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值