U3D观察者模式，实现1对多

迈不过友情╰ 2022-06-09 07:16 140阅读 0赞

## 观察者类 ##

using UnityEngine;
    using System.Collections;
    using System.Collections.Generic;
    
    public class Notification
    {
        /// <summary>
        /// 通知发送者
        /// </summary>
        public GameObject sender;
    
        /// <summary>
        /// 通知内容
        /// 备注：在发送消息时需要装箱、解析消息时需要拆箱
        /// </summary>
        public object param;
    
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="param"></param>
        public Notification(object param,GameObject sender = null)
        {
            this.sender = sender;
            this.param = param;
        }
    
        /// <summary>
        /// 实现ToString方法
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            return string.Format("sender={0},param={1}", this.sender, this.param);
        }
    }
    
    public class NotificationCenter {
    
        /// <summary>
        /// 通知中心单例
        /// </summary>
        private static NotificationCenter instance = null;
        public delegate void OnNotification(Notification notific);
        public static NotificationCenter Get()
        {
            if (instance == null)
            {
                instance = new NotificationCenter();
                return instance;
            }
            return instance;
        }
    
    
        //实现一对多的消息
        private Dictionary<string, Dictionary<GameObject, OnNotification>> m_dicEvent
        = new Dictionary<string, Dictionary<GameObject, OnNotification>>();
    
        public void ObjAddEventListener(string eventKey, GameObject obj,OnNotification eventListener)
        {
            if (!m_dicEvent.ContainsKey(eventKey))
            {
                Dictionary<GameObject, OnNotification> dic = new Dictionary<GameObject, OnNotification>();
                dic[obj] = eventListener;
                m_dicEvent[eventKey] = dic;
            }
            else
            {
                m_dicEvent[eventKey][obj] = eventListener;
            }
        }
    
        public void ObjRemoveEventListener(string eventKey,GameObject obj)
        {
            if (!m_dicEvent.ContainsKey(eventKey))
                return;
    
            m_dicEvent[eventKey].Remove(obj);
        }
    
    
        public void ObjDispatchEvent(string eventKey, object param = null,GameObject sender = null)
        {
            if (!m_dicEvent.ContainsKey(eventKey))
                return;
            List<GameObject> listRemoveKey = new List<GameObject>();
            List<OnNotification> listNoti = new List<OnNotification>();
            lock (m_dicEvent)
            {
                foreach (var it in m_dicEvent[eventKey])
                {
                    if (it.Key != null)
                    {
                        //it.Value(new Notification(param, sender));
                        listNoti.Add(it.Value);
                    }
                    else
                    {
                        listRemoveKey.Add(it.Key);
                    }
                }
    
                //删除已经Destory的GameObject
                for (int i = 0; i < listRemoveKey.Count; i++)
                {
                    m_dicEvent[eventKey].Remove(listRemoveKey[i]);
                }
    
                for ( int  i = 0; i < listNoti.Count; i++)
                {
                    listNoti[i](new Notification(param, sender));
                }
            }
        }
    
        /// <summary>
        /// 是否存在指定事件的监听器
        /// </summary>
        public bool HasEventListener(string eventKey)
        {
            return m_dicEvent.ContainsKey(eventKey);
        }
    
    }

## 使用： ##

订阅消息与取消订阅消息

void EventInit()
        {
            NotificationCenter.Get().ObjAddEventListener(KEventKey.m_evOpenInputTip, gameObject, OnEventOpenInputTip);
        }
    
        private void OnDestroy()
        {
            NotificationCenter.Get().ObjRemoveEventListener(KEventKey.m_evOpenInputTip, gameObject);
        }
    
        void OnEventOpenInputTip(Notification param)
        {
    
        }

发布消息

NotificationCenter.Get().ObjDispatchEvent(KEventKey.m_evDown, 1);

## 注意的地方1 ##

lock (m_dicEvent)
            {
                foreach (var it in m_dicEvent[eventKey])
                {
                    if (it.Key != null)
                    {
                        //it.Value(new Notification(param, sender));
                        listNoti.Add(it.Value);
                    }
                    else
                    {
                        listRemoveKey.Add(it.Key);
                    }
                }
    
                //删除已经Destory的GameObject
                for (int i = 0; i < listRemoveKey.Count; i++)
                {
                    m_dicEvent[eventKey].Remove(listRemoveKey[i]);
                }
    
                for ( int  i = 0; i < listNoti.Count; i++)
                {
                    listNoti[i](new Notification(param, sender));
                }
            }

发出消息时，1.根据GameObject是否存在，删除对应消息表中。 2。先保存一遍要处理的消息，因为有些委托是创建对象，如果对象初始化执行

public void Awake()
        {
            SetExamJianXiuDian();
            for (int i = 0; i < m_listId.Count; i++)
            {
                m_dicId[m_listId[i]] = false;
            }
            NotificationCenter.Get().ObjAddEventListener(KEventKey.m_evExamJianXiuDian, gameObject, OnEvJianXiuDian);
    
            NotificationCenter.Get().ObjAddEventListener(KEventKey.m_evChallengeCommit, gameObject, OnEvCommit);
            NotificationCenter.Get().ObjAddEventListener(KEventKey.m_evChallengeNext, gameObject, OnEvNext);
        }

就会产生执行委托，边遍历字典边修改字典问题

## 注意的地方2 ##

void OnEvNext(Notification noti)
        {
            if (gameObject.activeSelf == true)
            ChallengeMgr.m_instance.OnNextRet(GetScore());
        }

当执行委托时，要判断下这个脚本的GameObject是否激活状态，再去执行委托，不然出现一些难以确定bug