[Unity] 用观察者模式实现处理数据的分发

前面文章写到了通过SocketManager去接受和处理从服务器来的数据，那么处理好之后，我们可以通过观察者模式去分发给不同的客户端逻辑处理组件去处理。

SocketManager发布消息到ResponseEventManager，各种Synchronizer去订阅消息处理，EventDispatcher每帧都会处理从SocketManager来的消息。IClientDataSynchronizer就比如说用户状态管理器，游戏数据管理器，房间管理器，这些需要实时更新的模块。

这只是简化了，只留核心结构的设计，具体的还有很多细节，要根据实际情况来处理。

public delegate void DelegateEventHandler(EventMessage e);

    public class EventDispatcher : MonoBehaviour
    {
        #region --- Singlton ---

        private Queue<EventMessage> m_msgQueue = new Queue<EventMessage>();
        private Dictionary<object, List<DelegateEventHandler> >
            m_msgHandlers = new Dictionary<object, List<DelegateEventHandler>>();

        private static object m_forMsg = new object();

        #endregion

        #region Public Methods

        private void OnDestory()
        {
            m_msgQueue.Clear();
            m_msgHandlers.Clear();
        }

        public void Register(object msgType, DelegateEventHandler handler)
        {
            lock (m_forMsg)
            {
                List<DelegateEventHandler> handlers = null;

                if (!m_msgHandlers.TryGetValue(msgType, out handlers))
                {
                    handlers = new List<DelegateEventHandler>();
                    m_msgHandlers.Add(msgType, handlers);
                }

                handlers.Add(handler);
            }
        }

        public void UnRegister(object msgType, DelegateEventHandler handler)
        {
            lock (m_forMsg)
            {
                List<DelegateEventHandler> handlers = null;
                if (m_msgHandlers.TryGetValue(msgType, out handlers))
                {
                    handlers.Remove(handler);
                }
            }
        }

        public void PostMessage(object msgType, object msg)
        {
            lock (m_forMsg)
            { 
                EventMessage rspMsg = new EventMessage(msgType, msg);
                m_msgQueue.Enqueue(rspMsg);
            }
        }

        public void Update()
        {
            lock (m_forMsg)
            {
                foreach (EventMessage msg in m_msgQueue.ToArray())
                {
                    SendMessage(msg);
                }

                m_msgQueue.Clear();
            }
        }

        #endregion

        #region Private Methods

        private void SendMessage(EventMessage msg)
        {
            List<DelegateEventHandler> handlers = null;
            if (m_msgHandlers.TryGetValue(msg.Type, out handlers))
            {
                
                if (handlers.Count == 0)
                    return;

                for (int index = 0; index < handlers.Count; index++)
                {
                    DelegateEventHandler item = handlers[index];
                    item(msg);
                }
                
            }
        }

        #endregion

    }