初级知识六——C#事件通知系统实现（观察者模式运用）

观察者模式，绝对是游戏中十分重要的一种模式，运用这种模式，可以让游戏模块间的通信变得简单，耦合度也会大大降低，下面讲解如何利用C#实现事件通知系统。

补充，首先说下这个系统的实现原理，不然一头扎进去就难受了，这个系统的关键就在于两个类，EventCenter 和Handler，她们关系如下：

首先定义两个接口，IEventCenter 和IEventHandlerManager，代码如下：

 public interface IEventCenter : IDestroy
 {
     bool AddEventListener(Enum EventType, EventHandler handler);

     bool RemoveEventListener(Enum EventType, EventHandler handler);

     //触发事件
     void TriggerEvent(IEvent e);

     //广播事件
     void BroadCastEvent();

 }

 public delegate void EventHandler(IEvent evt);//顺带定义了下事件委托。

 public interface IEventHandlerManger : IEvent,IDestroy
 {
     bool AddHandler(EventHandler eventHandler);

     bool RemoveHandler(EventHandler eventHandler);

     void BroadCastEvent(IEvent evt);

     void Clear();
 }

定义完两个接口后，就分别开始实现两个接口，两个接口的实现分别为EventCenter 和EventHandlerManager，代码如下  1 public class EventCenter : MonoSingleton<EventCenter>, IEventCenter

 {
     private Dictionary<Enum, IEventHandlerManger> DictHandler = new Dictionary<Enum, IEventHandlerManger>();

     private SafeQuene<IEvent> eventQuene = new SafeQuene<IEvent>();

     public bool AddEventListener(Enum EventType, EventHandler handler)
     {
         bool isSuccessed;
　　　　　　　//如果不包含EventType，就将其加入到字典中，同时新建一个EventHandlerManager()
         if (!DictHandler.ContainsKey(EventType))
         {
             DictHandler[EventType] = new EventHandlerManager();
         }
　　　　　　　　//然后将handler加入到新创建的EventHandlerManager中去。
         isSuccessed = DictHandler[EventType].AddHandler(handler);

         return isSuccessed;
     }

     public bool RemoveEventListener(Enum EventType, EventHandler handler)
     {
         if (DictHandler.ContainsKey(EventType))
         {
             DictHandler.Remove(EventType);
             return true;
         }
         else
         {
             return false;
         }
     }

     public void TriggerEvent(IEvent e)
     {
         this.eventQuene.EnQuene(e);
     }

     #region 广播事件相关

     public void Update()
     {
         BroadCastEvent();
     }
     public void BroadCastEvent()
     {
         if (eventQuene.Count<)
         {
             return;
         }

         IEvent e = eventQuene.DeQuene();

         BroadCastEvent(e);
     }

     public void BroadCastEvent(IEvent e)
     {
         if (e == null)
         {
             return;
         }

         Enum type = e.EventType;

         if (!DictHandler.ContainsKey(type))
         {
             e.DestroySelf();
         }

         DictHandler[type].BroadCastEvent(e);
         e.DestroySelf();

     }

     #endregion

     #region 清除数据相关

     public void DestroySelf()
     {
         ClearEvenQueneAndDictHandler();
     }

     public void OnDestroy()
     {
         ClearEvenQueneAndDictHandler();
     }

     public void ClearEventQuene()
     {
         eventQuene.Clear();
     }

     public void ClearEvenQueneAndDictHandler()
     {
         DictHandler.Clear();
         ClearEventQuene();
     }

     #endregion
 }

 public class EventHandlerManager : IEventHandlerManger
 {
     private Enum _EventType;

     private List<EventHandler> handler = new List<EventHandler>();

     public Enum EventType
     {
         get
         {
             return _EventType;
         }
     }

     public bool AddHandler(EventHandler eventHandler)
     {
         if (handler.Contains(eventHandler))
         {
             return false;
         }

         handler.Add(eventHandler);
         return true;
     }

     public bool RemoveHandler(EventHandler eventHandler)
     {
         if (!handler.Contains(eventHandler))
         {
             return false;
         }

         handler.Remove(eventHandler);
         return true;
     }

     public void BroadCastEvent(IEvent evt)
     {
         List<EventHandler> list = new List<EventHandler>();
         list.AddRange(handler);

         foreach (EventHandler item in list)
         {
             item(evt);
         }
     }

     public void Clear()
     {
         handler.Clear();
     }

     public void DestroySelf()
     {
         if (handler !=null)
         {
             Clear();
             handler = null;
         }
     }

 }

ok，补充说明一下，IEvent接口很简单，里面定义了一个Enum EventType的Get方法，IDestroy接口则定义了一个DestroySelf()的方法。safeQuene<T>是一个线程安全的Quene<T>，其余和Quene<T>一样。

运用这套事件广播系统也十分简单，首先，在需要有事件通知的地方预定一个enum类型，比如：

public enum FBIEvent
{
     TheyHaveGuns = ,
     TheyUseBoom =,
     TheyAreCute =,
}

然后需要定义这三个枚举类型对应的操作函数，例如：

 public class FBI
 {
     void HavaGun(IEvent e)
     {
         Debug.Log("yellow gun!");
     }

     void UseBoom(IEvent e)
     {
           Debug.Log("yellow gun!");
     }

     void TheyCute(IEvent e)
     {
          Debug.Log("Impossible");
     }
 }

最后，只需要调用EventCenter的AddEventListener()方法，将其注册进入EventCenter的DicrtHandler 字典中，就大功告成了。

　　触发流程：

　　　　1 其他方法，触发EventCenter的TriggerEvent(IEvent e)方法。

　　　　2 EventCenter 的eventQuene会增加一个实现了IEvent接口的类。

　　　　3 在Update()中不停执行的BroadCastEvent()函数，会从eventQuene中取出类，然后执行BroadCastEvent(IEvent e)方法。

　　　　4 根据传入的EventType类型，将从DirctHandler中取出对应的IEventHandlerManager对象，然后执行其BroadCastEvent（EventHandler hanlder）方法，

　　　　　这里根据多态，实际上执行的是EventHandleManager类的BroadCastEvent（EventHandler hanlder）方法。

　　　　5 因为EventHandleManager的BroadCastEvent（EventHandler hanlder）类其实就是将该类中的List Handler中的委托全部取出来，然后执行，又因为其实

　　　　  这里的每个委托在我们注册的时候，就绑定了相应的处理方法，因此，此刻执行的委托，其实就是执行的我们绑定的具体的方法。