初级知识六——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<1)
        {
            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 = 1,
     TheyUseBoom =2,
     TheyAreCute =3,           
}

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

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中的委托全部取出来，然后执行，又因为其实

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