class DelegateWeakReference
    {
        Type _delegateType;
        WeakReference _targetRef;
        MethodInfo _method;

        public DelegateWeakReference(Delegate value)
        {
            _delegateType = value.GetType();
            _method = value.Method;
            if (_method.IsStatic == false)
                _targetRef = new WeakReference(value.Target);
        }

        object Target
        {
            get { return _targetRef != null ? _targetRef.Target : null; }
        }

        public Delegate TryGetDelegate()
        {
            var target = Target;

            if (GetIsTargetCollected(target))
                return null;

            if (_method.IsStatic)
                return Delegate.CreateDelegate(_delegateType, _method);

            return Delegate.CreateDelegate(_delegateType, target, _method);
        }

        public bool IsTargetCollected
        {
            get { return GetIsTargetCollected(Target); }
        }

        bool GetIsTargetCollected(object target)
        {
            return target == null && _method.IsStatic == false;
        }

        public bool Equals(Delegate value)
        {
            return Target == value.Target && _method == value.Method;
        }
    }

    class WeakDelegate
    {
        object _lockObj = new object();
        List<DelegateWeakReference> _weakHandlers = new List<DelegateWeakReference>();

        public void Add(Delegate handler)
        {
            lock (_lockObj)
            {
                RemoveHandlersWithCollectedTarget();

                foreach (var handlerItem in handler.GetInvocationList())
                    _weakHandlers.Add(new DelegateWeakReference(handlerItem));
            }
        }

        public void Remove(Delegate handler)
        {
            lock (_lockObj)
            {
                RemoveHandlersWithCollectedTarget();

                foreach (var handlerItem in handler.GetInvocationList())
                    for (int i = _weakHandlers.Count - 1; i >= 0; i--)
                        if (_weakHandlers[i].Equals(handlerItem))
                            _weakHandlers.RemoveAt(i);
            }
        }

        public Delegate InvocationList
        {
            get
            {
                lock (_lockObj)
                {
                    RemoveHandlersWithCollectedTarget();

                    Delegate result = null;
                    foreach (var weakHandler in _weakHandlers)
                    {
                        var handler = weakHandler.TryGetDelegate();
                        if (handler != null)
                            result = Delegate.Combine(result, handler);
                    }
                    return result;
                }
            }
        }

        void RemoveHandlersWithCollectedTarget()
        {
            for (int i = 0; i < _weakHandlers.Count; i++)
                if (_weakHandlers[i].IsTargetCollected)
                    _weakHandlers.RemoveAt(i);
        }
    }

    public class WeakEventHandler
    {
        WeakDelegate _weakDelegate = new WeakDelegate();

        public void Add(EventHandler handler)
        {
            _weakDelegate.Add(handler);
        }

        public void Remove(EventHandler handler)
        {
            _weakDelegate.Remove(handler);
        }

        public void Invoke(object sender, EventArgs e)
        {
            var handler = (EventHandler)_weakDelegate.InvocationList;
            if (handler != null)
                handler(sender, e);
        }
    }

    public class WeakAction
    {
        WeakDelegate _weakDelegate = new WeakDelegate();

        public void Add(Action handler)
        {
            _weakDelegate.Add(handler);
        }

        public void Remove(Action handler)
        {
            _weakDelegate.Remove(handler);
        }

        public void Invoke()
        {
            var handler = (Action)_weakDelegate.InvocationList;
            if (handler != null)
                handler();
        }
    }

        void RemoveHandlersWithCollectedTarget()
        {
            for (int i = _weakHandlers.Count - 1; i >= 0; i--)
                if (_weakHandlers[i].IsTargetCollected)
                    _weakHandlers.RemoveAt(i);
        }