/// <summary>
/// Creates a new asynchronous command, with the specified asynchronous delegate as its implementation which can use a weak event handler or the command manager.
/// </summary>
public AsyncCommand(Func <object, Task> executeAsync, Func <object, bool> canExecute, bool useCommandManager)
{
_canExecuteChanged = new WeakCanExecuteChanged(this);
_executeAsync = executeAsync;
_canExecute = canExecute;
_useCommandManager = useCommandManager;
}
public void CanExecuteChanged_UnsubscribeNonexistentEvent_DoesNothing()
{
var sender = new object();
object weakObservedSender = null;
object strongObservedSender = null;
object unsubscribedObservedSender = null;
var command = new WeakCanExecuteChanged(sender);
EventHandler weakSubscription = (s, _) =>
{
weakObservedSender = s;
};
EventHandler strongSubscription = (s, _) =>
{
strongObservedSender = s;
};
EventHandler unsubscribedSubscription = (s, _) =>
{
unsubscribedObservedSender = s;
};
command.CanExecuteChanged += strongSubscription;
command.CanExecuteChanged += weakSubscription;
weakSubscription = null;
GC.Collect();
command.CanExecuteChanged -= unsubscribedSubscription;
command.OnCanExecuteChanged();
Assert.Null(weakObservedSender);
Assert.Same(sender, strongObservedSender);
Assert.Null(unsubscribedObservedSender);
GC.KeepAlive(strongSubscription);
GC.KeepAlive(unsubscribedSubscription);
}
public void CanExecuteChanged_IsWeakEvent()
{
var sender = new object();
object weakObservedSender = null;
object strongObservedSender = null;
var command = new WeakCanExecuteChanged(sender);
EventHandler weakSubscription = (s, _) =>
{
weakObservedSender = s;
};
EventHandler strongSubscription = (s, _) =>
{
strongObservedSender = s;
};
command.CanExecuteChanged += weakSubscription;
command.CanExecuteChanged += strongSubscription;
weakSubscription = null;
GC.Collect();
command.OnCanExecuteChanged();
Assert.Null(weakObservedSender);
Assert.Same(sender, strongObservedSender);
GC.KeepAlive(strongSubscription);
}
/// <summary>
/// Creates a new command.
/// </summary>
/// <param name="execute">The execution logic.</param>
/// <param name="canExecute">The execution status logic.</param>
public DelegateCommand(Action <object> execute, Predicate <object> canExecute)
{
if (execute == null)
{
throw new ArgumentNullException(nameof(execute));
}
_execute = execute;
_canExecute = canExecute;
_canExecuteChanged = new WeakCanExecuteChanged(this);
}
public void CanExecuteChanged_Unsubscribed_IsNotNotified()
{
var sender = new object();
object observedSender = null;
var command = new WeakCanExecuteChanged(sender);
EventHandler subscription = (s, _) =>
{
observedSender = s;
};
command.CanExecuteChanged += subscription;
command.CanExecuteChanged -= subscription;
command.OnCanExecuteChanged();
Assert.Null(observedSender);
GC.KeepAlive(subscription);
}
/// <summary>
/// Base constructor for asynchronous command.
/// </summary>
/// <param name="canExecute">The implementation of <see cref="ICommand.CanExecute(object)"/>.</param>
protected AsyncCommandBase(Func <object, bool> canExecute = null)
{
_cancelCommand = new CancelAsyncCommand();
_canExecute = canExecute;
_canExecuteChanged = new WeakCanExecuteChanged(this);
}
/// <summary>
/// Creates a new cancel command with a new cancellation token. This command is initially enabled, with an uncanceled cancellation token.
/// </summary>
public CancelCommand()
{
_canExecuteChanged = new WeakCanExecuteChanged(this);
}
/// <summary>
/// Creates a new cancel command with a new cancellation token.
/// This command is initially enabled, with an uncanceled cancellation token.
/// </summary>
public CancelCommand()
{
_canExecuteChanged = new WeakCanExecuteChanged(this);
}
