public CommandsViewModel()
{
ManualRelayCommandNoCondition = new ManualRelayCommand(() => Executed = "ManualRelayCommandNoCondition");
ManualRelayCommand = new ManualRelayCommand(() => Executed = "ManualRelayCommand", () => CanExecute);
ManualRelayCommandWithParameter = new ManualRelayCommand <string>(x => Executed = "ManualRelayCommandWithParameter: " + x, _ => CanExecute);
RelayCommandNoCondition = new RelayCommand(() => Executed = "RelayCommandNoCondition");
RelayCommand = new RelayCommand(() => Executed = "RelayCommand", () => CanExecute);
RelayCommandWithParamater = new RelayCommand <string>(x => Executed = "RelayCommandWithParamater: " + x, x => CanExecute);
ObservingRelayCommand = new ObservingRelayCommand(() => Executed = "ObservingRelayCommand", () => CanExecute, this.ObservePropertyChanged(x => x.CanExecute));
ObservingRelayCommandWithParameter = new ObservingRelayCommand <string>(x => Executed = "ObservingRelayCommandWithParameter:" + x, x => CanExecute, this.ObservePropertyChanged(x => x.CanExecute));
var condition = new Condition(this.ObservePropertyChanged(x => x.CanExecute), () => CanExecute);
ConditionRelayCommand = new ConditionRelayCommand(() => Executed = "ObservingRelayCommand", condition);
ConditionRelayCommandWithParameter = new ConditionRelayCommand <string>(x => Executed = "ConditionRelayCommandWithParameter: " + x, condition);
RaiseCanExecuteCommand = new RelayCommand(RaiseCanExecute);
RaiseCanExecuteOnOtherThread = new RelayCommand(() => Task.Run(() => RaiseCanExecute()));
DelayedToggleCanExecute = new RelayCommand(async() =>
{
await Task.Delay(500).ConfigureAwait(false);
CanExecute = !CanExecute;
});
}
public void CanExecuteWithParameter()
{
int i = 5;
var command = new ManualRelayCommand(_ => { }, o => i == (int)o);
Assert.IsTrue(command.CanExecute(5));
Assert.IsFalse(command.CanExecute(4));
}
public static void ExecuteWithParameter()
{
var invokeCount = 0;
var command = new ManualRelayCommand <int>(o => invokeCount = o, _ => true);
command.Execute(4);
Assert.AreEqual(4, invokeCount);
}
public void ExecuteNoParameter()
{
int invokeCount = 0;
var command = new ManualRelayCommand(_ => invokeCount++, _ => true);
command.Execute(null);
Assert.AreEqual(1, invokeCount);
}
public void RaiseCanExecuteChanged()
{
int count = 0;
var command = new ManualRelayCommand(() => { }, () => true);
command.CanExecuteChanged += (sender, args) => count++;
Assert.AreEqual(0, count);
command.RaiseCanExecuteChanged();
Assert.AreEqual(1, count);
}
public static async Task WhenRaiseCanExecuteChanged()
{
var count = 0;
var command = new ManualRelayCommand <int>(x => { }, x => true);
command.CanExecuteChanged += (sender, args) => count++;
Assert.AreEqual(0, count);
command.RaiseCanExecuteChanged();
await Application.Current.Dispatcher.SimulateYield();
Assert.AreEqual(1, count);
}
public void MemoryLeak()
{
var command = new ManualRelayCommand(() => { }, () => true);
var listener = new CommandListener();
var wr = new WeakReference(listener);
command.CanExecuteChanged += listener.React;
listener = null;
GC.Collect();
Assert.IsFalse(wr.IsAlive);
command.CanExecute(); // Touching it after to prevent GC
}
public void MemoryLeak()
{
var command = new ManualRelayCommand <int>(x => { }, x => true);
var listener = new CommandListener();
var wr = new WeakReference(listener);
command.CanExecuteChanged += listener.React;
//// ReSharper disable once RedundantAssignment
listener = null;
GC.Collect();
Assert.IsFalse(wr.IsAlive);
command.CanExecute(0); // Touching it after to prevent GC
}
private void RaiseCanExecute()
{
ManualRelayCommandNoCondition.RaiseCanExecuteChanged();
ManualRelayCommand.RaiseCanExecuteChanged();
ManualRelayCommandWithParameter.RaiseCanExecuteChanged();
RelayCommandNoCondition.RaiseCanExecuteChanged();
RelayCommand.RaiseCanExecuteChanged();
RelayCommandWithParamater.RaiseCanExecuteChanged();
ObservingRelayCommand.RaiseCanExecuteChanged();
ObservingRelayCommandWithParameter.RaiseCanExecuteChanged();
ConditionRelayCommand.RaiseCanExecuteChanged();
ConditionRelayCommandWithParameter.RaiseCanExecuteChanged();
}
public void ExecuteNotifies()
{
var invokeCount = 0;
var isExecutingCount = 0;
var command = new ManualRelayCommand(() => invokeCount++, () => true);
command.ObservePropertyChangedSlim(nameof(command.IsExecuting), false)
.Subscribe(_ => isExecutingCount++);
Assert.IsFalse(command.IsExecuting);
Assert.True(command.CanExecute());
command.Execute();
Assert.IsFalse(command.IsExecuting);
Assert.True(command.CanExecute());
Assert.AreEqual(1, invokeCount);
Assert.AreEqual(2, isExecutingCount);
}
public static void MemoryLeak()
{
#if DEBUG
return; // debugger keeps things alive.
#endif
#pragma warning disable CS0162 // Unreachable code detected
var command = new ManualRelayCommand <int>(x => { }, x => true);
#pragma warning restore CS0162 // Unreachable code detected
var listener = new CommandListener();
var wr = new WeakReference(listener);
command.CanExecuteChanged += listener.React;
//// ReSharper disable once RedundantAssignment
listener = null;
GC.Collect();
Assert.IsFalse(wr.IsAlive);
Assert.NotNull(command); // Touching it after to prevent GC
}
public static void ExecuteNotifies()
{
var invokeCount = 0;
var isExecutingCount = 0;
var command = new ManualRelayCommand <int>(i => invokeCount += i, _ => true);
using (command.ObservePropertyChangedSlim(nameof(command.IsExecuting), signalInitial: false)
.Subscribe(_ => isExecutingCount++))
{
Assert.IsFalse(command.IsExecuting);
Assert.True(command.CanExecute(1));
command.Execute(1);
Assert.IsFalse(command.IsExecuting);
Assert.True(command.CanExecute(1));
Assert.AreEqual(1, invokeCount);
Assert.AreEqual(2, isExecutingCount);
}
}
public static void CanExecuteWithParameter(int i, int parameter, bool expected)
{
var command = new ManualRelayCommand <int>(x => { }, x => i == x);
Assert.AreEqual(expected, command.CanExecute(parameter));
}
public void CanExecute(bool canExecute)
{
var command = new ManualRelayCommand(() => { }, () => canExecute);
Assert.AreEqual(canExecute, command.CanExecute());
}
internal static void RemoveHandler(ManualRelayCommand source, EventHandler handler)
{
Manager.ProtectedRemoveHandler(source, handler);
}
