public void RemoveAllEventHandlers_RemoveMethodHasNoTarget_Success() { Delegate handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable<Delegate>(); EventRegistrationToken token1 = tokenTable.AddEventHandler(handler); EventRegistrationToken token2 = tokenTable.AddEventHandler(handler); EventRegistrationToken token3 = tokenTable.AddEventHandler(handler); Action<EventRegistrationToken> removeMethod = RemoveAllMethod; WindowsRuntimeMarshal.AddEventHandler(eventHandler => token1, removeMethod, handler); WindowsRuntimeMarshal.AddEventHandler(eventHandler => token2, removeMethod, handler); bool removeMethodWithTargetCalled = false; WindowsRuntimeMarshal.AddEventHandler(eventHandler => token3, token => removeMethodWithTargetCalled = false, handler); // Removing with the same handler but with a different method is a nop. WindowsRuntimeMarshal.RemoveAllEventHandlers(token => RemoveMethodCalled = true); Assert.Empty(RemoveAllTokens); Assert.False(DifferentRemoveAllMethodCalled); Assert.False(removeMethodWithTargetCalled); WindowsRuntimeMarshal.RemoveAllEventHandlers(DifferentRemoveAllMethod); Assert.Empty(RemoveAllTokens); Assert.False(DifferentRemoveAllMethodCalled); Assert.False(removeMethodWithTargetCalled); // Removing the same handler and the same method works. WindowsRuntimeMarshal.RemoveAllEventHandlers(removeMethod); Assert.Equal(new EventRegistrationToken[] { token1, token2 }, RemoveAllTokens); Assert.False(DifferentRemoveAllMethodCalled); Assert.False(removeMethodWithTargetCalled); }
public void RemoveEventHandler_MultipleTimes_RemovesSingleDelegateFromTable() { EventHandler handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable <Delegate>(); tokenTable.AddEventHandler(handler); tokenTable.AddEventHandler(handler); tokenTable.RemoveEventHandler(handler); Assert.Equal(new Delegate[] { handler }, tokenTable.InvocationList.GetInvocationList()); tokenTable.RemoveEventHandler(handler); Assert.Null(tokenTable.InvocationList); }
public void AddEventHandler_MultipleTimes_AddsEachDelegateToInvocationList() { EventHandler handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable <Delegate>(); EventRegistrationToken token1 = tokenTable.AddEventHandler(handler); Assert.NotEqual(0, token1.GetHashCode()); EventRegistrationToken token2 = tokenTable.AddEventHandler(handler); Assert.NotEqual(token1.GetHashCode(), token2.GetHashCode()); Assert.Equal(new Delegate[] { handler, handler }, tokenTable.InvocationList.GetInvocationList()); }
public void RemoveEventHandler_RemoveMethodHasTarget_Success() { bool removeMethodCalled = false; Delegate handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable<Delegate>(); EventRegistrationToken addToken = tokenTable.AddEventHandler(handler); Action<EventRegistrationToken> removeMethod = token => { Assert.False(removeMethodCalled); removeMethodCalled = true; Assert.Equal(addToken, token); }; WindowsRuntimeMarshal.AddEventHandler(eventHandler => addToken, removeMethod, handler); // Removing with the same handler but with a different method is a nop. WindowsRuntimeMarshal.RemoveEventHandler(token => removeMethodCalled = true, handler); Assert.False(removeMethodCalled); WindowsRuntimeMarshal.RemoveEventHandler(DifferentRemoveMethod, handler); Assert.False(removeMethodCalled); // Removing with a different handler but with the same method is a nop. WindowsRuntimeMarshal.RemoveEventHandler(removeMethod, new EventHandler(EventHandlerMethod2)); Assert.False(removeMethodCalled); // Removing the same handler and the same method works. WindowsRuntimeMarshal.RemoveEventHandler(removeMethod, handler); Assert.True(removeMethodCalled); }
public void RemoveEventHandler_RemoveMethodHasNoTarget_Success() { Delegate handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable<Delegate>(); ExpectedRemoveToken = tokenTable.AddEventHandler(handler); Action<EventRegistrationToken> removeMethod = RemoveMethod; WindowsRuntimeMarshal.AddEventHandler(eventHandler => ExpectedRemoveToken, removeMethod, handler); // Removing with the same handler but with a different method is a nop. WindowsRuntimeMarshal.RemoveEventHandler(token => RemoveMethodCalled = true, handler); Assert.False(RemoveMethodCalled); WindowsRuntimeMarshal.RemoveEventHandler(DifferentRemoveMethod, handler); Assert.False(RemoveMethodCalled); // Removing with a different handler but with the same method is a nop. WindowsRuntimeMarshal.RemoveEventHandler(removeMethod, new EventHandler(EventHandlerMethod2)); Assert.False(RemoveMethodCalled); // Removing the same handler and the same method works. WindowsRuntimeMarshal.RemoveEventHandler(removeMethod, handler); Assert.True(RemoveMethodCalled); }
/// <summary> /// Adds a handler to the observed event. /// </summary> /// <param name="handler"> /// The handler to add. /// </param> /// <returns> /// A token that can be used to remove the event handler from the /// invocation list. /// </returns> public EventRegistrationToken Add(TypedEventHandler <TSender, TResult> handler) { // Check if we currently have no subscribers bool wasNull = (eventTable.InvocationList == null); // Add var reg = eventTable.AddEventHandler(handler); // Notify of add if (observer != null) { observer.Added(this); } // If first handler, notify if ((wasNull) && (eventTable.InvocationList != null)) { if (firstAdded != null) { firstAdded(); } if (observer != null) { observer.FirstAdded(this); } } // Return the registration return(reg); }
public void InvocationList_SetNull_GetReturnsNull() { var tokenTable = new EventRegistrationTokenTable <Delegate>(); tokenTable.AddEventHandler(new EventHandler(EventHandlerMethod1)); tokenTable.InvocationList = null; Assert.Null(tokenTable.InvocationList); }
public static IEnumerable <object[]> Equals_TestData() { var tokenTable = new EventRegistrationTokenTable <Delegate>(); EventRegistrationToken token = tokenTable.AddEventHandler(new EventHandler(EventHandlerMethod1)); EventRegistrationToken emptyToken = tokenTable.AddEventHandler(null); yield return(new object[] { token, token, true }); yield return(new object[] { token, emptyToken, false }); yield return(new object[] { emptyToken, emptyToken, true }); yield return(new object[] { emptyToken, new EventRegistrationToken(), true }); yield return(new object[] { token, new object(), false }); yield return(new object[] { token, null, false }); }
public void AddEventHandler_Null_ReturnsZeroToken() { var tokenTable = new EventRegistrationTokenTable <Delegate>(); EventRegistrationToken token = tokenTable.AddEventHandler(null); Assert.Equal(0, token.GetHashCode()); // Removing this token should be a nop. tokenTable.RemoveEventHandler(token); }
public void AddEventHandler_SingleInvocationList_AddsSingleDelegateToInvocationList() { EventHandler handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable <Delegate>(); EventRegistrationToken token = tokenTable.AddEventHandler(handler); Assert.NotEqual(0, token.GetHashCode()); Assert.Equal(new Delegate[] { handler }, tokenTable.InvocationList.GetInvocationList()); }
// EventRegistrationToken PropertyChanged.add(PropertyChangedEventHandler value) internal EventRegistrationToken add_PropertyChanged(PropertyChangedEventHandler value) { INotifyPropertyChanged _this = Unsafe.As <INotifyPropertyChanged>(this); EventRegistrationTokenTable <PropertyChangedEventHandler> table = s_weakTable.GetOrCreateValue(_this); EventRegistrationToken token = table.AddEventHandler(value); _this.PropertyChanged += value; return(token); }
// EventRegistrationToken PropertyChanged.add(EventHandler<object> value) private EventRegistrationToken add_CanExecuteChanged(EventHandler <object> value) { ICommand _this = Unsafe.As <ICommand>(this); EventRegistrationTokenTable <EventHandler> table = s_weakTable.GetOrCreateValue(_this); EventHandler handler = ICommandAdapterHelpers.CreateWrapperHandler(value); EventRegistrationToken token = table.AddEventHandler(handler); _this.CanExecuteChanged += handler; return(token); }
public void RemoveEventHandler_Token_RemovesFromTable() { EventHandler handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable <Delegate>(); EventRegistrationToken token = tokenTable.AddEventHandler(handler); tokenTable.RemoveEventHandler(token); Assert.Null(tokenTable.InvocationList); // Calls to RemoveEventHandler after removal are nops. tokenTable.RemoveEventHandler(token); }
public void AddEventHandler_MultipleInvocationList_AddsAllDelegateToInvocationLists() { EventHandler handler1 = new EventHandler(EventHandlerMethod1); EventHandler handler2 = new EventHandler(EventHandlerMethod2); EventHandler combinedHandler = (EventHandler)Delegate.Combine(handler1, handler2); var tokenTable = new EventRegistrationTokenTable <Delegate>(); EventRegistrationToken token = tokenTable.AddEventHandler(combinedHandler); Assert.NotEqual(0, token.GetHashCode()); Assert.Equal(new Delegate[] { handler1, handler2 }, tokenTable.InvocationList.GetInvocationList()); }
public void RemoveEventHandler_NullHandler_Nop() { bool removeMethodCalled = false; Delegate handler = new EventHandler(EventHandlerMethod1); var tokenTable = new EventRegistrationTokenTable<Delegate>(); EventRegistrationToken addToken = tokenTable.AddEventHandler(handler); Action<EventRegistrationToken> removeMethod = token => removeMethodCalled = true; WindowsRuntimeMarshal.AddEventHandler(eventHandler => addToken, removeMethod, handler); WindowsRuntimeMarshal.RemoveEventHandler<Delegate>(removeMethod, null); Assert.False(removeMethodCalled); }
public void RemoveEventHandler_Delegate_RemovesFromTable() { EventHandler handler1 = new EventHandler(EventHandlerMethod1); EventHandler handler2 = new EventHandler(EventHandlerMethod2); EventHandler combinedHandler = (EventHandler)Delegate.Combine(handler1, handler2); var tokenTable = new EventRegistrationTokenTable <Delegate>(); tokenTable.AddEventHandler(combinedHandler); tokenTable.RemoveEventHandler(handler1); tokenTable.RemoveEventHandler(handler2); Assert.Equal(new Delegate[] { handler1, handler2 }, tokenTable.InvocationList.GetInvocationList()); tokenTable.RemoveEventHandler(combinedHandler); Assert.Null(tokenTable.InvocationList); // Calls to RemoveEventHandler after removal are nops. tokenTable.RemoveEventHandler(combinedHandler); }
private static EventRegistrationToken BindHandlerToEventSource <T>(EventHandler <T> handler, EventRegistrationTokenTable <EventHandler <PostedMessage <T> > > eventSource) { // Wrap the incoming EventHandler such that we will call it // back on the same synchronization context in which the event was added var boundEventHandler = new ThreadBoundEventHandler <T> { Handler = handler, Context = new TaskFactory(TaskScheduler.FromCurrentSynchronizationContext()) }; var eventHandlerThunk = new EventHandler <PostedMessage <T> >((_, message) => { boundEventHandler.Post(message.Fanout()); }); lock (eventSource) { var token = eventSource.AddEventHandler(eventHandlerThunk); return(token); } }