Unity3D 消息框架设计

抄自：http://wiki.unity3d.com/index.php/Advanced_CSharp_Messenger

附上自己的一些理解:

先考虑需要实现的基本功能： 在任意一个地方增加一个消息的listener，则当这个消息被broadcast的时候，所有的listener都应该收到。
考虑到delegate(我的理解是本身就是为实现观察者模式而出现的类)，另外有个dict保存消息名和Delegate的对应。

定义一个static消息类Messenger。

static internal class Messenger
{
    private static Dictionary<string, Delegate> eventDict = new Dictionary<string,Delegate>();
}

考虑到委托需要全部代码可见，所以单独放入到一个文件中。

以下实现了4中委托，都是void返回。可以依据需求自己增加。

    //无参数
    public delegate void Callback();  
    //一个参数的模板
    public delegate void Callback<T>(T t);
    //两个参数的模板
    public delegate void Callback<T, U>(T t, U u);
    
    public delegate void Callback<T,U,V>(T t,U u,V v);

为了进行优化，在load一个新level的时候，考虑将原先的消息都清空。但是有一些消息可能需要一直存在。
所以给messenger 类添加了 CleanUp 函数，一个标记永久消息函数，和一个 list来存储永久消息

 　　private static List<string> permenentMessages = new List<string>();

 　　public static void SetPermenent(string name)
    {
        if(!permenentMessages.Contains(name))
        {
            permenentMessages.Add(name);
        }
    }

 　　public static void CleanUp()
    {
        foreach (var value in eventDict)
        {
            if (!permenentMessages.Contains(value.Key))
            {
                eventDict.Remove(value.Key);
            }
        }
    }

添加 MessengerHelp类

public sealed class MessengerHelper:MonoBehaviour
{
    private void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }

    public void OnLevelWasLoaded(int unUsed)
    {
         //每次新level load 的时候，清理以前的message 。  但有些信息需要保留，通用，所以的话， 就必须有永久信息的存储。list
        Messenger.CleanUp();
    }
 
}

Messenger中其他的消息操作(增加，删除，广播，打印)（以无参数为例）：

    /// <summary>
    /// 打印出所有事件
    /// </summary>
    public static void PrintEventDict()
    {
        Debug.Log("EventDict as follows");
        foreach(var pair in eventDict)
        {
            Debug.Log("Event name:  " + pair.Key);
            Debug.Log("Event Delegate:  " + pair.Value);
        }
    }


        public static void OnAdding(string name,Delegate listenerBeingAdded)
    {
        if(!eventDict.ContainsKey(name))
        {
            eventDict.Add(name, null);
        }

        //判断加入的类型与原先存储的类型是否一样
        Delegate d = eventDict[name];
        if(d!=null && d.GetType() != listenerBeingAdded.GetType())
        {
            throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", name, d.GetType().Name, listenerBeingAdded.GetType().Name));
        }
    }
    static public void OnRemoving(string name,Delegate listenerBeingRemoved)
    {
        if(eventDict.ContainsKey(name))
        {
            Delegate d = eventDict[name];
            if(d == null)
            {
                throw new ListenerException(string.Format("Attempting to remove listener with for name "{0}" but current listener is null.", name));
            }
            else if(d.GetType() != listenerBeingRemoved.GetType())
            {
                throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for name {0}. Current listeners have type {1} and listener being removed has type {2}", name, d.GetType().Name, listenerBeingRemoved.GetType().Name));

            }
        }
        else
        {
            throw new ListenerException(string.Format("Attempting to remove listener for name "{0}" but Messenger doesn't know about this name.", name));
        }
    }
    /// <summary>
    /// 每次移除后查看name对应的value是否为空
    /// </summary>
    /// <param name="name"></param>
    static public void OnRemoved(string name)
    {
        if(eventDict[name] == null)
        {
            eventDict.Remove(name);
        }
    }
    static public void OnBroadcasting(string name)
    {
#if REQUIRE_LISTENER
        if (!eventDict.ContainsKey(name))
        {
            throw new BroadcastException(string.Format("Broadcasting message "{0}" but no listener found. Try marking the message with Messenger.MarkAsPermanent.", name));    
        }   
#endif
    }


       static public void AddListener(string name, Callback listenerBeingAdded)
    {
        OnAdding(name,listenerBeingAdded);
        //存储这个name 对应的delegate
        eventDict[name] = (Callback)eventDict[name] + listenerBeingAdded;
    }

     static public void RemoveListener(string name, Callback ListenerBeingRemoved)
    {
        //移除前检查
        OnRemoving(name, ListenerBeingRemoved);
        eventDict[name] = (Callback)eventDict[name] - ListenerBeingRemoved;
        //移除后检查
        OnRemoved(name);
    }


 public static void BroadCast(string name)
    {
        OnBroadcasting(name);

        Delegate d;
        if(eventDict.TryGetValue(name,out d))
        {
            Callback callback = d as Callback;

            if(callback != null)
            {
                callback();
            }
            else
            {
                throw CreateBroadcastSignatureException(name);
            }
        }
    }

 使用方式：

using UnityEngine;
using System.Collections;

public class UseMessenger : MonoBehaviour 
{
    int health = 100;

    void Awake()
    {
        Messenger.AddListener("LoseHealth", LoseHealth);
        Messenger.AddListener("LoseHealth", LoseHealthTwo);
        Messenger.AddListener("LoseHealthLoseHealth", LoseHealth);
        Messenger.AddListener<int, string, bool>("FOO", Foo);
    }
    
    void Update()
    {
        Debug.Log(health);
    }

    void LoseHealth()
    {
        health -= 10;
    }

    void LoseHealthTwo()
    {
        health -= 10;
    }

    void Foo(int number,string name,bool isTrue)
    {            
            Debug.Log(number);
            Debug.Log(name);
            Debug.Log(isTrue);                
    }
}

using UnityEngine;
using System.Collections;

public class BroadCast : MonoBehaviour 
{

    void Start()
    {
        Messenger.BroadCast("LoseHealth");
        Messenger.SetPermenent("LoseHealth");
        Messenger.BroadCast<int, string, bool>("FOO",100, "nice", true);
        
        Messenger.PrintEventDict();
       
    }
}

执行结果：

所有的代码如下。

#define REQUIRE_LISTENER

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

/// <summary>
///  消息处理框架 
/// </summary>
static internal class Messenger   //static internal
{

    static private MessengerHelper messengerHelper = (new GameObject("MessengerHelper")).AddComponent<MessengerHelper>();
    //存储暂时的消息，关卡load时清空
    //不同类型的delegate存储在同一个字典中，用大写的Delegate表示类型。 在System 下
    //此处value值只能为delegate，而不能选择event。 所以说只是利用了delegate 而没有使用event。为了简洁；
    private static Dictionary<string, Delegate> eventDict = new Dictionary<string,Delegate>();  
    //存储永久的消息，清空时忽略list中的消息
    private static List<string> permenentMessages = new List<string>();

    /// <summary>
    /// 打印出所有事件
    /// </summary>
    public static void PrintEventDict()
    {
        Debug.Log("EventDict as follows");
        foreach(var pair in eventDict)
        {
            Debug.Log("Event name:  " + pair.Key);
            Debug.Log("Event Delegate:  " + pair.Value);
        }
    }

    /// <summary>
    /// 标记为永久有效
    /// </summary>
    /// <param name="name"></param>
    public static void SetPermenent(string name)
    {
        if(!permenentMessages.Contains(name))
        {
            permenentMessages.Add(name);
        }
    }
    /// <summary>
    /// 清理
    /// </summary>
    public static void CleanUp()
    {
        foreach (var value in eventDict)
        {
            if (!permenentMessages.Contains(value.Key))
            {
                eventDict.Remove(value.Key);
            }
        }
    }
    public static void OnAdding(string name,Delegate listenerBeingAdded)
    {
        if(!eventDict.ContainsKey(name))
        {
            eventDict.Add(name, null);
        }

        //判断加入的类型与原先存储的类型是否一样
        Delegate d = eventDict[name];
        if(d!=null && d.GetType() != listenerBeingAdded.GetType())
        {
            throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", name, d.GetType().Name, listenerBeingAdded.GetType().Name));
        }
    }
    static public void OnRemoving(string name,Delegate listenerBeingRemoved)
    {
        if(eventDict.ContainsKey(name))
        {
            Delegate d = eventDict[name];
            if(d == null)
            {
                throw new ListenerException(string.Format("Attempting to remove listener with for name "{0}" but current listener is null.", name));
            }
            else if(d.GetType() != listenerBeingRemoved.GetType())
            {
                throw new ListenerException(string.Format("Attempting to remove listener with inconsistent signature for name {0}. Current listeners have type {1} and listener being removed has type {2}", name, d.GetType().Name, listenerBeingRemoved.GetType().Name));

            }
        }
        else
        {
            throw new ListenerException(string.Format("Attempting to remove listener for name "{0}" but Messenger doesn't know about this name.", name));
        }
    }
    /// <summary>
    /// 每次移除后查看name对应的value是否为空
    /// </summary>
    /// <param name="name"></param>
    static public void OnRemoved(string name)
    {
        if(eventDict[name] == null)
        {
            eventDict.Remove(name);
        }
    }
    static public void OnBroadcasting(string name)
    {
#if REQUIRE_LISTENER
        if (!eventDict.ContainsKey(name))
        {
            throw new BroadcastException(string.Format("Broadcasting message "{0}" but no listener found. Try marking the message with Messenger.MarkAsPermanent.", name));    
        }   
#endif
    }

    #region AddListener
    static public void AddListener(string name, Callback listenerBeingAdded)
    {
        OnAdding(name,listenerBeingAdded);
        //存储这个name 对应的delegate
        eventDict[name] = (Callback)eventDict[name] + listenerBeingAdded;
    }

    public static void AddListener<T>(string name,Callback<T> listenerBeingAdded)
    {
        OnAdding(name, listenerBeingAdded);
        eventDict[name] = (Callback<T>)eventDict[name] + listenerBeingAdded;
    }
    public static void AddListener<T,U>(string name,Callback<T,U> listenerBeingAdded)
    {
        OnAdding(name, listenerBeingAdded);
        eventDict[name] = (Callback<T, U>)eventDict[name] + listenerBeingAdded;
    }

    public static void AddListener<T,U,V>(string name,Callback<T,U,V> listenerBeingAdded)
    {
        OnAdding(name, listenerBeingAdded);
        eventDict[name] = (Callback<T, U, V>)eventDict[name] + listenerBeingAdded;
    }
    #endregion

    #region RemoveListener
    static public void RemoveListener(string name, Callback ListenerBeingRemoved)
    {
        //移除前检查
        OnRemoving(name, ListenerBeingRemoved);
        eventDict[name] = (Callback)eventDict[name] - ListenerBeingRemoved;
        //移除后检查
        OnRemoved(name);
    }

    static public void RemoveListener<T>(string name,Callback<T> ListenerBeingRemoved)
    {
        OnRemoving(name, ListenerBeingRemoved);
        eventDict[name] = (Callback<T>)eventDict[name] - ListenerBeingRemoved;
        OnRemoved(name);
    }
    public static void RemoveListener<T,U>(string name,Callback<T,U>listenerBeingRemoved)
    {
        OnRemoving(name, listenerBeingRemoved);
        eventDict[name] = (Callback<T, U>)eventDict[name] - listenerBeingRemoved;
        OnRemoved(name);
        
    }

    public static void RemoveListener<T,U,V>(string name,Callback<T,U,V>listenerBeingRemoved)
    {
        OnRemoving(name, listenerBeingRemoved);
        eventDict[name] = (Callback<T, U, V>)eventDict[name] - listenerBeingRemoved;
        OnRemoved(name);
    }
    #endregion

    #region BroadCast

    public static void BroadCast(string name)
    {
        OnBroadcasting(name);

        Delegate d;
        if(eventDict.TryGetValue(name,out d))
        {
            Callback callback = d as Callback;

            if(callback != null)
            {
                callback();
            }
            else
            {
                throw CreateBroadcastSignatureException(name);
            }
        }
    }

    public static void BroadCast<T>(string name,T t)
    {
        OnBroadcasting(name);

        Delegate d;
        if(eventDict.TryGetValue(name,out d))
        {
            Callback<T> callback = d as Callback<T>;
            if(callback != null)
            {
                callback(t);
            }
            else
            {
                throw CreateBroadcastSignatureException(name);
            }
        }
        
    }
    public static void BroadCast<T,U>(string name,T t,U u)
    {
        OnBroadcasting(name);
        Delegate d;
        if(eventDict.TryGetValue(name,out d))
        {
            Callback<T, U> callback = d as Callback<T, U>;
            if(callback != null)
            {
                callback(t,u);
            }
            else 
            {
                throw CreateBroadcastSignatureException(name);
            }
        }
    }
    public static void BroadCast<T,U,V>(string name,T t,U u,V v)
    {
        OnBroadcasting(name);
        Delegate d;
        if(eventDict.TryGetValue(name,out d))
        {
            Callback<T,U,V> callback = d as Callback<T,U,V>;
            if(callback != null)
            {
                callback(t, u, v);
            }
            else
            {
                throw CreateBroadcastSignatureException(name);
            }
        }
    }
    #endregion

    #region Exception
    public class ListenerException:Exception
    {
        public ListenerException(string msg):base(msg)
        {

        }
    }

    static public BroadcastException CreateBroadcastSignatureException(string name)
    {
        return new BroadcastException(string.Format("Broadcasting message "{0}" but listeners have a different signature than the broadcaster.", name));
    }


    public class BroadcastException :Exception
    {
        public BroadcastException(string msg) :base(msg)
        {

        }
    }

    #endregion

}


/// <summary>
/// 消息处理帮助类
/// </summary>
public sealed class MessengerHelper:MonoBehaviour
{
    private void Awake()
    {
        DontDestroyOnLoad(gameObject);
    }

    public void OnLevelWasLoaded(int unUsed)
    {
         //每次新level load 的时候，清理以前的message 。  但有些信息需要保留，通用，所以的话， 就必须有永久信息的存储。list
        Messenger.CleanUp();
    }

  
}