/// <summary> /// Subscribes a delegate to an event. /// </summary> /// <param name="action">The delegate that gets executed when the event is published.</param> /// <param name="threadOption">Specifies on which thread to receive the delegate callback.</param> /// <param name="keepSubscriberReferenceAlive">When <see langword="true"/>, the <see cref="PubSubEvent"/> keeps a reference to the subscriber so it does not get garbage collected.</param> /// <returns>A <see cref="SubscriptionToken"/> that uniquely identifies the added subscription.</returns> /// <remarks> /// If <paramref name="keepSubscriberReferenceAlive"/> is set to <see langword="false" />, <see cref="PubSubEvent"/> will maintain a <see cref="WeakReference"/> to the Target of the supplied <paramref name="action"/> delegate. /// If not using a WeakReference (<paramref name="keepSubscriberReferenceAlive"/> is <see langword="true" />), the user must explicitly call Unsubscribe for the event when disposing the subscriber in order to avoid memory leaks or unexpected behavior. /// <para/> /// The PubSubEvent collection is thread-safe. /// </remarks> public SubscriptionToken Subscribe(Action action, ThreadOption threadOption, bool keepSubscriberReferenceAlive) { IDelegateReference actionReference = new DelegateReference(action, keepSubscriberReferenceAlive); EventSubscription subscription; switch (threadOption) { case ThreadOption.PublisherThread: subscription = new EventSubscription(actionReference); break; case ThreadOption.BackgroundThread: subscription = new BackgroundEventSubscription(actionReference); break; case ThreadOption.UIThread: if (SynchronizationContext == null) throw new InvalidOperationException(Resources.EventAggregatorNotConstructedOnUIThread); subscription = new DispatcherEventSubscription(actionReference, SynchronizationContext); break; default: subscription = new EventSubscription(actionReference); break; } return base.InternalSubscribe(subscription); }
/// <summary> /// Subscribes a delegate to an event. /// </summary> /// <param name="action">The delegate that gets executed when the event is published.</param> /// <param name="threadOption">Specifies on which thread to receive the delegate callback.</param> /// <param name="keepSubscriberReferenceAlive">When <see langword="true"/>, the <see cref="PubSubEvent"/> keeps a reference to the subscriber so it does not get garbage collected.</param> /// <returns>A <see cref="SubscriptionToken"/> that uniquely identifies the added subscription.</returns> /// <remarks> /// If <paramref name="keepSubscriberReferenceAlive"/> is set to <see langword="false" />, <see cref="PubSubEvent"/> will maintain a <see cref="WeakReference"/> to the Target of the supplied <paramref name="action"/> delegate. /// If not using a WeakReference (<paramref name="keepSubscriberReferenceAlive"/> is <see langword="true" />), the user must explicitly call Unsubscribe for the event when disposing the subscriber in order to avoid memory leaks or unexpected behavior. /// <para/> /// The PubSubEvent collection is thread-safe. /// </remarks> public virtual SubscriptionToken Subscribe(Action action, ThreadOption threadOption, bool keepSubscriberReferenceAlive) { IDelegateReference actionReference = new DelegateReference(action, keepSubscriberReferenceAlive); EventSubscription subscription; switch (threadOption) { case ThreadOption.PublisherThread: subscription = new EventSubscription(actionReference); break; case ThreadOption.BackgroundThread: subscription = new BackgroundEventSubscription(actionReference); break; case ThreadOption.UIThread: if (SynchronizationContext == null) { throw new InvalidOperationException(Resources.EventAggregatorNotConstructedOnUIThread); } subscription = new DispatcherEventSubscription(actionReference, SynchronizationContext); break; default: subscription = new EventSubscription(actionReference); break; } return(InternalSubscribe(subscription)); }
public void KeepAlivePreventsDelegateFromBeingCollected() { var delegates = new SomeClassHandler(); var delegateReference = new DelegateReference((Action<string>)delegates.DoEvent, true); delegates = null; GC.Collect(); Assert.NotNull(delegateReference.Target); }
public void TargetShouldReturnAction() { var classHandler = new SomeClassHandler(); Action<string> myAction = new Action<string>(classHandler.MyAction); var weakAction = new DelegateReference(myAction, false); ((Action<string>)weakAction.Target)("payload"); Assert.Equal("payload", classHandler.MyActionArg); }
public void NotKeepAliveAllowsDelegateToBeCollected() { var delegates = new SomeClassHandler(); var delegateReference = new DelegateReference((Action<string>)delegates.DoEvent, false); delegates = null; GC.Collect(); Assert.Null(delegateReference.Target); }
public void ShouldReturnNullIfTargetNotAlive() { SomeClassHandler handler = new SomeClassHandler(); var weakHandlerRef = new WeakReference(handler); var action = new DelegateReference((Action<string>)handler.DoEvent, false); handler = null; GC.Collect(); Assert.False(weakHandlerRef.IsAlive); Assert.Null(action.Target); }
public void ShouldAllowCollectionOfOriginalDelegate() { var classHandler = new SomeClassHandler(); Action<string> myAction = new Action<string>(classHandler.MyAction); var weakAction = new DelegateReference(myAction, false); var originalAction = new WeakReference(myAction); myAction = null; GC.Collect(); Assert.False(originalAction.IsAlive); ((Action<string>)weakAction.Target)("payload"); Assert.Equal("payload", classHandler.MyActionArg); }
public void NotKeepAliveKeepsDelegateIfStillAlive() { var delegates = new SomeClassHandler(); var delegateReference = new DelegateReference((Action<string>)delegates.DoEvent, false); GC.Collect(); Assert.NotNull(delegateReference.Target); GC.KeepAlive(delegates); //Makes delegates ineligible for garbage collection until this point (to prevent oompiler optimizations that may release the referenced object prematurely). delegates = null; GC.Collect(); Assert.Null(delegateReference.Target); }
/// <summary> /// Subscribes a delegate to an event. /// </summary> /// <param name="action">The delegate that gets executed when the event is published.</param> /// <param name="threadOption">Specifies on which thread to receive the delegate callback.</param> /// <param name="keepSubscriberReferenceAlive">When <see langword="true"/>, the <see cref="PubSubEvent{TPayload}"/> keeps a reference to the subscriber so it does not get garbage collected.</param> /// <param name="filter">Filter to evaluate if the subscriber should receive the event.</param> /// <returns>A <see cref="SubscriptionToken"/> that uniquely identifies the added subscription.</returns> /// <remarks> /// If <paramref name="keepSubscriberReferenceAlive"/> is set to <see langword="false" />, <see cref="PubSubEvent{TPayload}"/> will maintain a <see cref="WeakReference"/> to the Target of the supplied <paramref name="action"/> delegate. /// If not using a WeakReference (<paramref name="keepSubscriberReferenceAlive"/> is <see langword="true" />), the user must explicitly call Unsubscribe for the event when disposing the subscriber in order to avoid memory leaks or unexpected behavior. /// /// The PubSubEvent collection is thread-safe. /// </remarks> public virtual SubscriptionToken Subscribe(Action <TPayload> action, ThreadOption threadOption, bool keepSubscriberReferenceAlive, Predicate <TPayload> filter) { IDelegateReference actionReference = new DelegateReference(action, keepSubscriberReferenceAlive); IDelegateReference filterReference; if (filter != null) { filterReference = new DelegateReference(filter, keepSubscriberReferenceAlive); } else { filterReference = new DelegateReference(new Predicate <TPayload>(delegate { return(true); }), true); } EventSubscription <TPayload> subscription; switch (threadOption) { case ThreadOption.PublisherThread: subscription = new EventSubscription <TPayload>(actionReference, filterReference); break; case ThreadOption.BackgroundThread: subscription = new BackgroundEventSubscription <TPayload>(actionReference, filterReference); break; case ThreadOption.UIThread: if (SynchronizationContext == null) { throw new InvalidOperationException(Resources.EventAggregatorNotConstructedOnUIThread); } subscription = new DispatcherEventSubscription <TPayload>(actionReference, filterReference, SynchronizationContext); break; default: subscription = new EventSubscription <TPayload>(actionReference, filterReference); break; } return(base.InternalSubscribe(subscription)); }
public void WeakDelegateWorksWithStaticMethodDelegates() { var action = new DelegateReference((Action)SomeClassHandler.StaticMethod, false); Assert.NotNull(action.Target); }