public void OnEvent(object sender, WeakEvent ev, PropertyChangedEventArgs e)
{
if (e.PropertyName == _property.Name || string.IsNullOrEmpty(e.PropertyName))
{
SendCurrentValue();
}
}
public void When_registering_typed_weak_event_then_it_should_still_be_here_when_target_referenced()
{
//// Arrange
var eventCalled = false;
var target = new MockEventTargetClass(() =>
{
eventCalled = true;
});
var obj = new MockObservableObject();
//// Act
WeakEvent.RegisterEvent <MockEventTargetClass, PropertyChangedEventHandler, PropertyChangedEventArgs>(
target,
h => obj.PropertyChanged += h,
h => obj.PropertyChanged -= h,
h => (o, e) => h(o, e),
(t, sender, args) => t.Callback(sender, args));
obj.Name = "test1";
Assert.IsTrue(eventCalled);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
eventCalled = false;
obj.Name = "test2";
//// Assert
Assert.IsTrue(eventCalled);
target.Action = null;
}
public void OnEvent(object?sender, WeakEvent ev, NotifyCollectionChangedEventArgs args)
{
if (ShouldNotifyListeners(args))
{
SendCurrentValue();
}
}
public void When_registering_weak_event_then_it_should_still_be_here_when_target_referenced()
{
//// Arrange
var eventCalled = false;
var target = new MockEventTargetClass(() =>
{
eventCalled = true;
});
var obj = new MockObservableObject();
//// Act
WeakEvent.RegisterEvent <MockObservableObject, PropertyChangedEventArgs>(obj, "PropertyChanged", target.Callback);
obj.Name = "test1";
Assert.IsTrue(eventCalled);
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
eventCalled = false;
obj.Name = "test2";
//// Assert
Assert.IsTrue(eventCalled);
target.Action = null;
}
public BrowserControl()
{
InitializeComponent();
if (DesignTimeProperty.InDesignMode)
{
return;
}
_mouseClickEvent = new WeakEvent <MouseButtonEventHandler>();
MouseLeftButtonDown += OnMouseLeftButtonDown;
MouseLeftButtonUp += OnMouseLeftButtonUp;
MouseMove += OnMouseMove;
LostMouseCapture += OnLostMouseCapture;
MouseWheel += OnMouseWheel;
SizeChanged += (sender, args) =>
{
if (ScaleOnResize)
{
ScaleInCenter();
}
};
//_popup = new Popup();
//IsManipulationEnabled = true;
//ManipulationDelta += OnManipulationDelta;
_scaleFactor = 0;
_instruments = new List <IInstrument>();
UpdateScale();
ZoomInCommand = new RelayCommand(() => ZoomIn());
ZoomOutCommand = new RelayCommand(() => ZoomOut());
ZoomCenterCommand = new RelayCommand(() => ScaleInCenter());
}
public OrientationTrigger()
{
var win = Window.Current;
WeakEvent.Subscribe <WindowSizeChangedEventHandler>(win, nameof(win.SizeChanged), Window_SizeChanged);
CalculateState();
}
public MiniWebServer(Uri BaseURL)
{
this.IdleTimeout = true;
this.KeepAliveTimer = new LifeTimeMonitor();
this.SessionTimer = new LifeTimeMonitor();
this.SessionTable = new Hashtable();
this.OnSessionEvent = new WeakEvent();
this.OnReceiveEvent = new WeakEvent();
this.OnHeaderEvent = new WeakEvent();
InstanceTracker.Add(this);
this.SessionTimer.OnExpired += new LifeTimeMonitor.LifeTimeHandler(this.SessionTimerSink);
this.KeepAliveTimer.OnExpired += new LifeTimeMonitor.LifeTimeHandler(this.KeepAliveSink);
string host = BaseURL.Host;
if (BaseURL.HostNameType == UriHostNameType.Dns)
{
throw new MiniWebServerException("Uri must explicitly define IP Address");
}
IPEndPoint localEP = new IPEndPoint(IPAddress.Parse(host), BaseURL.Port);
this.endpoint_local = localEP;
this.MainSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
this.MainSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
this.MainSocket.Bind(localEP);
this.MainSocket.Listen(0x19);
this.MainSocket.BeginAccept(new AsyncCallback(this.Accept), null);
this.KeepAliveTimer.Add(false, 7);
}
public Subscription(WeakEvent <TSender, TEventArgs> ev, TSender target)
{
_ev = ev;
_target = target;
_compact = Compact;
_unsubscribe = ev._subscribe(target, OnEvent);
}
public static void TestWeakEvent()
{
object a = new object();
bool w1Executed = false;
int val = 0;
WeakCallback <int> w1 = new WeakCallback <object, int>(a, (A, i) => { w1Executed = true; val = i; });
w1.Execute(1);
Assert.True(w1Executed);
Assert.AreEqual(1, val);
w1Executed = false;
a = null;
GC.Collect();
GC.WaitForPendingFinalizers();
w1.Execute(2);
Assert.AreEqual(1, val);
Assert.False(w1Executed);
object b = new object();
bool w2Executed = false;
WeakCallback <int> w2 = new WeakCallback <object, int>(b, (A, i) => { w2Executed = true; val = i; });
WeakEvent <int> e = new WeakEvent <int>();
e.Register(w1);
e.Register(w2);
e.Execute(3);
Assert.True(w2Executed);
}
public NetworkInfo(InterfaceHandler onNewInterfaceSink)
{
this.OnNewInterfaceEvent = new WeakEvent();
this.OnInterfaceDisabledEvent = new WeakEvent();
this.InterfacePoller = new LifeTimeMonitor();
this.AddressTable = new ArrayList();
InstanceTracker.Add(this);
this.InterfacePoller.OnExpired += new LifeTimeMonitor.LifeTimeHandler(this.PollInterface);
this.HostName = Dns.GetHostName();
IPHostEntry hostByName = Dns.GetHostByName(this.HostName);
this.AddressTable = new ArrayList(hostByName.AddressList);
if (!this.AddressTable.Contains(IPAddress.Loopback))
{
this.AddressTable.Add(IPAddress.Loopback);
}
if (onNewInterfaceSink != null)
{
this.OnNewInterface += onNewInterfaceSink;
foreach (IPAddress address in this.AddressTable)
{
this.OnNewInterfaceEvent.Fire(this, address);
}
}
this.InterfacePoller.Add(this, NetworkPollSeconds);
}
public DispatchOnSet(int senderID)
{
Console.LogWarningDebug("This method is obsolete and shouldn't be used anymore");
_senderID = new EGID(senderID, OBSOLETE_GROUP);
_subscribers = new WeakEvent <EGID, T>();
}
void IWeakEventSubscriber <AvaloniaPropertyChangedEventArgs> .
OnEvent(object?notifyPropertyChanged, WeakEvent ev, AvaloniaPropertyChangedEventArgs e)
{
if (e.Property == _property)
{
SendCurrentValue();
}
}
void Add <TEventArgs>(WeakEvent <EventHandler <TEventArgs>, TEventArgs> weakEvent, EventHandler <TEventArgs> eventHandler) where TEventArgs : EventArgs
{
if (!viewModel.IsAlive)
{
return;
}
weakEvent.Add(eventHandler);
}
void IWeakEventSubscriber <PropertyChangedEventArgs> .
OnEvent(object?notifyPropertyChanged, WeakEvent ev, PropertyChangedEventArgs e)
{
if (e.PropertyName == _property.Name || string.IsNullOrEmpty(e.PropertyName))
{
_eventRaised = true;
SendCurrentValue();
}
}
/// <summary>
///
/// </summary>
/// <param name="action"></param>
/// <param name="condition"></param>
public AsyncRelayCommand(Func <object, Task> action, Predicate <object> condition = null)
{
this.action = new WeakDelegate <Func <object, Task> >(action);
this.condition = null != condition ? new WeakPredicate <object>(condition) : null;
access = new AsyncReaderWriterLock();
executeChanged = new WeakEventHandler();
complete = new WeakEvent <TypedEventHandler <IAsyncCommand, CommandCompleteEventArgs> >();
propertyChanged = new WeakEvent <PropertyChangedEventHandler>();
}
/// <summary>
/// Initializes a new instance of the <see cref="OrientationStateTrigger" /> class.
/// </summary>
public OrientationStateTrigger()
{
if (!DesignMode.DesignModeEnabled)
{
WeakEvent.Subscribe <TypedEventHandler <DisplayInformation, object> >(
DisplayInformation.GetForCurrentView(), "OrientationChanged",
OrientationStateTrigger_OrientationChanged);
}
}
/// <summary>
/// Initializes a new instance of the RelayCommand class.
/// </summary>
/// <param name="execute">The execution logic.</param>
/// <param name="canExecute">The execution status logic.</param>
/// <exception cref="ArgumentNullException">If the execute argument is null.</exception>
public RelayCommand(Action execute, Func<bool> canExecute)
{
if (execute == null)
{
throw new ArgumentNullException(nameof(execute));
}
_execute = execute;
_canExecute = canExecute;
_canExecuteChanged = new WeakEvent<EventHandler>();
}
public void FiresForEachListener()
{
WeakEvent<EventHandler<EventArgs1>> handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
handler.Add(EventReceiver1.Callback);
handler.Raise(null, null);
Assert.That(EventReceiver1.CallCounter, Is.EqualTo(2));
}
/// <summary>
/// Initializes a new <see cref="OrientationTrigger"/> instance.
/// </summary>
public OrientationTrigger()
{
// Get application main window
var win = Window.Current;
// Create a weak subscription to the SizeChanged event so that we don't pin the trigger or page in memory
WeakEvent.Subscribe <WindowSizeChangedEventHandler>(win, nameof(win.SizeChanged), Window_SizeChanged);
// Calculate the initial state
CalculateState();
}
public void Test_WeakBindEvent_NormalProperty()
{
var viewModel = new TestViewModel();
var view = new TestView();
var propertyBinding = new WeakPropertyBinding(view, "Text1", viewModel, "Name")
.Initialize <WeakPropertyBinding>();
var weakEvent = new WeakEvent(viewModel);
Assert.IsFalse(weakEvent.IsAttached);
}
public SafeTimer()
{
this.ElapsedWeakEvent = new WeakEvent();
this.Interval = 0;
this.AutoReset = false;
this.mre = new ManualResetEvent(false);
this.RegLock = new object();
this.WaitFlag = false;
this.timeout = 0;
this.WOTcb = new WaitOrTimerCallback(this.HandleTimer);
InstanceTracker.Add(this);
}
public void ShouldForwardArgs()
{
var handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
var args = new EventArgs1(2);
handler.Raise(null, args);
Assert.That(EventReceiver1.Args, Is.EqualTo(args));
}
public void ForwardsArgsWhenRaising()
{
WeakEvent<EventHandler<EventArgs1>> handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
EventArgs1 args = new EventArgs1(2);
handler.Raise(null, args);
Assert.That(EventReceiver1.Args, Is.EqualTo(args));
}
private void TrackCollection()
{
if (Items is ObservableCollection <T> )
{
var collection = (ObservableCollection <T>)Items;
itemsChangedHandler = WeakEvent.Set <ObservableView <T>, NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(
h => (o, e) => h(o, e),
h => collection.CollectionChanged += h,
h => collection.CollectionChanged -= h,
this, (s, e) => s.OnOriginalCollectionChanged(s, e));
}
}
public void ForwardsSenderWhenRaising()
{
WeakEvent<EventHandler<EventArgs1>> handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
EventArgs1 args = new EventArgs1(2);
object sender = new object();
handler.Raise(sender, args);
Assert.That(EventReceiver1.Sender, Is.EqualTo(sender));
}
private void TrackCollection()
{
if (Items is ObservableCollection <TItem> )
{
var collection = (ObservableCollection <TItem>)Items;
_itemsChangedHandler = WeakEvent.RegisterEvent <ObservableCollectionViewBase <TItem>, NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(
this,
h => collection.CollectionChanged += h,
h => collection.CollectionChanged -= h,
h => (o, e) => h(o, e),
(subscriber, s, e) => subscriber.OnOriginalCollectionChanged(s, e));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="InteractionCapabilityTrigger"/> class.
/// </summary>
public InteractionCapabilityTrigger()
{
if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
{
var weakEvent =
new WeakEvent<InteractionCapabilityTrigger, object, WindowSizeChangedEventArgs>(this)
{
EventAction = (instance, source, eventArgs) => InteractionCapabilitiesTrigger_SizeChanged(source, eventArgs),
DetachAction = (instance, weakEventListener) => Window.Current.SizeChanged -= weakEventListener.Handler
};
Window.Current.SizeChanged += weakEvent.Handler;
UpdateTrigger(InteractionMode);
}
}
/// <summary>
/// Converts a WeakEvent conforming to the standard .NET event pattern into an observable
/// sequence, subscribing weakly.
/// </summary>
/// <typeparam name="TTarget">The type of target.</typeparam>
/// <typeparam name="TEventArgs">The type of the event args.</typeparam>
/// <param name="target">Object instance that exposes the event to convert.</param>
/// <param name="ev">The weak event to convert.</param>
/// <returns></returns>
public static IObservable <EventPattern <object, TEventArgs> > FromEventPattern <TTarget, TEventArgs>(
TTarget target, WeakEvent <TTarget, TEventArgs> ev)
where TEventArgs : EventArgs where TTarget : class
{
_ = target ?? throw new ArgumentNullException(nameof(target));
_ = ev ?? throw new ArgumentNullException(nameof(ev));
return(Observable.Create <EventPattern <object, TEventArgs> >(observer =>
{
var handler = new Handler <TEventArgs>(observer);
ev.Subscribe(target, handler);
return () => ev.Unsubscribe(target, handler);
}).Publish().RefCount());
}
/// <summary>
/// Initializes a new instance of the <see cref="InteractionCapabilityTrigger"/> class.
/// </summary>
public InteractionCapabilityTrigger()
{
if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled)
{
var weakEvent =
new WeakEvent <InteractionCapabilityTrigger, object, WindowSizeChangedEventArgs>(this)
{
EventAction = (instance, source, eventArgs) => InteractionCapabilitiesTrigger_SizeChanged(source, eventArgs),
DetachAction = (instance, weakEventListener) => Window.Current.SizeChanged -= weakEventListener.Handler
};
Window.Current.SizeChanged += weakEvent.Handler;
UpdateTrigger(InteractionMode);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="execute">The action that is performed when the command is executed.</param>
/// <param name="canExecute">
/// A predicate that determines whether the command can be executed or not.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="execute"/> is <see langword="null"/>.
/// </exception>
public DelegateCommand(Action<T> execute, Func<T, bool> canExecute = null)
{
if (execute == null)
throw new ArgumentNullException(nameof(execute));
_execute = execute;
if (canExecute != null)
{
_canExecute = canExecute;
_canExecuteChangedEvent = new WeakEvent<EventHandler>();
}
}
/// <summary>
/// Registers a handler for the weak event which occurs after the <see cref="Settings"/> have been updated in the file.
/// The event handler cannot be an anonymous method.
/// For best performance, the class in which the event handler method is defined should implement <see cref="IWeakEventTarget"/>.
/// </summary>
/// <exception cref="ArgumentNullException">
/// <paramref name="property"/> and/or <paramref name="eventHandler"/> are null.
/// </exception>
public void RegisterSettingsChangedHandler(SettingProperty property, Action <object, EventArgs> eventHandler)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
if (eventHandler == null)
{
throw new ArgumentNullException(nameof(eventHandler));
}
WeakEvent <object, EventArgs> keyedEvent = settingsChangedEvents.GetOrAdd(property.Name, key => new WeakEvent <object, EventArgs>());
keyedEvent.AddListener(eventHandler);
}
private void RegisterEvent(INotifyPropertyChanged item)
{
if (events.ContainsKey(item))
{
return;
}
var handler = WeakEvent.Set <ObservableView <T>, PropertyChangedEventHandler, PropertyChangedEventArgs>(
h => (o, e) => h(o, e),
h => item.PropertyChanged += h,
h => item.PropertyChanged -= h,
this, (s, e) => s.UpdateList());
events.Add(item, handler);
}
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="execute">The action that is performed when the command is executed.</param>
/// <param name="canExecute">
/// A predicate that determines whether the command can be executed or not.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="execute"/> is <see langword="null"/>.
/// </exception>
public DelegateCommand(Action execute, Func<bool> canExecute = null)
{
if (execute == null)
throw new ArgumentNullException(nameof(execute));
_execute = execute;
if (canExecute != null)
{
_canExecute = canExecute;
#if !NET45
_canExecuteChangedEvent = new WeakEvent<EventHandler>();
#endif
}
}
public AsyncSocket(int BufferSize)
{
this.StopThread = null;
this.SentDisconnect = false;
this.BufferReadLength = 0;
this.BufferBeginPointer = 0;
this.BufferEndPointer = 0;
this.BufferSize = 0;
this.OnReceiveEvent = new WeakEvent();
this.OnSendReadyEvent = new WeakEvent();
this.OnConnectEvent = new WeakEvent();
this.OnConnectFailedEvent = new WeakEvent();
this.OnDisconnectEvent = new WeakEvent();
this._WriteStream = null;
this.MainBuffer = new byte[BufferSize];
}
private void RegisterEvent(INotifyPropertyChanged item)
{
if (_events.ContainsKey(item))
{
return;
}
var handler = WeakEvent.RegisterEvent <ObservableCollectionViewBase <TItem>, PropertyChangedEventHandler, PropertyChangedEventArgs>(
this,
h => item.PropertyChanged += h,
h => item.PropertyChanged -= h,
h => (o, e) => h(o, e),
(subscriber, s, e) => subscriber.Refresh());
_events.Add(item, handler);
}
//--------------------------------------------------------------
#region Creation & Cleanup
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="DelegateCommand"/> class.
/// </summary>
/// <param name="execute">The action that is performed when the command is executed.</param>
/// <param name="canExecute">
/// A predicate that determines whether the command can be executed or not.
/// </param>
/// <exception cref="ArgumentNullException">
/// <paramref name="execute"/> is <see langword="null"/>.
/// </exception>
public DelegateCommand(Action execute, Func <bool> canExecute = null)
{
if (execute == null)
{
throw new ArgumentNullException(nameof(execute));
}
_execute = execute;
if (canExecute != null)
{
_canExecute = canExecute;
#if !NET45
_canExecuteChangedEvent = new WeakEvent <EventHandler>();
#endif
}
}
public void Test_MemoryLeak_WeakEvent()
{
// 1. Normal Event will hold the strong reference which prevent the GC collect.
var view = new TestView();
var viewModel = new TestViewModel();
var reference = new WeakReference(view);
viewModel.TestViewModelEvent += view.OnEventOccured;
viewModel.RaiseTestViewModelEvent();
Assert.AreEqual(1, view.EventCount);
Assert.AreEqual(1, viewModel.GetTestViewModelEventInvocationCount());
view = null;
GC.Collect();
Assert.IsTrue(reference.IsAlive); // Still live
viewModel.TestViewModelEvent -= reference.GetTarget <TestView>().OnEventOccured;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
Assert.IsFalse(reference.IsAlive);
reference = null;
Assert.IsNull(reference.GetTarget <TestView>());
// 2. WeakEvent hold the weak reference which will not prevent GC collect.
var view2 = new TestView();
var viewModel2 = new TestViewModel();
var reference2 = new WeakReference(view2);
var weakEvent = new WeakEvent(view2);
weakEvent.AttachEvent(viewModel2, null, "TestViewModelEvent", "OnEventOccured");
viewModel2.RaiseTestViewModelEvent();
Assert.AreEqual(1, view2.EventCount);
view2 = null;
GC.Collect();
Assert.IsFalse(reference2.IsAlive);
viewModel2.RaiseTestViewModelEvent();
Assert.AreEqual(0, viewModel2.GetTestViewModelEventInvocationCount());
}
public void StaticConstructorShouldThrowOnInvalidEventHandler2()
{
var weakEvent = new WeakEvent<Action<object, object>>();
}
public void ShouldIgnoreGarbageCollectedSubscribers()
{
var handler = new WeakEvent<EventHandler<EventArgs1>>();
var receiver = new EventReceiver1();
var receiverReference = new WeakReference(receiver);
var args = new EventArgs1(2);
var sender = new object();
handler.Add(receiver.Callback);
handler.Raise(sender, args);
receiver = null;
GC.Collect();
Assert.That(receiverReference.IsAlive, Is.False);
handler.Raise(sender, args);
Assert.That(handler.ListenersCount, Is.EqualTo(0));
}
public void StaticConstructorShouldThrowOnInvalidEventHandler3()
{
var weakEvent = new WeakEvent<Func<object, EventArgs, int>>();
}
private RateLimitAwaiter CreateRateLimitAwaiter()
{
_weakEvent = new WeakEvent<EventHandler<QueryAwaitingEventArgs>>();
return _fakeBuilder.GenerateClass(new ConstructorNamedParameter("queryAwaitingForRateLimitWeakEvent", _weakEvent));
}
public Publisher1()
{
_myTestHandler = new WeakEvent<EventHandler<EventArgs1>>();
}
public void AllowTypesCompatibleWithEventHandler()
{
var weakEvent = new WeakEvent<Action<object, EventArgs>>();
}
public void ThrowsWhenRegisteringClosureAsHandler()
{
WeakEvent<EventHandler<EventArgs1>> handler = new WeakEvent<EventHandler<EventArgs1>>();
#pragma warning disable 219
int tempNumber;
#pragma warning restore 219
Assert.Throws<ArgumentException>(() => handler.Add((sender, e) => { tempNumber = e.ANumber; }));
}
public void ThrowsWhenRaisingGivenInvalidEventArgType()
{
WeakEvent<EventHandler<EventArgs1>> handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
Assert.Throws<InvalidCastException>(() => handler.Raise(null, new EventArgs2()));
}
public void PerTestTearDown()
{
EventReceiver1 = null;
EventReceiver2 = null;
_myTestHandler = null;
}
public InternalTweetinviEvents()
{
_queryBeforeExecuteWeakEvent = new WeakEvent<EventHandler<QueryBeforeExecuteEventArgs>>();
_queryAfterExecuteWeakEvent = new WeakEvent<EventHandler<QueryAfterExecuteEventArgs>>();
}
public void StaticConstructorShouldThrowOnInvalidEventHandler()
{
var weakEvent = new WeakEvent<Action<int, EventArgs>>();
}
public void ShouldThrowWhenRegisteringClosure()
{
var handler = new WeakEvent<EventHandler<EventArgs1>>();
int tempNumber;
Assert.Throws<ArgumentException>(() => handler.Add((sender, e) => { tempNumber = e.ANumber; }));
}
public void ShouldThrowWhenRaisingEvent()
{
var handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
Assert.Throws<InvalidCastException>(() => handler.Raise(null, new EventArgs2()));
}
public void IgnoresGarbageCollectedListeners()
{
WeakEvent<EventHandler<EventArgs1>> handler = new WeakEvent<EventHandler<EventArgs1>>();
EventReceiver1 receiver = new EventReceiver1();
WeakReference receiverReference = new WeakReference(receiver);
EventArgs1 args = new EventArgs1(2);
object sender = new object();
handler.Add(receiver.Callback);
handler.Raise(sender, args);
// ReSharper disable RedundantAssignment
receiver = null;
// ReSharper restore RedundantAssignment
GC.Collect();
Assert.That(receiverReference.IsAlive, Is.False);
handler.Raise(sender, args);
Assert.That(handler.ListenersCount, Is.EqualTo(0));
}
public void ShouldForwardSender()
{
var handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
var args = new EventArgs1(2);
var sender = new object();
handler.Raise(sender, args);
Assert.That(EventReceiver1.Sender, Is.EqualTo(sender));
}
public void StaticConstructorShouldThrowOnInvalidType()
{
var weakEvent = new WeakEvent<object>();
}
public void PerTestSetUp()
{
EventReceiver1 = new EventReceiver1();
EventReceiver2 = new EventReceiver2();
_myTestHandler = new WeakEvent<EventHandler<EventArgs1>>();
}
public void ShouldNotifyEachSubscriber()
{
var handler = new WeakEvent<EventHandler<EventArgs1>>();
handler.Add(EventReceiver1.Callback);
handler.Add(EventReceiver1.Callback);
handler.Raise(null, null);
Assert.That(EventReceiver1.CallCounter, Is.EqualTo(2));
}
protected BaseDisposableObject()
{
_disposing = new WeakEvent<EventHandler<EventArgs>>();
_disposed = new WeakEvent<EventHandler<EventArgs>>();
}
