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