unity消息系统机制，工具类可以直接使用

转自：http://www.manew.com/blog-117699-43032.html

在开发Unity的时候，为了方便开发一般都会采用消息事件，消息事件主要是做啥的？我们如何去封装，如何去运用消息事件处理事情。接下来就给大家介绍一下：

消息事件顾名思义，是通过消息触发的事件。比如大家去完成某个任务，完成后才会触发另一个事件的发生，这种情况我们就会使用消息事件等等吧。

消息事件的使用主要是通过添加消息监听，然后分发消息处理事情。

那我们如何去封装我们的消息系统，在这里我把代码给大家分享一下：

1.首先我们封装消息事件的基类CBaseEvent.cs

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

public enum CEventType
{
    GAME_OVER,
    GAME_WIN,
    PAUSE,
    GAME_DATA,
}

public class CBaseEvent
{

    protected Hashtable arguments;
    protected CEventType type;
    protected object sender;
    protected string eventName;

    public CEventType Type
    {
        get
        {
            return this.type;
        }
        set
        {
            this.type = value;
        }
    }

    public IDictionary Params
    {
        get
        {
            return this.arguments;
        }
        set
        {
            this.arguments = (value as Hashtable);
        }
    }

    public object Sender
    {
        get
        {
            return this.sender;
        }
        set
        {
            this.sender = value;
        }
    }

    public string EventName
    {
        get
        {
            return eventName;
        }

        set
        {
            eventName = value;
        }
    }

    public override string ToString()
    {
        return this.type + " { " + ((this.sender == null) ? "null" : this.sender.ToString()) + " } ";
    }

    public CBaseEvent Clone()
    {
        return new CBaseEvent(this.type, this.arguments, Sender);
    }

    public CBaseEvent(CEventType type, object sender)
    {
        this.Type = type;
        Sender = sender;
        if (this.arguments == null)
        {
            this.arguments = new Hashtable();
        }
    }

    public CBaseEvent(CEventType type, Hashtable args, object sender)
    {
        this.Type = type;
        this.arguments = args;
        Sender = sender;
        if (this.arguments == null)
        {
            this.arguments = new Hashtable();
        }
    }

    public CBaseEvent(string eventName, object sender)
    {
        this.EventName = eventName;
        Sender = sender;
        if (this.arguments == null)
        {
            this.arguments = new Hashtable();
        }
    }
}

2.以上是消息基类的定义。那接下来就是封装对外使用的消息接口了。写一个新的类CEventDispatcher

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

public delegate void CEventListenerDelegate(CBaseEvent evt);

public class CEventDispatcher
{

    static CEventDispatcher instance;
    public static CEventDispatcher GetInstance()
    {
        if (instance == null)
        {
            instance = new CEventDispatcher();
        }
        return instance;
    }

    private Hashtable listeners = new Hashtable();

    public void AddEventListener(CEventType eventType, CEventListenerDelegate listener)
    {
        CEventListenerDelegate ceventListenerDelegate = this.listeners[eventType] as CEventListenerDelegate;
        ceventListenerDelegate = (CEventListenerDelegate)Delegate.Combine(ceventListenerDelegate, listener);
        this.listeners[eventType] = ceventListenerDelegate;
    }

    public void RemoveEventListener(CEventType eventType, CEventListenerDelegate listener)
    {
        CEventListenerDelegate ceventListenerDelegate = this.listeners[eventType] as CEventListenerDelegate;
        if (ceventListenerDelegate != null)
        {
            ceventListenerDelegate = (CEventListenerDelegate)Delegate.Remove(ceventListenerDelegate, listener);
        }
        this.listeners[eventType] = ceventListenerDelegate;
    }

    public void AddEventListener(string eventName, CEventListenerDelegate listener)
    {
        CEventListenerDelegate ceventListenerDelegate = this.listeners[eventName] as CEventListenerDelegate;
        //这个combine就相当于委托的+=    (整体的实现就是类似于观察者模式)
        ceventListenerDelegate = (CEventListenerDelegate)Delegate.Combine(ceventListenerDelegate, listener);
        this.listeners[eventName] = ceventListenerDelegate;
    }
    public void RemoveEventListener(string eventName, CEventListenerDelegate listener)
    {
        CEventListenerDelegate ceventListenerDelegate = this.listeners[eventName] as CEventListenerDelegate;
        if (ceventListenerDelegate != null)
        {
            ceventListenerDelegate = (CEventListenerDelegate)Delegate.Remove(ceventListenerDelegate, listener);
        }
        this.listeners[eventName] = ceventListenerDelegate;
    }

    public void DispatchEventOnce(CBaseEvent evt)
    {
        CEventListenerDelegate ceventListenerDelegate;
        if (string.IsNullOrEmpty(evt.EventName))
        {
            ceventListenerDelegate = this.listeners[evt.Type] as CEventListenerDelegate;
        }
        else
        {
            ceventListenerDelegate = this.listeners[evt.EventName] as CEventListenerDelegate;
        }
        if (ceventListenerDelegate != null)
        {
            try
            {
                ceventListenerDelegate(evt);
                if (string.IsNullOrEmpty(evt.EventName))
                {
                    this.listeners.Remove(evt.Type);
                }
                else
                {
                    this.listeners.Remove(evt.EventName);
                }
            }
            catch (Exception ex)
            {
                throw new Exception(string.Concat(new string[]
                {
                    "Error dispatching event ",
                    evt.Type.ToString(),
                    ": ",
                    ex.Message,
                    " ",
                    ex.StackTrace
                }), ex);
            }
        }
    }
    /// 

    /// 使用枚举传递
    /// 
    /// 
    public void DispatchEvent(CBaseEvent evt)
    {
        CEventListenerDelegate ceventListenerDelegate = this.listeners[evt.Type] as CEventListenerDelegate;

        if (ceventListenerDelegate != null)
        {
            try
            {
                ceventListenerDelegate(evt);
            }
            catch (Exception ex)
            {
                throw new Exception(string.Concat(new string[]
                {
                    "Error dispatching event ",
                    evt.Type.ToString(),
                    ": ",
                    ex.Message,
                    " ",
                    ex.StackTrace
                }), ex);
            }
        }
    }

    /// 

    /// 使用字符串传递
    /// 
    /// 
    public void DispatchStringEvent(CBaseEvent evt)
    {
        CEventListenerDelegate ceventListenerDelegate = this.listeners[evt.EventName] as CEventListenerDelegate;

        if (ceventListenerDelegate != null)
        {
            try
            {
                ceventListenerDelegate(evt);
            }
            catch (Exception ex)
            {
                throw new Exception(string.Concat(new string[]
                {
                    "Error dispatching event ",
                    evt.Type.ToString(),
                    ": ",
                    ex.Message,
                    " ",
                    ex.StackTrace
                }), ex);
            }
        }
    }

    public void RemoveAll()
    {
        this.listeners.Clear();
    }
}

3.一共就这2个类就可以了，接下来是使用方法

using UnityEngine;
using System.Collections;

public class TestEvent : MonoBehaviour {

	// Use this for initialization
	void Start () {
        CEventDispatcher.GetInstance().AddEventListener("开始触发", MyTestFunc);
        CEventDispatcher.GetInstance().AddEventListener(CEventType.GAME_WIN, MyTestFunc);
        CEventDispatcher.GetInstance().DispatchEventOnce(new CBaseEvent("开始触发","第一次"));
        CEventDispatcher.GetInstance().DispatchStringEvent(new CBaseEvent("开始触发", "第三次"));
        CEventDispatcher.GetInstance().DispatchEvent(new CBaseEvent(CEventType.GAME_WIN, "事件类型"));



    }
    void MyTestFunc(CBaseEvent evt)
    {
        Debug.Log("触发了该方法："+ evt.Sender.ToString());
    }

}