上一节我们写了一个简单的引用池，而单一的引用池是没有啥作用的，事件池就是引用池的作用之一
我们当然可以把事件定义在模块的内部，比如把一个打开UI的事件定义在UI模块内，但是随着我们模块的不断增多，如果所有事件都定义在自己的模块内，在后期是很难维护的，我们都不知道一共定义了哪些事件…因此，一个全局的事件管理中心，是很有必要的
事件池
事件池是实际上保存事件的地方，可以添加或者取消订阅事件。
在此之前，我希望我们的委托遵循.NET规范，即应该是如下格式
public delegate void TestEventHandler(Object sender, EventArgs e);其中sender是事件的发送者，而e则是发送的数据
发送者自然是之后会写到的事件管理器，而这里的数据类型我们需要自定义，提供一个统一的基类
/// 所有事件的基类，会被引用池管理
public abstract class GlobalEventArgs:IReference
{
public abstract int Id { get; set; }
public abstract void Clear();
}其中ID代表事件类型，不同类型的事件需要有不同的ID。Clear()方法属于IReference，我们会发现这个数据类型继承自引用接口，这说明什么？说明事件池传递的参数，是被引用池管理的！这就是引用池的作用之一，如果没有引用池，那每一次事件的调用我们都需要主动的new一个类型。
接着写好基本的事件池框架
public class EventPool<T> where T : GlobalEventArgs
{
#region Private
/// 事件编码与对应的处理方法，这里的key，就是我们注册在事件数据里的ID，EventHandler<T>是一个(Object,T)类型的委托
private Dictionary<int, EventHandler<T>> m_EventHandlers;
#endregion
#region 构造方法
public EventPool()
{
m_EventHandlers = new Dictionary<int, EventHandler<T>>();
}
#endregion
}接口方法，添加订阅与取消订阅
public class EventPool<T> where T : GlobalEventArgs
{
#region Public 接口方法
/// 订阅事件
public void Subscribe(int id, EventHandler<T> handler)
{
if (handler == null)
{
throw new Exception("事件处理方法为空，无法订阅...");
}
EventHandler<T> eventHandler = null;
// 检查是否获取处理方法失败或获取到的为空
if (!m_EventHandlers.TryGetValue(id, out eventHandler) || eventHandler == null)
{
m_EventHandlers[id] = handler;
}
// 不为空，就检查处理方法是否重复了
else if (Check(id, handler))
{
Debug.LogError("ID为:" + (SGFEvents)id + "的事件下已存在这个处理方法:" + nameof(handler) + "...");
}
else
{
eventHandler += handler;
m_EventHandlers[id] = eventHandler;
}
}
/// 取消订阅事件
public void Unsubscribe(int id, EventHandler<T> handler)
{
if (handler == null)
{
throw new Exception("事件处理方法为空，无法取消订阅...");
}
if (m_EventHandlers.ContainsKey(id))
{
m_EventHandlers[id] -= handler;
}
}
/// 抛出事件（线程不安全），抛出之后会立刻执行
public void FireNow(object sender, T e)
{
HandleEvent(sender, e);
}
#endregion
#region Private 工具方法
/// 检查某个编码的事件是否存在它对应的处理方法
private bool Check(int id, EventHandler<T> handler)
{
if (handler == null)
{
throw new Exception("事件处理方法为空...");
}
EventHandler<T> handlers = null;
if (!m_EventHandlers.TryGetValue(id, out handlers))
{
return false;
}
if (handlers == null)
{
return false;
}
// 遍历委托里的所有方法
foreach (EventHandler<T> i in handlers.GetInvocationList())
{
if (i == handler)
{
return true;
}
}
return false;
}
/// 事件处理
private void HandleEvent(object sender, T e)
{
// 尝试获取事件的处理方法
int eventId = e.Id;
EventHandler<T> handlers = null;
if (m_EventHandlers.TryGetValue(eventId, out handlers))
{
if (handlers != null)
{
handlers(sender, e);
}
else
{
throw new Exception("事件没有对应处理方法：" + eventId);
}
}
}
#endregion
}到此为止大体上的内容就已经完成了，我们来写我们的事件管理器
事件管理器
其实事件管理器就是对事件池的一个代理罢了
public class EventManager : ManagerBase
{
#region Private
/// 事件池，维护一个事件池，其实事件管理器就是对事件池的代理
private EventPool<GlobalEventArgs> m_EventPool;
#endregion
#region 构造方法
public EventManager()
{
m_EventPool = new EventPool<GlobalEventArgs>();
}
#endregion
#region Override
public override int Priority
{
get { return ManagerPriority.EventManager.GetHashCode(); }
}
#endregion
#region Public 接口方法
/// 订阅事件
public void Subscribe(SGFEvents id, EventHandler<GlobalEventArgs> handler)
{
// =========== 这一部分是用于DEBUG的，会在Hierachy中显示出当前的引用状态 ==========
#if UNITY_EDITOR
var trans = SGFEntry.Instance.transform.Find("EventManager");
var name = id.ToString();
var temp = trans.Find(name);
if (temp == null)
{
GameObject go = new GameObject();
go.name = name;
go.transform.SetParent(trans);
GameObject go2 = new GameObject();
go2.name = $"{handler.Target}：{handler.Method.Name}";
go2.transform.SetParent(go.transform);
}
else
{
GameObject go2 = new GameObject();
go2.name = $"{handler.Target}：{handler.Method.Name}";
go2.transform.SetParent(temp.transform);
}
#endif
// =========================================================================
m_EventPool.Subscribe(id.GetHashCode(), handler);
}
/// 取消订阅事件
public void Unsubscribe(SGFEvents id, EventHandler<GlobalEventArgs> handler)
{
m_EventPool.Unsubscribe(id.GetHashCode(), handler);
// =========== 这一部分是用于DEBUG的，会在Hierachy中显示出当前的引用状态 ==========
#if UNITY_EDITOR
var trans = SGFEntry.Instance.transform.Find("EventManager");
var group = trans.Find(id.ToString());
var child = group.Find($"{handler.Target}：{handler.Method.Name}");
if (child != null)
{
GameObject.DestroyImmediate(child.gameObject);
}
if (group.childCount <= 0)
{
GameObject.DestroyImmediate(group.gameObject);
}
#endif
// =========================================================================
}
/// 抛出事件（线程不安全）
public void FireNow(object sender, GlobalEventArgs e)
{
m_EventPool.FireNow(sender, e);
}
#endregion
}完全都是在调用事件池中的方法，单纯只是一个代理类而已
好了让我们先来测试一下，以打开UI为例，首先我们需要有一个打开UI的数据类型，且必须继承自GolbalEventArgs
public class UIOpenEventArgs : GlobalEventArgs
{
/// UI的名字，所有的UI都会注册这个事件，则需要靠名称来确定当前到底打开了哪一个UI
public string uiName;
public string data;
/// 这个ID是事件的ID，会根据事件ID找到相应的处理方法
public override int Id
{
get
{
return SGFEvents.OpenUI.GetHashCode();
}
set { }
}
/// 归还引用后清空数据
public override void Clear()
{
Id = UIRegister.None.GetHashCode();
uiName = string.Empty;
data = string.Empty;
}
}然后让我们在UI中注册这个事件，打开UI这个事件应该是所有UI都需要的，所以我们直接在UIBase中注册
在此之前，为了事件方便管理，我们把所有事件的ID注册到一个类中
/// 注册所有事件的事件编码
public enum SGFEvents
{
/*================== UI相关 =================*/
OpenUI,
}更新UIBase
public abstract class UIBase : MonoBehaviour
{
#region Field
/// 事件管理器
private EventManager eventManager;
/// UI的名字，不可重复
public string uiName;
#endregion
#region MonoBehaviour
private void Awake()
{
eventManager = SGFEntry.Instance.GetManager<EventManager>();
eventManager.Subscribe(SGFEvents.OpenUI,AfterShow);
Load();
}
private void OnDestroy()
{
eventManager.Unsubscribe(SGFEvents.OpenUI,AfterShow);
UnLoad();
}
#endregion
#region 工具方法
private void AfterShow(object o, GlobalEventArgs e)
{
var temp = e as UIOpenEventArgs;
if (!temp.uiName.Equals(uiName))
{
return;
}
DoAfterShow(o,temp);
}
#endregion
#region 事件
/// <summary>
/// 会在这个UI显示后调用
/// </summary>
public virtual void DoAfterShow(object o, UIOpenEventArgs e)
{
}
#endregion
}更新UIManager
public class UIManager : ManagerBase
{
#region Field
/// 事件管理器
private EventManager eventManager;
/// 引用池
private ReferenceManager referenceManager;
#endregion
#region 管理器生命周期
public override void Init()
{
//...
// 初始化管理器
eventManager = SGFEntry.Instance.GetManager<EventManager>();
referenceManager = SGFEntry.Instance.GetManager<ReferenceManager>();
}
#endregion
#region 接口方法
/// <summary>
/// 打开一个UI
/// </summary>
public void Open(UIStruct data, UIOpenEventArgs uiOpenEventArgs)
{
// 如果这个UI还没被加载，那需要先加载
if (!uiLoaded.TryGetValue(data.name,out var ui))
{
LoadUI(data,out ui);
}
// 显示UI
ShowUI(ui);
// 发送打开UI事件
uiOpenEventArgs.uiName = ui.uiName;
eventManager.FireNow(this,uiOpenEventArgs);
}
#endregion
}以Fixed1这个UI为例
public class Fixed1 : UIBase
{
public override void DoAfterShow(object o, UIOpenEventArgs e)
{
Debug.Log(e.data);
}
}public class test : MonoBehaviour
{
private ReferenceManager referenceManager;
void Start()
{
referenceManager = SGFEntry.Instance.GetManager<ReferenceManager>();
var tempRef = referenceManager.Acquire<UIOpenEventArgs>();
tempRef.data = "测试：打开UI的事件！";
SGFEntry.Instance.GetManager<UIManager>().Open(UIs.Fixed1, tempRef);
}
}
大体上算是完成了，但会有一些细节可能会影响大家的需求，在我这里，我把所有的打开UI归类为一个委托，不关我打开A还是打开B还是打开C，所有注册了这个事件的页面，都会被执行，所以如果大家只想当前最新打开的页面执行委托，那么在重写DoAfterShow方法时，需要进行额外的判断，根据传入的数据来判断是不是当前页面。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
