事件系统的使用

今天我们来了解一下模块实体组件框架中的事件系统
首先事件系统是用来分解模块之间的依赖关系，在模块与模块之间起到解耦合的作用的。它是把复杂的相互调用关系清晰明了的分离开来，使开发人员在开发和读取代码变得更容易。
接下来为大家书写代码：

    //事件类型枚举
    public enum EnumEventType
    {
        none = 0,
        one = 1,
    }
    
    //模块类
    public class Module:ModuleBase
    {
    	//事件发布的监听
        public override void onEventHandler(EnumEventType evevnType, object data)
        {
            if (evevnType == EnumEventType.one)
            {
                Console.WriteLine(data);
            }
        }
        
         public void Main()
         {
            //注册事件
            registerEvent(EnumEventType.one);
            
            //发布事件
            dispatchEvent(EnumEventType.one, new object());
	    
	    //移除事件
	    removeEvent(EnumEventType.one);
         }
    }
    
    //模块基类
    public class ModuleBase
    {
    	public void registerEvent(EnumEventType eventType)
        {
            AppEvent.getInstanse().addEvent(eventType, onEventHandler);
        }
        
        public void removeEvent(EnumEventType eventType)
        {
            AppEvent.getInstanse().removeEvent(eventType, onEventHandler);
        }
	
        public void dispatchEvent(EnumEventType eventType, object data)
        {
            AppEvent.getInstanse().dispatchEvent(eventType, data);
        }

        public virtual void onEventHandler(EnumEventType evevnType, object data)
        {
        }
    }
    
    //事件管理类
    public delegate void eventDispose(EnumEventType evevnType, object data);
    public class AppEvent
    {
    	private static AppEvent instanse;
        public static AppEvent getInstanse()
        {
            if (instanse == null)
                instanse = new AppEvent();
            return instanse;
        }
        
 	private Dictionary<EnumEventType, List<eventDispose>> dis_event = new Dictionary<EnumEventType, List<eventDispose>>();
 	
 	public void addEvent(EnumEventType eventType, eventDispose fun)
        {
            if (dis_event.ContainsKey(eventType) == false)
            {
                dis_event[eventType] = new List<eventDispose>();
            }
            dis_event[eventType].Add(fun);
        }
	
	public void removeEvent(EnumEventType eventType, eventDispose fun)
        {
            if (dis_event.ContainsKey(eventType) == false)
            {
                return;
            }
            if (dis_event[eventType].Contains(fun) == false)
            {
                return;
            }
            dis_event[eventType].Remove(fun);
        }

	public void dispatchEvent(EnumEventType eventType, object data)
        {
            if (dis_event.ContainsKey(eventType) == false)
            {
                return;
            }
            foreach (var fun in dis_event[eventType])
            {
                fun(eventType, data);
            }
        }
    }

其实最终我们的需要使用的是继承模块基类的每一个模块类中，其中我们要先把自己模块中需要和其他模块进行交互的事件进行发布，然后就可以在另一个模块中把需要调用的事件进行注册监听，当模块中的事件发布时就会在相应的监听函数中监听到，并获取相应的参数值。最后可以把不需要的监听函数进行移除，移除后监听就会失效。