基于UGUI的框架

这个框架简单易懂，上手就可以直接拿来用，主要是单例管理类，界面和界面之间的互相交流通过单例去实现，个人感觉不是很好，但是我特别喜欢他的管理层级非常分明。

之后会发一个广播机制，结合上这套UI框架，但是本文主要是讲这个框架，所以后话就后话说吧，话不多说上代码

（一）UImanager：

以panel为编程单位，储存管理panel和下级控件，向外提供接口方法，接收界面和控件主动往管理类里注册，排查是否重复注册以及最后销毁等

注意：我在使用的时候发现还是有很多需要注意的问题的

1、UIManager必须游戏启动第一时间启动，整个游戏进程中不能销毁的，可以给个空物体，然后dontdestory，再动态addcompnent加入

2、整个框架主体分为三个脚本，执行顺序为 UIManager > UIBase > UIBehaviour,我在第一使用的时候发现，只要一加载界面就会报空，百思不其解，然后层层断点发现执行顺序的问题，UIBehaivour先执行了，导致找不到UIManager往里注册，有点坑

3、因为字典存的是界面name，控件name，控件对象，在RegistGameObject函数中会进行一次筛选，key不能相同，也就意味着界面名字不能重复，同界面的控件名字不能重复，我在做交易列表时被这个搞得头疼，一定要注意，加载完换个名字

 using System.Collections.Generic;
 using UnityEngine;

 public class UIManager : MonoBehaviour
 {
     Dictionary<string, Dictionary<string, GameObject>> allChild;
     public static UIManager Instance;

     private GameObject mainCanvas;
     public GameObject MainCanvas
     {
         get
         {
             if (mainCanvas == null)
             {
                 mainCanvas = GameObject.FindGameObjectWithTag("MainCanvas");
             }
             return mainCanvas;
         }
     }

     public GameObject InstantiateUIPanelGameObject(string path, string endWithName = "", Transform parent = null)
     {
         if (parent == null)
         {
             parent = MainCanvas.transform;
         }
         GameObject tmpGameObj = Instantiate(Resources.Load<GameObject>(path));
         tmpGameObj.name = tmpGameObj.name.Replace("(Clone)", endWithName);
         tmpGameObj.transform.SetParent(parent,false);
         return tmpGameObj;
     }

     void Awake()
     {
         allChild = new Dictionary<string, Dictionary<string, GameObject>>();
         Instance = this;
     }

     /// <summary>
     /// 可以拿到字典中已经注册过的panel下的控件
     /// </summary>
     /// <param name="panelName"></param>
     /// <param name="widgeNmae"></param>
     /// <returns></returns>
     public GameObject GetGameObject(string panelName, string widgeNmae)
     {
         if (allChild.ContainsKey(panelName))
         {
             return allChild[panelName][widgeNmae];
         }
         return null;
     }

     /// <summary>
     /// 反注册，当你确定不再需要这个界面的时候，没必要浪费空间
     /// </summary>
     /// <param name="panelName"></param>
     /// <param name="widgeName"></param>
     public void UnRegistGameObject(string panelName, string widgeName)
     {
         if (allChild.ContainsKey(panelName))
         {
             if (allChild.ContainsKey(widgeName))
             {
                 allChild[panelName].Remove(widgeName);
             }
         }
     }

     /// <summary>
     /// 销毁某个panel上所有控件
     /// </summary>
     /// <param name="panelName"></param>
     public void DestroyAllWidgeFormPanel(string panelName)
     {
         if (allChild.ContainsKey(panelName))
         {
             if (allChild[panelName] != null)
             {
                 allChild[panelName].Clear();
             }
         }
     }

     /// <summary>
     /// 供UIBehaviour调用，UIBehaviour每个控件都会动态挂载，并且在awake里面调用，注册自己
     /// </summary>
     /// <param name="panelName"></param>
     /// <param name="widgeName"></param>
     /// <param name="widge"></param>
     public void RegistGameObject(string panelName, string widgeName, GameObject widge)
     {
         if (!allChild.ContainsKey(panelName))
         {
             allChild.Add(panelName, new Dictionary<string, GameObject>());
         }

         if (!allChild[panelName].ContainsKey(widgeName))
         {
             allChild[panelName].Add(widgeName, widge);
         }
         else
         {
             Debug.LogError(" has been registed => " + widgeName);
         }
     }

     public void CleanDic()
     {
         allChild.Clear();
     }
 }

（二）UIBase：

这是一个供界面脚本继承的基类，前面也说次框架是以panel为编程单位的，这也就是说只要你想用这套框架，只需要在panel上挂载自己写的脚本去控制底下的所有控件即可，但是这个脚本必须继承UIBase

这里又存在一个硬性条件，那就是panel下，你所要写功能的控件，对象名的结尾必须_N，这是为了动态挂脚本UIBehaivour，我想这是为了让预设体或者AB尽量减少依赖吧

在UIBase里存着panel下所有的控件，不用再去find了，避免低效，同时在UIBase里对各种控件的回调进行了二次封装，直接调用传参就行，这点我很喜欢，简单粗暴

如果有需要，也可以自己拓展封装，底层回调在UIBehaivour封装，UIBase进行二次封装

 using UnityEngine;
 using UnityEngine.Events;
 using UnityEngine.EventSystems;
 using UnityEngine.UI;

 public class UIBase : MonoBehaviour
 {
     public Transform[] allChild;

     private void Awake()
     {
         // 将所有的子控件 获取到。
         allChild = gameObject.GetComponentsInChildren<Transform>();
         for (int i = ; i < allChild.Length; i++)
         {
             //以名字区别控件，动态挂载脚本，所以必须按规范命名
             if (allChild[i].name.EndsWith("_N"))
             {
                 allChild[i].gameObject.AddComponent<UIBehaviour>();
             }
         }
     }

     public virtual void OnDestroy()
     {
         UIManagerLen.Instance.DestroyAllWidgeFormPanel(transform.name);
     }

     /// <summary>
     ///  从UIManager里面拿子控件
     /// </summary>
     /// <param name="widgaeName"></param>
     /// <returns></returns>
     public GameObject GetGameObject(string widgaeName)
     {
         return UIManagerLen.Instance.GetGameObject(transform.name, widgaeName);
     }

     /// <summary>
     /// 为了拿到底层封装
     /// </summary>
     /// <param name="widgaeName"></param>
     /// <returns></returns>
     public UIBehaviour GetBehavour(string widgaeName)
     {
         // 找对象
         GameObject tmpBtn = GetGameObject(widgaeName);
         if (tmpBtn)
         {
             // 拿到 UIBehavour
             UIBehaviour behavour = tmpBtn.GetComponent<UIBehaviour>();
             return behavour;
         }
         return null;
     }

     /// <summary>
     /// button
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddButtonListen(string widageName, UnityAction action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.AddButtonListener(action);
         }
     }

     /// <summary>
     /// slider
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddSliderListen(string widageName, UnityAction<float> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.AddSliderListen(action);
         }
     }

     /// <summary>
     /// scroll view
     /// </summary>
     /// <param name="cellName"></param>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddScrollListen(string widageName, UnityAction<Vector2> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.AddScrollListen(action);
         }
     }

     /// <summary>
     /// dropdown
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddDropDownListen(string widageName, UnityAction<int> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.AddDropDownListen(action);
         }
     }

     /// <summary>
     /// toggle
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddToggleListen(string widageName, UnityAction<bool> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.AddToggleListener(action);
         }
     }

     /// <summary>
     /// inputfiled
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddInputListen(string widageName, UnityAction<string> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.AddInputEndListen(action);
         }
     }

     /// <summary>
     /// 文本赋值
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="value"></param>
     public void ChangeText(string widageName, string value)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             //绑定事件
             behavour.ChangeText(value);
         }
     }

     /// <summary>
     /// 图片点击
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddPointClick(string widageName, UnityAction<BaseEventData> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             behavour.AddInterfaceLisenter(EventTriggerType.PointerClick, action);
         }
     }

     /// <summary>
     /// 图片拖拽 开始，正在拖，结束
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="action"></param>
     public void AddBeginDrag(string widageName, UnityAction<BaseEventData> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             behavour.AddInterfaceLisenter(EventTriggerType.BeginDrag, action);
         }
     }
     public void AddOnDrag(string widageName, UnityAction<BaseEventData> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             behavour.AddInterfaceLisenter(EventTriggerType.Drag, action);
         }
     }
     public void AddEndDrag(string widageName, UnityAction<BaseEventData> action)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             behavour.AddInterfaceLisenter(EventTriggerType.EndDrag, action);
         }
     }

     /// <summary>
     /// 更换图片
     /// </summary>
     /// <param name="widageName"></param>
     /// <param name="value"></param>
     public void SetImage(string widageName, Sprite value)
     {
         UIBehaviour subManager = GetBehavour(widageName);
         if (subManager)
         {
             subManager.GetComponent<Image>().sprite = value;
         }
     }

     /// <summary>
     /// 获取图片
     /// </summary>
     /// <param name="widageName"></param>
     /// <returns></returns>
     public Image GetImage(string widageName)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             return behavour.GetImage();
         }
         return null;
     }

     /// <summary>
     /// 拿到text组件的值
     /// </summary>
     /// <param name="widageName"></param>
     /// <returns></returns>
     public string GetText(string widageName)
     {
         UIBehaviour behavour = GetBehavour(widageName);
         if (behavour)
         {
             return behavour.GetText();
         }
         return null;
     }
 }

（三）UIBehaivour：

这个脚本就是动态挂载各个控件上的脚本，作用只有两个

1、向UIManager注册，接受管理

2、底层回调封装，供UIBase调用从而进行二次封装后直接使用  如果需要拓展也是从这里开始

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

 public class UIBehaviour : MonoBehaviour
 {
     UIBase tmpBase;
     private void Awake()
     {
         tmpBase = gameObject.GetComponentInParent<UIBase>();//找到父类，也就是panel

         UIManagerLen.Instance.RegistGameObject(tmpBase.name, transform.name, gameObject);//向管理类注册自己
     }

     private void OnDestroy()
     {
         UIManagerLen.Instance.UnRegistGameObject(tmpBase.name, gameObject.name);
     }

     #region UGUI各种控件的回调封装
     public void AddButtonListener(UnityAction action)//按钮回调封装
     {
         Button tmpBtn = gameObject.GetComponent<Button>();
         if (tmpBtn) tmpBtn.onClick.AddListener(action);
     }
     public void AddSliderListen(UnityAction<float> action)//滚动条回调封装
     {
         Slider tmpBtn = gameObject.GetComponent<Slider>();
         if (tmpBtn) tmpBtn.onValueChanged.AddListener(action);
     }
     public void AddDropDownListen(UnityAction<int> action)//下拉框回调封装
     {
         Dropdown tmpBtn = gameObject.GetComponent<Dropdown>();
         if (tmpBtn) tmpBtn.onValueChanged.AddListener(action);
     }
     public void AddScrollListen(UnityAction<Vector2> action)//滚动框回调封装
     {
         ScrollRect tmpBtn = gameObject.GetComponent<ScrollRect>();
         if (tmpBtn) tmpBtn.onValueChanged.AddListener(action);
     }
     public void AddToggleListener(UnityAction<bool> action)
     {
         Toggle tmpToggle = gameObject.GetComponent<Toggle>();
         if (tmpToggle) tmpToggle.onValueChanged.AddListener(action);
     }
     public void AddInputEndListen(UnityAction<string> action)//输入框回调封装
     {
         InputField tmpBtn = GetComponent<InputField>();
         if (tmpBtn) tmpBtn.onEndEdit.AddListener(action);
     }
     public void ChangeText(string value)//改变文本的接口
     {
         Text tmpBtn = gameObject.GetComponent<Text>();
         if (tmpBtn) tmpBtn.text = value;
     }
     public Image GetImage()//如果控件是图片，提供获取图片的接口
     {
         Image tmpBtn = gameObject.GetComponent<Image>();
         return tmpBtn;
     }
     public string GetText()//如果控件是文本，提供获取文本的接口
     {
         Text tmpBtn = gameObject.GetComponent<Text>();
         return tmpBtn.text;
     }
     #endregion

     /// <summary>
     /// 用代码动态添加接口事件
     /// </summary>
     /// <param name="action"></param>
     public void AddInterfaceLisenter(EventTriggerType triger, UnityAction<BaseEventData> action)
     {

         EventTrigger trigger = gameObject.GetComponent<EventTrigger>();

         if (trigger == null)
             trigger = gameObject.AddComponent<EventTrigger>();

         EventTrigger.Entry entry = new EventTrigger.Entry();
         //绑定哪个接口
         entry.eventID = triger;

         entry.callback = new EventTrigger.TriggerEvent();

         entry.callback.AddListener(action);

         trigger.triggers.Add(entry);
     }
 }

(四)使用：

继承，调用就行了，简单示例一下

总结：

这个框架有优点，也有缺点

优点是层级管理分明，分工明确，封装之后调用简单方便

缺点界面和界面的交流，以及模块和模块之间的交流，耦合性还是不能很好的解决

有时间会写一套广播机制，配合着使用，已达到尽可能解耦的效果