Unity高度解耦和，事件的监听和广播

总共需要三个脚本，一个是CallBack 这个脚本里面定义了委托，包括无参的委托，带有一个参数的委托，两个参数的委托等
public delegate void CallBack();
public delegate void CallBack(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);

第二个脚本是EventType ，事件的类型，也就是事件码，是一个枚举类型的
public enum EventTypes
{
ShowText,
}

最后一个脚本是最核心也是最重要的一个脚本，EventCenter 这个脚本编写监听，移除监听和广播的脚本

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

public class EventCenter
{
    private static Dictionary<EventTypes, Delegate> m_EventTable = new Dictionary<EventTypes, Delegate>();

private static void OnListenerAdding(EventTypes 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.GetType()));
    }
}
private static void OnListenerRemoving(EventTypes 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));
    }
}
private static void OnListenerRemoved(EventTypes eventType)
{
    if (m_EventTable[eventType] == null)
    {
        m_EventTable.Remove(eventType);
    }       
}
//no parameters
public static void AddListener(EventTypes eventType, CallBack callBack)
{
    OnListenerAdding(eventType, callBack);
    m_EventTable[eventType] = (CallBack)m_EventTable[eventType] + callBack;
}
//Single parameters
public static void AddListener<T>(EventTypes eventType, CallBack<T> callBack)
{
    OnListenerAdding(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
}
//two parameters
public static void AddListener<T, X>(EventTypes eventType, CallBack<T, X> callBack)
{
    OnListenerAdding(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] + callBack;
}
//three parameters
public static void AddListener<T, X, Y>(EventTypes eventType, CallBack<T, X, Y> callBack)
{
    OnListenerAdding(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] + callBack;
}
//four parameters
public static void AddListener<T, X, Y, Z>(EventTypes eventType, CallBack<T, X, Y, Z> callBack)
{
    OnListenerAdding(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] + callBack;
}
//five parameters
public static void AddListener<T, X, Y, Z, W>(EventTypes eventType, CallBack<T, X, Y, Z, W> callBack)
{
    OnListenerAdding(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X, Y, Z, W>)m_EventTable[eventType] + callBack;
}

//no parameters
public static void RemoveListener(EventTypes eventType, CallBack callBack)
{
    OnListenerRemoving(eventType, callBack);
    m_EventTable[eventType] = (CallBack)m_EventTable[eventType] - callBack;
    OnListenerRemoved(eventType);
}
//single parameters
public static void RemoveListener<T>(EventTypes eventType, CallBack<T> callBack)
{
    OnListenerRemoving(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
    OnListenerRemoved(eventType);
}
//two parameters
public static void RemoveListener<T, X>(EventTypes eventType, CallBack<T, X> callBack)
{
    OnListenerRemoving(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X>)m_EventTable[eventType] - callBack;
    OnListenerRemoved(eventType);
}
//three parameters
public static void RemoveListener<T, X, Y>(EventTypes eventType, CallBack<T, X, Y> callBack)
{
    OnListenerRemoving(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X, Y>)m_EventTable[eventType] - callBack;
    OnListenerRemoved(eventType);
}
//four parameters
public static void RemoveListener<T, X, Y, Z>(EventTypes eventType, CallBack<T, X, Y, Z> callBack)
{
    OnListenerRemoving(eventType, callBack);
    m_EventTable[eventType] = (CallBack<T, X, Y, Z>)m_EventTable[eventType] - callBack;
    OnListenerRemoved(eventType);
}
//five parameters
public static void RemoveListener<T, X, Y, Z, W>(EventTypes 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);
}


//no parameters
public static void Broadcast(EventTypes 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));
        }
    }
}
//single parameters
public static void Broadcast<T>(EventTypes 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));
        }
    }
}
//two parameters
public static void Broadcast<T, X>(EventTypes 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));
        }
    }
}
//three parameters
public static void Broadcast<T, X, Y>(EventTypes 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));
        }
    }
}
//four parameters
public static void Broadcast<T, X, Y, Z>(EventTypes 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));
        }
    }
}
//five parameters
public static void Broadcast<T, X, Y, Z, W>(EventTypes 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));
        }
    }
}
}

写完上面的三个脚本，接下来就是用法
比如一个按钮，当你按下时你要执行某个方法时，那你就在那里进行广播，广播其实就是调用 通过EventCenter.Broadcast进行广播

监听事件是在需要被修改的地方进行监听和移除监听

比如我这个例子是当点击按钮时，改变text的文本，那么我就需要在text文本上挂一个脚本，然后进行监听和移除监听，然后在点击按钮那里进行广播，那么监听的就会去执行代码方法。