Unity3D中利用Action实现自己的消息管理（订阅/发布）类

引言

一般的软件开发过程中，为了方便对项目进行管理、维护和扩展，通常会采用一种MVC框架，以将显示逻辑、业务逻辑和数据进行分离。

这在传统企业软件的开发中很常见，但我在使用Unity做游戏开发的时候却几乎找不到相关框架。

其原因猜测大概有两点，一是游戏开发模式多变，不同类型的游戏代码结构差异很大，很难有一个适用性很强的框架出现；二是Unity太年轻，其大范围使用也不过是最近三四年的事情。

没有框架也不是意味着没有办法，MVC只是一种规范，只要在开发过程中对代码的组织结构及用途做一定的约束，就能达到各层分离的效果。

在代码分层组织的结构中，出于解耦合的需求，通常需要一个对事件/消息进行管理的类，以便在各层之间传送消息，其功能包括事件/消息的订阅、发布以及取消订阅。

本文不会写怎么实现一个MVC结构（驾驭不了），只说说这个事件管理类的实现方法。

事件管理类的实现

1、编写EventManager类

一个事件管理类通过包括三个功能，订阅、发布消息、取消订阅，对应到代码中，也是就三个方法：AddEvent、DispatchEvent、RemoveEvent，还有一个字典List，对订阅事件做管理，实现如下：

 /**
 * UnityVersion: 2018.3.1f1
 * FileName:     EventManager.cs
 * Author:       TYQ
 * CreateTime:   2019/04/04 15:49:53
 * Description:  自定义的事件派发类
 */
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;

 public class EventManager
 {
     /// <summary>
     /// 带返回参数的回调列表,参数类型为T，支持一对多
     /// </summary>
     public static Dictionary<string, List<Delegate>> events = new Dictionary<string, List<Delegate>>();

     /// <summary>
     /// 注册事件，1个返回参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void AddEvent<T> (string eventName, Action<T> callback)
     {
         List<Delegate> actions = null;

         //eventName已存在
         if (events.TryGetValue(eventName, out actions))
         {
             actions.Add(callback);
         }
         //eventName不存在
         else
         {
             actions = new List<Delegate>();

             actions.Add(callback);
             events.Add(eventName ,actions);
         }
     }

     /// <summary>
     /// 注册事件，不带返回参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void AddEvent(string eventName, Action callback)
     {
         List<Delegate> actions = null;

         //eventName已存在
         if (events.TryGetValue(eventName, out actions))
         {
             actions.Add(callback);
         }
         //eventName不存在
         else
         {
             actions = new List<Delegate>();

             actions.Add(callback);
             events.Add(eventName, actions);
         }
     }

     /// <summary>
     /// 移除事件
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void RemoveEvent<T>(string eventName, Action<T> callback)
     {
         List<Delegate> actions = null;

         if (events.TryGetValue(eventName, out actions))
         {
             actions.Remove(callback);
             if (actions.Count == )
             {
                 events.Remove(eventName);
             }
         }
     }
     /// <summary>
     /// 移除全部事件
     /// </summary>
     public static void RemoveAllEvents ()
     {
         events.Clear();
     }

     /// <summary>
     /// 派发事件
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="arg"></param>
     public static void DispatchEvent<T>(string eventName, T arg)
     {
         List<Delegate> actions = null;

         if (events.ContainsKey(eventName))
         {
             events.TryGetValue(eventName, out actions);

             foreach (var act in actions)
             {
                 act.DynamicInvoke(arg);
             }
         }
     }
     /// <summary>
     /// 派发事件，不带参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="arg"></param>
     public static void DispatchEvent(string eventName)
     {
         List<Delegate> actions = null;

         if (events.ContainsKey(eventName))
         {
             events.TryGetValue(eventName, out actions);

             foreach (var act in actions)
             {
                 act.DynamicInvoke();
             }
         }
     }
 }

EventManager.cs

2、测试事件类

2.1、先制作测试界面，包括两个接收（订阅）消息的Text组件，以及一个发布消息的Slider组件，层次结构见下图：

预期效果：拖动Slider，Slider的值会同步显示到两个用于接收的Text组件上。

2.2、编写测试类

先写一个发布消息的类，在Slider的onValueChanged事件中执行发布操作，如下

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

public class Sender : MonoBehaviour
{
    public Slider slider = null;

    private void Awake()
    {
        slider.onValueChanged.AddListener(delegate (float value) {
            Debug.LogFormat("slider:{0}", value);
            //有参分发
            EventManager.DispatchEvent<float>("NumberEvent", value);

            //无参分发
            EventManager.DispatchEvent("NumberEventNoParam");
        });
    }
}

Sender.cs

再写一下接收消息的类，，如下

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

public class Receiver : MonoBehaviour
{
    public Text receiveText1 = null;
    public Text receiveText2 = null;

    private void Awake()
    {
        //带参数回调

        //注册方法1
        EventManager.AddEvent<float>("NumberEvent", OnNumberChangeEventHandler);

        //注册方法2
        EventManager.AddEvent("NumberEvent", delegate (float arg) {
            receiveText2.text = (Convert.ToInt32(arg)).ToString();
        });

        //无参回调
        EventManager.AddEvent("NumberEventNoParam", delegate () {
            Debug.Log("无参回调");
        });
    }

    /// <summary>
    /// 事件处理方法
    /// </summary>
    /// <param name="arg"></param>
    private void OnNumberChangeEventHandler (float arg)
    {
        receiveText1.text = (Convert.ToInt32(arg)).ToString();
    }
}

Receiver.cs

2.3、运行

运行结果如下图：

可以看到，Slider值的改变会立马同步到接收端Text中，实现了预期的功能。

3、后记

1、我在EventManager.cs中使用Action类型来接受事件的回调，而不是使用c#的delegate，是因为，Action是Unity已经定义好的一种公共delegate，使用起来更方便。

2、目录的EventManager.cs只支持无参回调和一个参数的回调，如需更多参数回调，可以依照AddEvent<T>的写法，添加重载。

3、在EventManager.cs中好像还缺一个无参的RemoveEvent方法，请自行补充。

4、补充（2019-04-22）

实际使用中发现，派发消息时，传递两个参数和三个参数的情况还是挺多的，因此对EventManager进行了补充，有些不优雅的地方也进行了修改：

 /**
 * UnityVersion: 2018.3.1f1
 * FileName:     EventManager.cs
 * Author:       TYQ
 * CreateTime:   2019/04/04 15:49:53
 * Description:  自定义的事件派发类
 */
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;

 public class EventManager
 {
     /// <summary>
     /// 带返回参数的回调列表,参数类型为T，支持一对多
     /// </summary>
     public static Dictionary<string, List<Delegate>> events = new Dictionary<string, List<Delegate>>();

     /// <summary>
     /// 通用注册事件方法
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     private static void CommonAdd (string eventName, Delegate callback)
     {
         List<Delegate> actions = null;

         //eventName已存在
         if (events.TryGetValue(eventName, out actions))
         {
             actions.Add(callback);
         }
         //eventName不存在
         else
         {
             actions = new List<Delegate>();

             actions.Add(callback);
             events.Add(eventName, actions);
         }
     }

     /// <summary>
     /// 注册事件，0个返回参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void AddEvent(string eventName, Action callback)
     {
         CommonAdd(eventName, callback);
     }

     /// <summary>
     /// 注册事件，1个返回参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void AddEvent<T> (string eventName, Action<T> callback)
     {
         CommonAdd(eventName, callback);
     }
     /// <summary>
     /// 注册事件，2个返回参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void AddEvent<T, T1>(string eventName, Action<T, T1> callback)
     {
         CommonAdd(eventName, callback);
     }
     /// <summary>
     /// 注册事件，3个返回参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void AddEvent<T, T1, T2>(string eventName, Action<T, T1, T2> callback)
     {
         CommonAdd(eventName, callback);
     }

     /// <summary>
     /// 通用移除事件的方法
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     private static void CommonRemove (string eventName, Delegate callback)
     {
         List<Delegate> actions = null;

         if (events.TryGetValue(eventName, out actions))
         {
             actions.Remove(callback);
             if (actions.Count == )
             {
                 events.Remove(eventName);
             }
         }
     }

     /// <summary>
     /// 移除事件 0参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void RemoveEvent(string eventName, Action callback)
     {
         CommonRemove(eventName, callback);
     }

     /// <summary>
     /// 移除事件 1个参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void RemoveEvent<T>(string eventName, Action<T> callback)
     {
         CommonRemove(eventName, callback);
     }

     /// <summary>
     /// 移除事件 2个参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void RemoveEvent<T, T1>(string eventName, Action<T, T1> callback)
     {
         CommonRemove(eventName, callback);
     }
     /// <summary>
     /// 移除事件 3个参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="callback"></param>
     public static void RemoveEvent<T, T1, T2>(string eventName, Action<T, T1, T2> callback)
     {
         CommonRemove(eventName, callback);
     }

     /// <summary>
     /// 移除全部事件
     /// </summary>
     public static void RemoveAllEvents ()
     {
         events.Clear();
     }

     /// <summary>
     /// 派发事件，0参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="arg"></param>
     public static void DispatchEvent(string eventName)
     {
         List<Delegate> actions = null;

         if (events.ContainsKey(eventName))
         {
             events.TryGetValue(eventName, out actions);

             foreach (var act in actions)
             {
                 act.DynamicInvoke();
             }
         }
     }

     /// <summary>
     /// 派发事件 1个参数
     /// </summary>
     /// <param name="eventName"></param>
     /// <param name="arg"></param>
     public static void DispatchEvent<T>(string eventName, T arg)
     {
         List<Delegate> actions = null;

         if (events.ContainsKey(eventName))
         {
             events.TryGetValue(eventName, out actions);

             foreach (var act in actions)
             {
                 act.DynamicInvoke(arg);
             }
         }
     }

     /// <summary>
     /// 派发事件 2个参数
     /// </summary>
     /// <param name="eventName">事件名</param>
     /// <param name="arg">参数1</param>
     /// <param name="arg2">参数2</param>
     public static void DispatchEvent<T, T1>(string eventName, T arg, T1 arg2)
     {
         List<Delegate> actions = null;

         if (events.ContainsKey(eventName))
         {
             events.TryGetValue(eventName, out actions);

             foreach (var act in actions)
             {
                 act.DynamicInvoke(arg, arg2);
             }
         }
     }

     /// <summary>
     /// 派发事件 3个参数
     /// </summary>
     /// <param name="eventName">事件名</param>
     /// <param name="arg">参数1</param>
     /// <param name="arg2">参数2</param>
     /// <param name="arg3">参数3</param>
     public static void DispatchEvent<T1, T2, T3>(string eventName, T1 arg, T2 arg2, T3 arg3)
     {
         List<Delegate> actions = null;

         if (events.ContainsKey(eventName))
         {
             events.TryGetValue(eventName, out actions);

             foreach (var act in actions)
             {
                 act.DynamicInvoke(arg, arg2, arg3);
             }
         }
     }
 }

EventManager