Unity3D 消息收发器 基于模板类型

目前大多数消息收发器都是基于string类型,个人感觉不是很直观也不好一件查找引用进行维护,所以编写更新迭代了一个模板类型消息收发器出来,推荐配合枚举使用.

展示

测试效果图

对Monobehaviour的生命周期顺序输出

测试代码

using UnityEngine;

public class BroadCastTest : MonoBehaviour {
    
    enum enum_BroadCastTest
    {
        Invalid=0,
        LifeCycle,
        EnableSet,
    }
    private void Awake()
    {
        TBroadCaster<enum_BroadCastTest>.Add<string>(enum_BroadCastTest.LifeCycle, OnLifeCycle);
        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.LifeCycle, "Awake");
    }
    private void OnEnable()
    {
        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.LifeCycle, "Enable");

        TBroadCaster<enum_BroadCastTest>.Add<bool,string>(enum_BroadCastTest.EnableSet, OnEnableSet);
        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.EnableSet, true, "Enable");
    }
    private void Start()
    {
        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.LifeCycle, "Start");
    }
    private void OnDisable()
    {
        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.LifeCycle, "Disable");

        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.EnableSet, false, "Disable");
        TBroadCaster<enum_BroadCastTest>.Remove<bool, string>(enum_BroadCastTest.EnableSet, OnEnableSet);
    }
    private void OnDestroy()
    {
        TBroadCaster<enum_BroadCastTest>.Trigger(enum_BroadCastTest.LifeCycle, "Destroy");
        TBroadCaster<enum_BroadCastTest>.Remove<string>(enum_BroadCastTest.LifeCycle, OnLifeCycle);
    }
    void OnLifeCycle(string cycle)
    {
        Debug.Log("Life Cycle:"+cycle);
    }

    void OnEnableSet(bool enable,string test)
    {
        Debug.LogWarning("Enable Cycle:"+enable + "," + test);
    }

}

思路

调用函数Add/Remove/Trigger
字典结合消息包装类进行整体消息管理
在函数触发时检测并新建类

核心代码

可直接到项目内复制使用
推荐搭配枚举使用

using System;
using System.Collections.Generic;

public static class TBroadCaster<TEnum>
{
    static Dictionary<TEnum, MessageBase> m_Messages = new Dictionary<TEnum, MessageBase>();
    public static void Clear() => m_Messages.Clear();
    #region Messages Get
    static BroadCastMessage GetMessage(TEnum identity)
    {
        BroadCastMessage message;
        if (!m_Messages.ContainsKey(identity))
        {
            message = new BroadCastMessage();
            m_Messages.Add(identity, message);
        }
        else
        {
            message = (m_Messages[identity] as BroadCastMessage);
            if (message == null)
                throw new Exception("Wrong Message Type Of"+identity);
        }
        return message;
    }

    static BroadCastMessage<T> GetMessage<T>(TEnum identity)
    {
        BroadCastMessage<T> message;
        if (!m_Messages.ContainsKey(identity))
        {
            message = new BroadCastMessage<T>();
            m_Messages.Add(identity, message);
        }
        else
        {
            message = (m_Messages[identity] as BroadCastMessage<T>);
            if (message == null)
                throw new Exception("Wrong Message Type Of" + identity + "," + typeof(T));
        }
        return message;
    }
    static BroadCastMessage<T, Y> GetMessage<T, Y>(TEnum identity)
    {
        BroadCastMessage<T, Y> message;
        if (!m_Messages.ContainsKey(identity))
        {
            message = new BroadCastMessage<T, Y>();
            m_Messages.Add(identity, message);
        }
        else
        {
            message = (m_Messages[identity] as BroadCastMessage<T, Y>);
            if (message == null)
                throw new Exception("Wrong Message Type Of" + identity + "," + typeof(T) + "," + typeof(Y));
        }
        return message;
    }
    static BroadCastMessage<T, Y,U> GetMessage<T, Y, U>(TEnum identity)
    {
        BroadCastMessage<T, Y, U> message;
        if (!m_Messages.ContainsKey(identity))
        {
            message = new BroadCastMessage<T, Y, U>();
            m_Messages.Add(identity, message);
        }
        else
        {
            message = (m_Messages[identity] as BroadCastMessage<T, Y, U>);
            if (message == null)
                throw new Exception("Wrong Message Type Of" + identity + "," + typeof(T) + "," + typeof(Y)+","+typeof(U));
        }
        return message;
    }
    static BroadCastMessage<T, Y, U, I> GetMessage<T, Y, U, I>(TEnum identity)
    {
        BroadCastMessage<T, Y, U, I> message;
        if (!m_Messages.ContainsKey(identity))
        {
            message = new BroadCastMessage<T, Y, U, I>();
            m_Messages.Add(identity, message);
        }
        else
        {
            message = (m_Messages[identity] as BroadCastMessage<T, Y, U, I>);
            if (message == null)
                throw new Exception("Wrong Message Type Of" + identity + "," + typeof(T) + "," + typeof(Y)+","+typeof(U)+","+typeof(I));
        }
        return message;
    }
    #endregion
    
    #region Message Helper		//减少代码量(虽然也不是很多)
    public static void Add(TEnum identity, Action message) => GetMessage(identity).Add(message);
    public static void Add<T>(TEnum identity, Action<T> message) => GetMessage<T>(identity).Add(message);
    public static void Add<T, Y>(TEnum identity, Action<T,Y> message) => GetMessage< T,Y>(identity).Add(message);
    public static void Add<T, Y, U>(TEnum identity, Action<T,Y,U> message) => GetMessage<T, Y, U>(identity).Add(message);
    public static void Add<T, Y, U, I>(TEnum identity, Action<T,Y,U,I> message) => GetMessage<T, Y, U, I>(identity).Add(message);
    public static void Remove(TEnum identity, Action message) => GetMessage(identity).Remove(message);
    public static void Remove<T>(TEnum identity, Action<T> message) => GetMessage<T>(identity).Remove(message);
    public static void Remove<T, Y>(TEnum identity, Action<T, Y> message) => GetMessage<T, Y>(identity).Remove(message);
    public static void Remove<T, Y, U>(TEnum identity, Action<T, Y, U> message) => GetMessage<T, Y, U>(identity).Remove(message);
    public static void Remove<T, Y, U, I>(TEnum identity, Action<T, Y, U, I> message) => GetMessage<T, Y, U, I>(identity).Remove(message);
    public static void Trigger(TEnum identity) => GetMessage(identity).Trigger();
    public static void Trigger<T>(TEnum identity, T template1) => GetMessage<T>(identity).Trigger(template1);
    public static void Trigger<T,Y>(TEnum identity, T template1,Y template2) => GetMessage<T,Y>(identity).Trigger(template1,template2);
    public static void Trigger<T,Y,U>(TEnum identity, T template1, Y template2,U template3) => GetMessage<T,Y,U>(identity).Trigger(template1,template2,template3);
    public static void Trigger<T,Y,U,I>(TEnum identity, T template1, Y template2,U template3,I template4) => GetMessage<T,Y,U,I>(identity).Trigger(template1,template2,template3,template4);
    #endregion
}

#region Messages
internal interface IBroadCastMessage<T>
{
    List<T> m_MessageList { get; }
}

internal static class IBroadCastMesasge_Extend
{
    public static int Count(this IBroadCastMessage<Action> messages) => messages.m_MessageList.Count;
    public static void Add<T>(this IBroadCastMessage<T> messages, T message)
    {
        if (messages.m_MessageList.Contains(message))
            throw new Exception("Message Already Registed!" + message);
        messages.m_MessageList.Add(message);
    }

    public static void Remove<T>(this IBroadCastMessage<T> messages, T message)
    {
        if (!messages.m_MessageList.Contains(message))
            throw new Exception("Message Not Registed!" + message);
        messages.m_MessageList.Remove(message);
    }
}
public class MessageBase { }
public class BroadCastMessage : MessageBase, IBroadCastMessage<Action>
{
    public List<Action> m_MessageList { get; } = new List<Action>();
    public void Trigger()
    {
        foreach (Action message in m_MessageList)
            message();
    }
}
public class BroadCastMessage<T> : MessageBase, IBroadCastMessage<Action<T>>
{
    public List<Action<T>> m_MessageList { get; } = new List<Action<T>>();
    public void Trigger(T template)
    {
        foreach (Action<T> message in m_MessageList)
            message(template);
    }
}
public class BroadCastMessage<T, Y> : MessageBase, IBroadCastMessage<Action<T, Y>>
{
    public List<Action<T, Y>> m_MessageList { get; } = new List<Action<T, Y>>();
    public void Trigger(T template1, Y template2)
    {
        foreach (Action<T, Y> message in m_MessageList)
            message(template1, template2);
    }
}
public class BroadCastMessage<T, Y, U> : MessageBase, IBroadCastMessage<Action<T, Y, U>>
{
    public List<Action<T, Y, U>> m_MessageList { get; } = new List<Action<T, Y, U>>();
    public void Trigger(T template1, Y template2, U template3)
    {
        foreach (Action<T, Y, U> message in m_MessageList)
            message(template1, template2, template3);
    }
}
public class BroadCastMessage<T, Y, U, I> : MessageBase, IBroadCastMessage<Action<T, Y, U, I>>
{
    public List<Action<T, Y, U, I>> m_MessageList { get; } = new List<Action<T, Y, U, I>>();
    public void Trigger(T template1, Y template2, U template3, I template4)
    {
        foreach (Action<T, Y, U, I> message in m_MessageList)
            message(template1, template2, template3, template4);
    }
}
#endregion

感谢观阅文章.如有问题请联系博主                     
                                                                           - StriteR. 2020/6/2