Unity事件的监听与广播系统（高度解耦合）

视频地址
http://www.sikiedu.com/my/course/304
平常我们写的一些脚本

image.png

比如点击btn然后显示文本或者改变文本文字 一般我们都在Find到或者public把他们关联到一起 这样相互之间的调用会有很高的耦合性
用事件广播监听的话可以做到每个类关联性不那么强 各做各的职责 监听者不用管广播者是谁 广播者不用管监听者是谁

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
/// <summary>
/// 注册码
/// </summary>
public enum eEventType
{
    ShowText=0,
}

/// <summary>
/// 事件管理
/// </summary>
public class EventCenter
{
    static Dictionary<eEventType, Delegate> m_EventTable = new Dictionary<eEventType, Delegate>();
    /// <summary>
    /// 无参添加监听的方法
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void AddListener(eEventType eventType, CallBack callBack)
    {
        if (!m_EventTable.ContainsKey(eventType))
        {
            m_EventTable.Add(eventType, null);
        }
        Delegate d = m_EventTable[eventType];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试为事件{0}添加不同类型的委托，当前事件对应的的委托是{1}，要添加的委托类型是{2}", eventType, d.GetType(), callBack));
        }
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;  
    }
    /// <summary>
    /// 移除无参监听的方法
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void RemoveListener(eEventType eventType, CallBack callBack)
    {
        if (m_EventTable.ContainsKey(eventType))
        {
            Delegate d = m_EventTable[eventType];
            if (d == null)
            {
                throw new Exception(string.Format("移除监听错误:事件{0}没有对应的委托", eventType));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除监听错误:尝试为事件{0}移除不同类型的委托，当前委托类型为{1}" +
                    ",要移除的委托的类型为{2}", eventType, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除监听错误:没有事件码{0}", eventType));
        }
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
    }

    public static void Broadcast(eEventType eventType)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType,out d))
        {
            CallBack callBack = d as CallBack;
            if (callBack!=null)
            {
                callBack();
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型",eventType));
            }
        }      
    }
}


//回调管理
public delegate void CallBack();
public delegate void CallBack<T>(T arg);

下面是测试的Test脚本挂在Test上

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

public class ShowTest : MonoBehaviour
{
    public void Awake()
    {    
        EventCenter.AddListener(eEventType.ShowText, Show);
        gameObject.SetActive(false);
    }

    public void OnDestroy()
    {
        EventCenter.RemoveListener(eEventType.ShowText, Show);
    }
    public void Show()
    {
        gameObject.SetActive(true);
    }
}

下面是btn脚本挂在btn上

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

public class BtnOnClick : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        GetComponent<Button>().onClick.AddListener (() => {
            EventCenter.Broadcast(eEventType.ShowText);
        });
    }
}

点击btn Test激活


GIF.gif

然后我们加上泛型 和有参数 还有代码优化

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
/// <summary>
/// 注册码
/// </summary>
public enum eEventType
{
    ShowText = 0,
}

/// <summary>
/// 事件管理
/// </summary>
public class EventCenter
{
    static Dictionary<eEventType, Delegate> m_EventTable = new Dictionary<eEventType, Delegate>();

    static void OnListenerAdding(eEventType eventType, Delegate callBack)
    {
        if (!m_EventTable.ContainsKey(eventType))
        {
            m_EventTable.Add(eventType, null);
        }
        Delegate d = m_EventTable[eventType];
        if (d != null && d.GetType() != callBack.GetType())
        {
            throw new Exception(string.Format("尝试为事件{0}添加不同类型的委托，当前事件对应的的委托是{1}，要添加的委托类型是{2}", eventType, d.GetType(), callBack));
        }
    }

    static void OnListenerRemoving(eEventType eventType, Delegate callBack)
    {
        if (m_EventTable.ContainsKey(eventType))
        {
            Delegate d = m_EventTable[eventType];
            if (d == null)
            {
                throw new Exception(string.Format("移除监听错误:事件{0}没有对应的委托", eventType));
            }
            else if (d.GetType() != callBack.GetType())
            {
                throw new Exception(string.Format("移除监听错误:尝试为事件{0}移除不同类型的委托，当前委托类型为{1}" +
                    ",要移除的委托的类型为{2}", eventType, d.GetType(), callBack.GetType()));
            }
        }
        else
        {
            throw new Exception(string.Format("移除监听错误:没有事件码{0}", eventType));
        }
    }

    static void OnListenerRemoved(eEventType eventType)
    {
        if (m_EventTable[eventType] == null)
        {
            m_EventTable.Remove(eventType);
        }
    }
    /// <summary>
    /// 无参添加监听的方法
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void AddListener(eEventType eventType, CallBack callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
    }
    /// <summary>
    /// 1参添加监听的方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void AddListener<T>(eEventType eventType, CallBack<T> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
    }
    /// <summary>
    /// 2参添加监听的方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="X"></typeparam>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void AddListener<T,X>(eEventType eventType, CallBack<T,X> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T,X>)m_EventTable[eventType] + callBack;
    }

    public static void AddListener<T, X ,Y>(eEventType eventType, CallBack<T, X,Y> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X,Y>)m_EventTable[eventType] + callBack;
    }

    public static void AddListener<T, X, Y,Z>(eEventType eventType, CallBack<T, X, Y,Z> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y,Z>)m_EventTable[eventType] + callBack;
    }
    public static void AddListener<T, X, Y, Z,W>(eEventType eventType, CallBack<T, X, Y, Z,W> callBack)
    {
        OnListenerAdding(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z,W>)m_EventTable[eventType] + callBack;
    }
    /// <summary>
    /// 移除无参监听的方法
    /// </summary>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void RemoveListener(eEventType eventType, CallBack callBack)
    {
        OnListenerRemoving(eventType, callBack);
         m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    /// <summary>
    /// 移除1参监听的方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void RemoveListener<T>(eEventType eventType, CallBack<T> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    /// <summary>
    /// 移除2参监听的方法
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="eventType"></param>
    /// <param name="callBack"></param>
    public static void RemoveListener<T,X>(eEventType eventType, CallBack<T,X> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T,X>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    public static void RemoveListener<T, X,Y>(eEventType eventType, CallBack<T, X,Y> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X,Y>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    public static void RemoveListener<T, X, Y,Z>(eEventType eventType, CallBack<T, X, Y,Z> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y,Z>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }

    public static void RemoveListener<T, X, Y, Z,W>(eEventType eventType, CallBack<T, X, Y, Z,W> callBack)
    {
        OnListenerRemoving(eventType, callBack);
        m_EventTable[eventType] = (CallBack<T, X, Y, Z,W>)m_EventTable[eventType] - callBack;
        OnListenerRemoved(eventType);
    }
    /// <summary>
    /// 广播无参方法
    /// </summary>
    /// <param name="eventType"></param>
    public static void Broadcast(eEventType eventType)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack callBack = d as CallBack;
            if (callBack != null)
            {
                callBack();
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型", eventType));
            }
        }
    }
    /// <summary>
    /// 广播1参方法
    /// </summary>
    /// <param name="eventType"></param>
    public static void Broadcast<T>(eEventType eventType, T arg)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T> callBack = d as CallBack<T>;
            if (callBack != null)
            {
                callBack(arg);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型", eventType));
            }
        }
    }
    /// <summary>
    /// 广播2参方法
    /// </summary>
    /// <param name="eventType"></param>
    public static void Broadcast<T,X>(eEventType eventType, T arg1,X arg2)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T,X> callBack = d as CallBack<T,X>;
            if (callBack != null)
            {
                callBack(arg1,arg2);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型", eventType));
            }
        }
    }

    public static void Broadcast<T, X,Y>(eEventType eventType, T arg1, X arg2,Y arg3)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T, X,Y> callBack = d as CallBack<T, X,Y>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型", eventType));
            }
        }
    }

    public static void Broadcast<T, X, Y,Z>(eEventType eventType, T arg1, X arg2, Y arg3,Z arg4)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y,Z> callBack = d as CallBack<T, X, Y,Z>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3,arg4);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型", eventType));
            }
        }
    }

    public static void Broadcast<T, X, Y, Z,W>(eEventType eventType, T arg1, X arg2, Y arg3, Z arg4,W arg5)
    {
        Delegate d;
        if (m_EventTable.TryGetValue(eventType, out d))
        {
            CallBack<T, X, Y, Z,W> callBack = d as CallBack<T, X, Y, Z,W>;
            if (callBack != null)
            {
                callBack(arg1, arg2, arg3, arg4,arg5);
            }
            else
            {
                throw new Exception(string.Format("广播事件错误:事件{0}对应的委托具有不同类型", eventType));
            }
        }
    }
}


//回调管理 不用Action因为自带的最多4个参数
public delegate void CallBack();
public delegate void CallBack<T>(T arg);
public delegate void CallBack<T, X>(T arg1, X arg2);
public delegate void CallBack<T, X, Y>(T arg1, X arg2, Y arg3);
public delegate void CallBack<T, X, Y, Z>(T arg1, X arg2, Y arg3, Z arg4);
public delegate void CallBack<T, X, Y, Z,W>(T arg1, X arg2, Y arg3, Z arg4, W arg5);

下面测试脚本

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
public class ShowTest : MonoBehaviour
{
    public void Awake()
    {    
        EventCenter.AddListener<string,string,float,float,int>(eEventType.ShowText, Show);
    
        gameObject.SetActive(false);
    }

    public void OnDestroy()
    {
        EventCenter.RemoveListener<string, string, float, float, int>(eEventType.ShowText, Show);     
    }
    public void Show(string str,string str1,float a,float b,int c)
    {
        gameObject.SetActive(true);
        GetComponent<Text>().text = str+str1+a+b+c;
    }
}


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

public class BtnOnClick : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        GetComponent<Button>().onClick.AddListener (() => {
            EventCenter.Broadcast(eEventType.ShowText,"你好","你好呀",1.7f,1.8f,2);
        });
    }
}
GIF.gif

传类也是可以的

缺点

image.png

添加和移除与CallBack 的泛型顺序长度必须和方法的参数顺序长度一致 不然会报错

image.png

然后广播时候也要监听者的长度和顺序一致
因为注册码和方法一对一的可以这样操作做好标记说明参数信息


image.png

image.png

这样调用的时候就不用猜或者去翻了

https://github.com/1004019267/EventCenter/tree/master

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容