m_EventTable[eventType] = (Callback)m_EventTable[eventType] + callback;

这是啥情况，哦哦哦！委托类型是可以相加的，表示一个委托执行多个程序！

核心是委托

当需要调用方法时，将该方法做成一个监听，AddListener（事件码，方法）委托需要与事件码绑定。

方法若持有参数，在AddListener前指定同类型的泛型。

添加完监听后要记得remove

监听要在初始化函数（Awake、Start）中调用

外界想要调用方法时只需要广播事件码即可，达到解耦合目的

精简代码

新建一个方法

把重复的代码放进方法里面

然后调用即可

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

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

    //注册监听事件
    public static void AddListener<T>(EventType eventType, CallBack<T> 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
                ()));
        }
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] + callBack;
    }
    //移除监听事件
    public static void RemoveListener<T>(EventType eventType, CallBack<T> 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
                ));

        }
        m_EventTable[eventType] = (CallBack<T>)m_EventTable[eventType] - callBack;
        if (m_EventTable[eventType] == null) {
            m_EventTable.Remove(eventType);

        }
    }
    //广播事件
    public static void Broadcast<T>(EventType 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));
            }

        }
    }

}

利用单例模式，创立一个实例化对象，引用其他脚本配合EVent ，将事件广播，采用监听解决耦合

private void Awake()

{

    gameObject.SetActive(false);

    EventCenter.AddListener<string>(EventType.ShowText,Show);

}

private void OnDestroy()

{

    EventCenter.RemoveListener<string>(EventType.ShowText, Show);

}

private void Show(shring str)

{

    gameObject.SetActive(true);

    GetComponent<Text>().text = str;

}

监听

Awake()/Start()

{

EventCenter.AddListener<Type>(EventType.Name, 方法);

}

OnDestroy()

{

EventCenter.RemoveListener<Type>(EventType.Name, 方法);

}

EventCenter.AddListener<string>(事件，方法）；

1.初始化（Awake）里调用。

2.传递相应的类型。

EventCenter.Broadcast(事件，广播内容)；

结论：解除按键和按钮的耦合性。

EnterCenter.br

10-25到这里

 这个是我自己在用的，可以单独对某个物体进行操作 减少GetComponent

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

namespace System
{

    /// <summary>封装一个方法，该方法具有N个参数并且不返回值。</summary>
    /// <param mName="arg1">此委托封装的方法的第一个参数。</param>
    /// <typeparam mName="T1">此委托封装的方法的第一个参数类型。</typeparam>
    public delegate void Action<T1, T2, T3, T4, T5, T6, T7, T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
    public delegate void Action<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
    public delegate void Action<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
    public delegate void Action<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
}

namespace GameDevUtility
{
    public class EventManager : MonoBehaviour
    {

        //声明存放全局事件的字典
        private static Dictionary<string, Delegate> s_GlobalEventTable = new Dictionary<string, Delegate>();

        //声明存放在单个游戏对象上被调用的局部事件的字典
        private static Dictionary<GameObject, Dictionary<string, Delegate>> s_EventTable = new Dictionary<GameObject, Dictionary<string, Delegate>>();



        #region //全局事件的登录函数
        public static void RegisterEvent(string eventName, Action handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T>(string eventName, Action<T> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2>(string eventName, Action<T1, T2> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3>(string eventName, Action<T1, T2, T3> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3, T4>(string eventName, Action<T1, T2, T3, T4> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3, T4, T5>(string eventName, Action<T1, T2, T3, T4, T5> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3, T4, T5, T6>(string eventName, Action<T1, T2, T3, T4, T5, T6> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }
        public static void RegisterEvent<T1, T2, T3, T4, T5, T6, T7>(string eventName, Action<T1, T2, T3, T4, T5, T6, T7> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }
        public static void RegisterEvent<T1, T2, T3, T4, T5, T6, T7, T8>(string eventName, Action<T1, T2, T3, T4, T5, T6, T7, T8> handler)
        {
            RegisterEvent(eventName, (Delegate)handler);
        }

        private static void RegisterEvent(string eventName, Delegate handler)
        {
            Delegate prevHandler;
            if (s_GlobalEventTable.TryGetValue(eventName, out prevHandler)) //如果要存入字典的键名称跟已经在字典里面的键名重复了
            {
                s_GlobalEventTable[eventName] = Delegate.Combine(prevHandler, handler);
                //将已有的键名对应的委托和要新存入的委托合并，存回已有建名对应的位置
            }
            else    //如果字典中不存在以eventName为键名称的键值对，就以eventName为键名称创建新的键值对
            {
                s_GlobalEventTable.Add(eventName, handler);
            }
        }




        #endregion



        #region  //局部事件的登录函数
        public static void RegisterEvent(GameObject obj, string eventName, Action handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T>(GameObject obj, string eventName, Action<T> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2>(GameObject obj, string eventName, Action<T1, T2> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3>(GameObject obj, string eventName, Action<T1, T2, T3> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3, T4>(GameObject obj, string eventName, Action<T1, T2, T3, T4> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void RegisterEvent<T1, T2, T3, T4, T5>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void RegisterEvent<T1, T2, T3, T4, T5, T6>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5, T6> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void RegisterEvent<T1, T2, T3, T4, T5, T6, T7>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5, T6, T7> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void RegisterEvent<T1, T2, T3, T4, T5, T6, T7, T8>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5, T6, T7, T8> handler)
        {
            RegisterEvent(obj, eventName, (Delegate)handler);
        }

        private static void RegisterEvent(GameObject obj, string eventName, Delegate handler)
        {
            //在局部事件字典中查找以obj游戏对象为键的字典
            Dictionary<string, Delegate> handlers;

            //如果在局部事件字典中找不到以obj游戏对象为键的字典，说明这是obj游戏对象的第一次事件登录
            if (!s_EventTable.TryGetValue(obj, out handlers))
            {
                //在局部字典中添加以obj为键，一个空白字典为值的键值对
                handlers = new Dictionary<string, Delegate>();
                s_EventTable.Add(obj, handlers);
            }

            //在记录obj游戏对象的局部事件的字典中查找以eventName为键的委托
            Delegate prevHandlers;
            //如果在局部事件字典中已经存在以eventName为键的委托
            if (handlers.TryGetValue(eventName, out prevHandlers))
            {
                //就将已有的键名对应的委托和要新存入的委托合并，存回已有建名对应的位置
                handlers[eventName] = Delegate.Combine(prevHandlers, handler);
            }
            else
            {
                //否则，说明这是eventName的第一次事件登录，那么就以eventName为键名称创建新的键值对
                handlers.Add(eventName, handler);
            }
        }



        #endregion



        #region //全局事件的调用函数
        public static void ExecuteEvent(string eventName)
        {
            Action handler;
            handler = s_GlobalEventTable[eventName] as Action;
            handler();
        }

        public static void ExecuteEvent<T>(string eventName, T arg1)
        {
            Action<T> handler;
            handler = s_GlobalEventTable[eventName] as Action<T>;
            if (handler != null)
            {
                handler(arg1);
            }
        }

        public static void ExecuteEvent<T1, T2>(string eventName, T1 arg1, T2 arg2)
        {
            Action<T1, T2> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2>;
            if (handler != null)
            {
                handler(arg1, arg2);
            }
        }

        public static void ExecuteEvent<T1, T2, T3>(string eventName, T1 arg1, T2 arg2, T3 arg3)
        {
            Action<T1, T2, T3> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2, T3>;
            if (handler != null)
            {
                handler(arg1, arg2, arg3);
            }
        }

        public static void ExecuteEvent<T1, T2, T3, T4>(string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            Action<T1, T2, T3, T4> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2, T3, T4>;
            if (handler != null)
            {
                handler(arg1, arg2, arg3, arg4);
            }
        }

        public static void ExecuteEvent<T1, T2, T3, T4, T5>(string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            Action<T1, T2, T3, T4, T5> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2, T3, T4, T5>;
            if (handler != null)
            {
                handler(arg1, arg2, arg3, arg4, arg5);
            }
        }
        public static void ExecuteEvent<T1, T2, T3, T4, T5, T6>(string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            Action<T1, T2, T3, T4, T5, T6> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2, T3, T4, T5, T6>;
            if (handler != null)
            {
                handler(arg1, arg2, arg3, arg4, arg5, arg6);
            }
        }
        public static void ExecuteEvent<T1, T2, T3, T4, T5, T6, T7>(string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            Action<T1, T2, T3, T4, T5, T6, T7> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2, T3, T4, T5, T6, T7>;
            if (handler != null)
            {
                handler(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
            }
        }

        public static void ExecuteEvent<T1, T2, T3, T4, T5, T6, T7, T8>(string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            Action<T1, T2, T3, T4, T5, T6, T7, T8> handler;
            handler = s_GlobalEventTable[eventName] as Action<T1, T2, T3, T4, T5, T6, T7, T8>;
            if (handler != null)
            {
                handler(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
            }
        }
        #endregion





        #region //局部事件的调用函数
        public static void ExecuteEvent(GameObject obj, string eventName)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action handler;
                handler = handlers[eventName] as Action;
                if (handler != null)
                {
                    handler();
                }
            }
        }

        public static void ExecuteEvent<T>(GameObject obj, string eventName, T arg1)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T> handler;
                handler = handlers[eventName] as Action<T>;
                if (handler != null)
                {
                    handler(arg1);
                }
            }
        }

        public static void ExecuteEvent<T1, T2>(GameObject obj, string eventName, T1 arg1, T2 arg2)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2> handler;
                handler = handlers[eventName] as Action<T1, T2>;
                if (handler != null)
                {
                    handler(arg1, arg2);
                }
            }
        }

        public static void ExecuteEvent<T1, T2, T3>(GameObject obj, string eventName, T1 arg1, T2 arg2, T3 arg3)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2, T3> handler;
                handler = handlers[eventName] as Action<T1, T2, T3>;
                if (handler != null)
                {
                    handler(arg1, arg2, arg3);
                }
            }
        }

        public static void ExecuteEvent<T1, T2, T3, T4>(GameObject obj, string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2, T3, T4> handler;
                handler = handlers[eventName] as Action<T1, T2, T3, T4>;
                if (handler != null)
                {
                    handler(arg1, arg2, arg3, arg4);
                }
            }
        }

        public static void ExecuteEvent<T1, T2, T3, T4, T5>(GameObject obj, string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2, T3, T4, T5> handler;
                handler = handlers[eventName] as Action<T1, T2, T3, T4, T5>;
                if (handler != null)
                {
                    handler(arg1, arg2, arg3, arg4, arg5);
                }
            }
        }
        public static void ExecuteEvent<T1, T2, T3, T4, T5, T6>(GameObject obj, string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2, T3, T4, T5, T6> handler;
                handler = handlers[eventName] as Action<T1, T2, T3, T4, T5, T6>;
                if (handler != null)
                {
                    handler(arg1, arg2, arg3, arg4, arg5, arg6);
                }
            }
        }
        public static void ExecuteEvent<T1, T2, T3, T4, T5, T6, T7>(GameObject obj, string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2, T3, T4, T5, T6, T7> handler;
                handler = handlers[eventName] as Action<T1, T2, T3, T4, T5, T6, T7>;
                if (handler != null)
                {
                    handler(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
                }
            }
        }
        public static void ExecuteEvent<T1, T2, T3, T4, T5, T6, T7, T8>(GameObject obj, string eventName, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
        {
            Dictionary<string, Delegate> handlers;
            handlers = s_EventTable[obj];

            if (handlers != null)
            {
                Action<T1, T2, T3, T4, T5, T6, T7, T8> handler;
                handler = handlers[eventName] as Action<T1, T2, T3, T4, T5, T6, T7, T8>;
                if (handler != null)
                {
                    handler(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
                }
            }
        }
        #endregion




        #region //取消全局事件订阅的函数


        private static void UnregisterEvent(string eventName, Delegate handler)
        {
            Delegate prevHandlers;
            if (s_GlobalEventTable.TryGetValue(eventName, out prevHandlers))
            {
                s_GlobalEventTable[eventName] = Delegate.Remove(prevHandlers, handler);
            }
        }

        public static void UnregisterEvent(string eventName, Action handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T>(string eventName, Action<T> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T1, T2>(string eventName, Action<T1, T2> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T1, T2, T3>(string eventName, Action<T1, T2, T3> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T1, T2, T3, T4>(string eventName, Action<T1, T2, T3, T4> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5>(string eventName, Action<T1, T2, T3, T4, T5> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5, T6>(string eventName, Action<T1, T2, T3, T4, T5, T6> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5, T6, T7>(string eventName, Action<T1, T2, T3, T4, T5, T6, T7> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5, T6, T7, T8>(string eventName, Action<T1, T2, T3, T4, T5, T6, T7, T8> handler)
        {
            UnregisterEvent(eventName, (Delegate)handler);
        }
        #endregion




        #region //取消局部事件订阅的函数
        private static void UnregisterEvent(GameObject obj, string eventName, Delegate handler)
        {
            Dictionary<string, Delegate> handlers;
            if (s_EventTable.TryGetValue(obj, out handlers))
            {
                Delegate prevHandlers;
                if (handlers.TryGetValue(eventName, out prevHandlers))
                {
                    handlers[eventName] = Delegate.Remove(prevHandlers, handler);
                }
            }
        }

        public static void UnregisterEvent(GameObject obj, string eventName, Action handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T>(GameObject obj, string eventName, Action<T> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T1, T2>(GameObject obj, string eventName, Action<T1, T2> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T1, T2, T3>(GameObject obj, string eventName, Action<T1, T2, T3> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }

        public static void UnregisterEvent<T1, T2, T3, T4>(GameObject obj, string eventName, Action<T1, T2, T3, T4> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5, T6>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5, T6> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5, T6, T7>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5, T6, T7> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }
        public static void UnregisterEvent<T1, T2, T3, T4, T5, T6, T7, T8>(GameObject obj, string eventName, Action<T1, T2, T3, T4, T5, T6, T7, T8> handler)
        {
            UnregisterEvent(obj, eventName, (Delegate)handler);
        }

    }


    #endregion

}

throw new Exception：异常处理（括号内写错误信息）

strin.Format：可以用占位符写输出信息

数据名前加例如：（int，string）之类的数据类型可以强制将数据转成括号内的数据类型

EventCenter.Broadcast(1);  

1,写要监听事件的枚举

为监听的事件添加一个带参数的委托

public static void AddListener<T>(EventType eventType,CallBack<T> callBack)

{

内容与无参数相似 仅需药品在CallBack后添加<T>即可 

}

移除的方法与添加的方法一样

添加<T>即可

广播的方法也一样  传参数时要多加一个T的参数

public static void Baroadcast<T>(EventType eventType,T arg)

{

Delegate d;

CallBack<T> callBack =d as CallBack<T>;

     if (callBack!=null)

    {

       callBack(arg);要把传的T的参数传过去

    }

}

这里用字典可能使学生会看不懂

首先了解理解事件和委托

委托是把方法包装成一种变量

比如说有一个               public void M1(int i){}          方法

声明一种委托类型             public delegate void dA(int)

创建一个委托变量将方法保存一个方法          dA dA1 =new dA(M1)

这时，dA1就是一个类型为dA的变量，你在其他方法中需要再去使用.来写出完整的地址名，只需要传递这个变量就可以执行它所代表的方法了

调用委托         dA1()

事件其实就是一种委托的应用

事件的声明首先要有个委托类型，这里就用上面定义好的dA委托类型

声明一个事件类似声明一个委托变量，只不过加了event关键字                event dA dAE;

然后就是挂接方法               dAE+=m1           注意挂接不是调用方法，和委托一样，直接加上方法名就行了

最后就是执行事件         m1()        就跟委托调用一样

然后再是理解事件

事件是因为一种叫做事件模式而诞生的

有一个场景——手机没电了，自动执行亮度降低、关闭震动、关闭蓝牙、清理后台等等，这里就可以理解为手机没电了是一个事件，挂接了后面很多方法

那你这么一说，那不就和定义一个方法，然后再在方法里调用亮度降低这些方法一样吗

我一开始也是这么认为的，但其实不是的。如果使用的是方法调用，那么在方法体中就必须写进具体的方法调用，所有的后续的方法都需要写进去。

然而实际情况是，执行亮度降低是A同事写的，关闭震动是B同事写的，关闭蓝牙确实是我自己写的，清理后台还没写好，我必须把他们写的引入到我的程序中才能执行，但还有没写好的，我甚至都没法加进我自己的代码中。

所以得用事件，我把手机没电了事件给出来，所有和这个事件挂接的方法都会执行，哪个方法要接着在后面执行的，自己挂接就行了，至于没写好的，等他写完了自己再挂接就好

那这种就是一种事件模式，其实就是通知响应关系

这里定义了委托类型和enum类型，然后再定一个以enum为key，以委托为值得字典其是就是定义了一个委托数组，而在C#里，事件就是语法糖，本质还是委托

那定义一个委托数组就是因为我们要创建好几个委托，有用于显示文字的，有用于***的，等等

再不明白，就先依葫芦画瓢，跟着敲代码，迟早会明白的。

EventCenter.

private void

好好学习下，代码精简。。。

1  button 上挂载脚本 

拿到text 物体设置 text

2 

游戏里面 物体尽量少挂载脚本

单例模式  使用频繁 耦合性高

public static ShowText  Instance

每个代码只需要 负责各自的任务