消息广播接受

 /// <summary>
    /// 消息广播类
    /// 此类是线程安全的
    /// </summary>
    public class Messenger
    {
        private Dictionary<string, MessengerEvents> _events;

        private static object _lockobj = new object();
        private static Messenger _messenger;
        public static Messenger Instance
        {
            get
            {
                lock (_lockobj)
                {
                    if (_messenger == null)
                    {
                        lock (_lockobj)
                            _messenger = new Messenger();
                    }
                }
                return _messenger;
            }
        }
        private Messenger()
        {
            _events = new Dictionary<string, MessengerEvents>();
        }
        /// <summary>
        /// 注册广播接收事件
        /// </summary>
        /// <param name="sign">广播标识</param>
        /// <returns></returns>
        public MessengerEvents Register(string sign)
        {
            MessengerEvents me;
            lock (_lockobj)
            {
                if (_events.ContainsKey(sign))
                    me = _events[sign];
                else
                {
                    me = new MessengerEvents();
                    _events.Add(sign, me);
                }
            }

            return me;

        }
        /// <summary>
        /// 发送广播
        /// </summary>
        /// <param name="sign">广播标识</param>
        public void Send(string sign)
        {
            lock (_lockobj)
            {
                if (_events.ContainsKey(sign))
                {
                    _events[sign].ExeFun();
                }
            }

        }
        /// <summary>
        /// 发送广播
        /// </summary>
        /// <param name="sign">广播标识</param>
        /// <param name="args">广播参数</param>
        public void Send(string sign, params dynamic[] args)
        {
            lock (_lockobj)
            {
                if (_events.ContainsKey(sign))
                {
                    _events[sign].ExeFun(args);
                }
            }

        }
        /// <summary>
        /// 发送广播
        /// </summary>
        /// <param name="sign">广播标识</param>
        /// <returns>返回结果</returns>
        public OperationResult SendByResult(string sign)
        {
            lock (_lockobj)
            {
                if (_events.ContainsKey(sign))
                {
                    return _events[sign].ExeFunResult();
                }
            }
            return null;
        }
        /// <summary>
        /// 发送广播
        /// </summary>
        /// <param name="sign">广播标识</param>
        /// <param name="args">广播参数</param>
        /// <returns>返回结果</returns>
        public OperationResult SendByResult(string sign, params dynamic[] args)
        {
            lock (_lockobj)
            {
                if (_events.ContainsKey(sign))
                {
                    return _events[sign].ExeFunResult(args);
                }
            }
            return null;
        }
    }

 

 #region 广播委托
    /// <summary>
    /// 没有参数的广播方法实现
    /// </summary>
    public delegate void Broadcast();
    /// <summary>
    /// 含有参数的广播方法实现
    /// </summary>
    /// <param name="args">参数</param>
    public delegate void BroadcastParams(dynamic[] args);
    public delegate OperationResult BroadcastResult();
    public delegate OperationResult BroadcastParamsResult(dynamic[] args);
    #endregion

    /// <summary>
    /// 广播事件定义类
    /// </summary>
    public class MessengerEvents
    {
        /// <summary>
        /// 无参数无返回值的广播接收事件
        /// </summary>
        public event Broadcast Receive;
        /// <summary>
        /// 含有参数无返回值的广播接收事件
        /// </summary>
        public event BroadcastParams ReceiveByParams;
        /// <summary>
        /// 无参数具有返回值的广播接收事件
        /// </summary>
        public event BroadcastResult ReceiveResult;
        /// <summary>
        /// 含有参数具有返回值的广播接收事件
        /// </summary>
        public event BroadcastParamsResult ReceiveResultByParams;

        #region 方法
        internal void ExeFun()
        {
            if (Receive != null)
                Receive();
        }
        internal void ExeFun(params dynamic[] args)
        {
            if (ReceiveByParams != null)
                ReceiveByParams(args);
        }

        internal OperationResult ExeFunResult()
        {
            if (Receive != null)
                return ReceiveResult();

            return null;
        }
        internal OperationResult ExeFunResult(params dynamic[] args)
        {
            if (ReceiveByParams != null)
                return ReceiveResultByParams(args);

            return null;
        }
        #endregion
    }