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);
}
}