Unity客户端框架设计：UI管理系统的构建

在Unity客户端框架设计中，UI管理系统的构建是至关重要的部分。一个好的UI框架可以有效解决UI页面的打开、关闭、层级管理和页面跳转等问题，并将这些操作集中管理，从而简化开发流程，提高开发效率。

### UI管理系统的核心特点

1. **集中管理**：所有UI页面的打开、关闭、层级管理和页面跳转等操作都由UIManager统一管理，确保外部切换逻辑的一致性和可靠性。
2. **功能逻辑分散化**：每个UI页面维护自身的逻辑，依托于框架进行开发，开发者无需关心具体的跳转和显示关闭细节，便于多人协同开发。
3. **代码复用和经验沉淀**：通用性框架能够做到简单的代码复用，积累项目经验，提升开发效率。
4. **兼容多种UI工具**：该框架不仅适用于NGUI和UGUI，还可以扩展到其他UI工具。

### BaseUI类的设计

BaseUI类是UI页面的基础类，提供了缓存、状态管理和事件触发等功能。以下是BaseUI类的主要代码示例：

```csharp
public abstract class BaseUI : MonoBehaviour
{
private Transform _CachedTransform;
public Transform cachedTransform
{
get
{
if (_CachedTransform == null)
_CachedTransform = this.transform;
return _CachedTransform;
}
}

private GameObject _CachedGameobject;
public GameObject cachedGameobject
{
get
{
if (_CachedGameobject == null)
_CachedGameobject = this.gameObject;
return _CachedGameobject;
}
}

protected EnumObjectState state = EnumObjectState.None;
public event StateChangedEvent StateChanged;

public EnumObjectState State
{
get { return this.state; }
set
{
if (value != state)
{
EnumObjectState oldState = value;
state = value;
if (StateChanged != null)
StateChanged(this, state, oldState);
}
}
}

public abstract EnumUIType GetUIType();

public virtual void SetDepthToTop() { }

void Start()
{
OnStart();
}

void Awake()
{
this.State = EnumObjectState.Initial;
OnAwake();
}

void Update()
{
if (EnumObjectState.Ready == State)
OnUpdate(Time.deltaTime);
}

public void Release()
{
this.State = EnumObjectState.Closing;
ObjPool.Instance.OnReturnObj(cachedGameobject);
OnRelease();
}

protected virtual void OnStart() { }
protected virtual void OnAwake()
{
this.State = EnumObjectState.Loading;
this.OnPlayOpenUIAudio();
}

protected virtual void OnUpdate(float deltaTime) { }
protected virtual void OnRelease()
{
this.OnPlayCloseUIAudio();
}

protected virtual void OnPlayOpenUIAudio() { }
protected virtual void OnPlayCloseUIAudio() { }

protected virtual void SetUI(params object[] uiParams)
{
this.State = EnumObjectState.Loading;
}

protected virtual void OnLoadData() { }

public void SetUIWhenOpening(params object[] uiParams)
{
SetUI(uiParams);
CoroutineInstance.Instance.StartCoroutine(AsyncOnLoadData());
}

private IEnumerator AsyncOnLoadData()
{
yield return new WaitForSeconds(0);
if (this.State == EnumObjectState.Loading)
{
this.OnLoadData();
this.State = EnumObjectState.Ready;
}
}
}
```

### UIManager类的设计

UIManager类负责UI页面的加载、预加载、打开和关闭等操作。以下是UIManager类的主要代码示例：

```csharp
public class UIManager : Singleton
{
private Dictionary dicOpenedUIs = null;
private Stack stackOpeningUIs = null;

public override void Init()
{
dicOpenedUIs = new Dictionary();
stackOpeningUIs = new Stack();
}

public T GetUI(EnumUIType type) where T : BaseUI
{
GameObject retObj = GetUIObject(type);
if (retObj != null)
return retObj.GetComponent();
return null;
}

public GameObject GetUIObject(EnumUIType type)
{
if (!dicOpenedUIs.TryGetValue(type, out GameObject retObj))
throw new Exception("dicOpenedUIs TryGetValue Failure! _uiType :" + type.ToString());
return retObj;
}

public void PreloadUI(EnumUIType[] uiTypes)
{
foreach (var uiType in uiTypes)
PreloadUI(uiType);
}

public void PreloadUI(EnumUIType uiType)
{
string path = UIPathDefines.UI_PREFAB + uiType.ToString();
ResManager.Instance.Load(path);
}

public void OpenUI(EnumUIType[] uiTypes)
{
OpenUI(false, uiTypes, null);
}

public void OpenUI(EnumUIType uiType, params object[] uiObjParams)
{
OpenUI(false, new[] { uiType }, uiObjParams);
}

public void OpenUICloseOthers(EnumUIType[] uiTypes)
{
OpenUI(true, uiTypes, null);
}

public void OpenUICloseOthers(EnumUIType uiType, params object[] uiObjParams)
{
OpenUI(true, new[] { uiType }, uiObjParams);
}

private void OpenUI(bool isCloseOthers, EnumUIType[] uiTypes, params object[] uiParams)
{
if (isCloseOthers)
CloseUIAll();

foreach (var uiType in uiTypes)
{
if (!dicOpenedUIs.ContainsKey(uiType))
stackOpeningUIs.Push(new UIInfoData(uiType, UIPathDefines.UI_PREFAB + uiType.ToString(), uiParams));
}

if (stackOpeningUIs.Count > 0)
CoroutineInstance.Instance.StartCoroutine(AsyncLoadData());
}

private IEnumerator AsyncLoadData()
{
while (stackOpeningUIs.Count > 0)
{
var uiInfoData = stackOpeningUIs.Pop();
var prefabObj = ObjPool.Instance.OnGetObj(uiInfoData.Path.Split('/')[1], uiInfoData.Path.Split('/')[0]);
prefabObj.transform.SetParent(null);

if (prefabObj != null)
{
var baseUI = prefabObj.GetComponent();
if (baseUI == null)
baseUI = prefabObj.AddComponent(uiInfoData.ScriptType) as BaseUI;

if (baseUI != null)
baseUI.SetUIWhenOpening(uiInfoData.UIParams);

dicOpenedUIs.Add(uiInfoData.UIType, prefabObj);
}
}
yield return 0;
}

public void CloseUI(EnumUIType uiType)
{
if (dicOpenedUIs.TryGetValue(uiType, out GameObject uiObj))
CloseUI(uiType, uiObj);
}

public void CloseUI(EnumUIType[] uiTypes)
{
foreach (var uiType in uiTypes)
CloseUI(uiType);
}

public void CloseUIAll()
{
foreach (var uiType in new List(dicOpenedUIs.Keys))
CloseUI(uiType, dicOpenedUIs[uiType]);

dicOpenedUIs.Clear();
}

private void CloseUI(EnumUIType uiType, GameObject uiObj)
{
if (uiObj == null)
dicOpenedUIs.Remove(uiType);
else
{
var baseUI = uiObj.GetComponent();
if (baseUI != null)
{
baseUI.StateChanged += CloseUIHandler;
baseUI.Release();
}
else
{
GameObject.Destroy(uiObj);
dicOpenedUIs.Remove(uiType);
}
}
}

private void CloseUIHandler(object sender, EnumObjectState newState, EnumObjectState oldState)
{
if (newState == EnumObjectState.Closing)
{
var baseUI = sender as BaseUI;
dicOpenedUIs.Remove(baseUI.GetUIType());
baseUI.StateChanged -= CloseUIHandler;
}
}
}
```

### 枚举与静态类

为了更好地管理和定义UI类型及路径，我们使用了枚举和静态类。以下是相关代码示例：

```csharp
namespace TownsFramework
{
public delegate void StateChangedEvent(object sender, EnumObjectState n, EnumObjectState o);

public enum EnumObjectState
{
None,
Initial,
Loading,
Ready,
Disabled,
Closing
}

public enum EnumUIType : int
{
NOne= -1,
StartUI,
WarUI
}

public static class UIPathDefines
{
public const string UI_PREFAB = "UIPrefab/";
public const string UI_CONTROLS_PREFAB = "UIPrefab/Control/";
public const string UI_SUBUI_PREFAB = "UIPrefab/SubUI/";
public const string UI_ICON = "UI/Icon";

public static System.Type GetUIScriptByType(EnumUIType type)
{
switch (type)
{
case EnumUIType.StartUI:
return typeof(StratUI);
case EnumUIType.WarUI:
return typeof(WarUI);
default:
Debug.Log("No This UIType : " + type.ToString());
break;
}
return null;
}
}
}
```

以上代码展示了如何构建一个高效且易于扩展的UI管理系统，帮助开发者更轻松地管理复杂的UI逻辑。