Beispiel #1
0
        /// <summary>
        ///     Adds the listener.
        /// </summary>
        /// <param name="listener">The listener.</param>
        /// <param name="filter">The filter.</param>
        /// <param name="keepAlive">if set to <c>true</c> [keep alive].</param>
        public DelegateReference AddListener(Delegate listener, Delegate filter = null, bool keepAlive = false)
        {
            var id      = listener.CreateDelegateUniqueId();
            var delRefs = GetListeners(id);

            if (!delRefs.IsNullOrEmpty())
            {
                var fid = filter != null?filter.CreateDelegateUniqueId() : listener.CreateDelegateUniqueId();

                foreach (var dr in delRefs)
                {
                    if (dr == null)
                    {
                        continue;
                    }
                    if (dr.Id == id || _listeners[dr].Id == fid)
                    {
                        return(dr);
                    }
                }
            }

            var delRef = new DelegateReference(listener, keepAlive);
            var filRef = filter == null ? null : new DelegateReference(filter, keepAlive);

            _listeners.Add(delRef, filRef);

            return(delRef);
        }
Beispiel #2
0
        /// <summary>
        ///     Cleanups this instance.
        /// </summary>
        private void Cleanup()
        {
            if (_listeners.IsNullOrEmpty())
            {
                return;
            }

            var res = GetDeadListeners();

            if (res.IsNullOrEmpty())
            {
                return;
            }

            // NOTE: Workaround for iOS
            var keys = new DelegateReference[res.Length];

            for (var i = 0; i < keys.Length; i++)
            {
                keys[i] = res[i];
            }

            foreach (var key in keys)
            {
                Loggers.Default.ConsoleLogger.Write("Listener_Cleanup [{0}=\"{1}\"]", key, key.Id);
                _listeners.Remove(key);
            }
        }
Beispiel #3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="DelegatePayloadBase"/> class.
        /// </summary>
        /// <param name="method">The method.</param>
        /// <param name="methodArgs">The method args.</param>
        protected DelegatePayloadBase(Delegate method = null, params object[] methodArgs)
        {
            //ArgumentValidator.AssertNotNull(method, "method");

            if (method != null)
            {
                Method = new DelegateReference(method);
            }
            MethodArgs = methodArgs;
        }
Beispiel #4
0
        /// <summary>
        ///     Called when [delegate invoked event].
        /// </summary>
        /// <param name="delRef">The delete preference.</param>
        /// <param name="args">The arguments.</param>
        /// <returns></returns>
        protected virtual bool OnDelegateInvokedEvent(DelegateReference delRef, params object[] args)
        {
            if (DelegateInvokedEvent == null)
            {
                return(false);
            }
            var arg = new WeakDelegatesManagerEventArgs(delRef);

            DelegateInvokedEvent(this, arg);
            return(arg.IsHandled);
        }
Beispiel #5
0
        /// <summary>
        ///     Gets the listener.
        /// </summary>
        /// <param name="listenerId">The listener id.</param>
        /// <returns></returns>
        public DelegateReference GetListener(string listenerId)
        {
            DelegateReference res = null;

            foreach (var pair in _listeners)
            {
                if (pair.Key.Id != listenerId)
                {
                    continue;
                }
                res = pair.Key;
                break;
            }
            return(res);
        }
Beispiel #6
0
 public WeakDelegatesManagerEventArgs(DelegateReference delRef, params object[] args)
 {
     DelegateRef = delRef;
     Args        = args;
 }