C# DelegateCommand.RaiseCanExecuteChanged方法代码示例

        private bool _windowClosedBySelf = false; // Tracks whether the window was closed by logic internal
                                                  // to the command (e.g. not by clicking the window's close button)
        // Presents the user with a sign-in dialog
        public override void Execute(object parameter)
        {
            // Initialize the viewmodel if not yet done
            if (viewModel == null)
            {
                // Instantiate the viewmodel and sign-in/cancel commands
                viewModel = new SignInViewModel();
                DelegateCommand signInCommand = new DelegateCommand(onSignIn, canSignIn);
                viewModel.SignIn = signInCommand;
                viewModel.Cancel = new DelegateCommand(onCancel);

                // When a property changes on the viewmodel, have the sign-in command check its executable state
                viewModel.PropertyChanged += (o, e) => signInCommand.RaiseCanExecuteChanged();

                // instantiate the view
                view = new SignInView() { Margin = new Thickness(10) };

                // plug the viewmodel into the view
                view.DataContext = viewModel;
            }

            // Prompt for sign-in
            if (MapApplication.Current != null)
                MapApplication.Current.ShowWindow(Strings.SignIn, view, true, null, onWindowClosed,
                    WindowType.DesignTimeFloating);
        }

 public MultiViewModel()
 {
     SelectAllCommand = new DelegateCommand(SelectAll);
     ClearSelectionCommand = new DelegateCommand(ClearSelection, CanClearSelection);
     SelectedItems = new ObservableCollection<ItemViewModel>();
     SelectedItems.CollectionChanged += (sender, args) => ClearSelectionCommand.RaiseCanExecuteChanged();
 }

        public void CommandCanExecuteChangedTest()
        {
            DelegateCommand command = new DelegateCommand(() => { });

            AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged());

            AssertHelper.ExpectedException<ArgumentNullException>(
                () => AssertHelper.CanExecuteChangedEvent(null, () => command.RaiseCanExecuteChanged()));
            AssertHelper.ExpectedException<ArgumentNullException>(
                () => AssertHelper.CanExecuteChangedEvent(command, null));

            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () => { }));

            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () =>
                {
                    command.RaiseCanExecuteChanged();
                    command.RaiseCanExecuteChanged();
                }));
        }

        public MainViewModel(NumberDiceViewModel numDiceViewModel,
            NumberSidesViewModel numSidesViewModel,
            RollModeViewModel rollModeViewModel,
            RandomModeViewModel randomModeViewModel)
        {
            if (numDiceViewModel == null)
                throw new ArgumentNullException("numDiceViewModel is null.");
            if (numSidesViewModel == null)
                throw new ArgumentNullException("numSidesViewModel is null.");
            if (rollModeViewModel == null)
                throw new ArgumentNullException("rollModeViewModel is null.");
            if (randomModeViewModel == null)
                throw new ArgumentNullException("randomModeViewModel is null.");

            SetupPages = new ObservableCollection<IPageViewModel>();
            Dice = new ObservableCollection<IDieViewModel>();
            Statistics = new ObservableCollection<IStatisticViewModel>();
            _rollCommand = new DelegateCommand(x => randomModeViewModel.GeneratorIsReady, x => rollDice());

            _numDiceViewModel = numDiceViewModel;
            _numDiceViewModel.NumberDiceChanged += (sender, e) => onSetupChanged();
            SetupPages.Add(_numDiceViewModel);

            _numSidesViewModel = numSidesViewModel;
            _numSidesViewModel.NumberSidesChanged += (sender, e) => onSetupChanged();
            SetupPages.Add(_numSidesViewModel);

            _rollModeViewModel = rollModeViewModel;
            _rollModeViewModel.ModeChanged += (sender, e) => onSetupChanged();
            SetupPages.Add(_rollModeViewModel);

            _randomModeViewModel = randomModeViewModel;
            _randomModeViewModel.RandomModeChanged += (sender, e) => onSetupChanged();
            _randomModeViewModel.Ready += (sender, e) => _rollCommand.RaiseCanExecuteChanged();
            _randomModeViewModel.Error += (sender, e) => _rollCommand.RaiseCanExecuteChanged();
            // TODO: Add error checking before adding this feature
            //SetupPages.Add(_randomModeViewModel);

            onSetupChanged();
        }

        public void CommandCanExecuteChangedTest2()
        {
            var command = new DelegateCommand(() => { });
            
            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () => { }));

            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () =>
                {
                    command.RaiseCanExecuteChanged();
                    command.RaiseCanExecuteChanged();
                }));

            
            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 0, ExpectedChangedCountMode.Exact));

            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 2, ExpectedChangedCountMode.Exact));

            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 2, ExpectedChangedCountMode.AtLeast));

            AssertHelper.ExpectedException<AssertException>(() =>
                AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 0, ExpectedChangedCountMode.AtMost));
        }

        public void RaiseCanExecuteChangedTest()
        {
            bool executed = false;
            bool canExecute = false;
            DelegateCommand command = new DelegateCommand(() => executed = true, () => canExecute);

            Assert.IsFalse(command.CanExecute());
            canExecute = true;
            Assert.IsTrue(command.CanExecute());

            AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged());

            Assert.IsFalse(executed);
        }

        public PersonEntryViewModel(IPersonEntry person, ISchedulerProvider schedulerProvider)
        {
            _person = person;
            _schedulerProvider = schedulerProvider;

            SaveCommand = new DelegateCommand(Save, () => !Person.HasErrors && !Person.State.HasError);

            var errors = Observable.FromEventPattern<EventHandler<DataErrorsChangedEventArgs>, DataErrorsChangedEventArgs>(
                    h => Person.ErrorsChanged += h,
                    h => Person.ErrorsChanged -= h)
                .Select(_ => Unit.Default);
            var states = Person.OnPropertyChanges(p => p.State)
                               .Select(_ => Unit.Default);

            _errorStateSubscription = Observable
                .Merge(errors, states)
                .ObserveOn(_schedulerProvider.Dispatcher)
                .Subscribe(_ => SaveCommand.RaiseCanExecuteChanged());

            states.ObserveOn(_schedulerProvider.Dispatcher)
                 .Subscribe(_ => OnPropertyChanged("State"));
        }

        public void CommandCanExecuteChangedTest1()
        {
            var command = new DelegateCommand(() => { });

            AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged());
            AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 1, ExpectedChangedCountMode.Exact);
            AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 0, ExpectedChangedCountMode.AtLeast);
            AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), 2, ExpectedChangedCountMode.AtMost);


            AssertHelper.ExpectedException<ArgumentNullException>(
                () => AssertHelper.CanExecuteChangedEvent(null, () => command.RaiseCanExecuteChanged()));
            
            AssertHelper.ExpectedException<ArgumentNullException>(
                () => AssertHelper.CanExecuteChangedEvent(command, null));

            AssertHelper.ExpectedException<ArgumentOutOfRangeException>(
                () => AssertHelper.CanExecuteChangedEvent(command, () => command.RaiseCanExecuteChanged(), -1, ExpectedChangedCountMode.Exact));
        }

        void OnLoggedIn(dynamic result)
        {
            if (result["Result"].ToObject<bool>())
            {
                m_ServerStatusMetadataSource = result["ServerMetadataSource"].ToObject<List<KeyValuePair<string, StatusInfoAttribute[]>>>();

                BuildGridColumns(
                    m_ServerStatusMetadataSource.FirstOrDefault(p => string.IsNullOrEmpty(p.Key)).Value,
                    GetCommonColumns(m_ServerStatusMetadataSource.Where(p => !string.IsNullOrEmpty(p.Key)).Select(c => c.Value).ToArray()));

                var nodeInfo = DynamicViewModelFactory.Create(result["NodeStatus"].ToString());

                GlobalInfo = nodeInfo.BootstrapStatus;

                var instances = nodeInfo.InstancesStatus as IEnumerable<DynamicViewModel.DynamicViewModel>;
                Instances = new ObservableCollection<DynamicViewModel.DynamicViewModel>(instances.Select(i =>
                    {
                        var startCommand = new DelegateCommand<DynamicViewModel.DynamicViewModel>(ExecuteStartCommand, CanExecuteStartCommand);
                        var stopCommand = new DelegateCommand<DynamicViewModel.DynamicViewModel>(ExecuteStopCommand, CanExecuteStopCommand);
                        var restartCommand = new DelegateCommand<DynamicViewModel.DynamicViewModel>(ExecuteRestartCommand, CanExecuteRestartCommand);

                        i.PropertyChanged += (s, e) =>
                            {
                                if (string.IsNullOrEmpty(e.PropertyName)
                                    || e.PropertyName.Equals("IsRunning", StringComparison.OrdinalIgnoreCase))
                                {
                                    startCommand.RaiseCanExecuteChanged();
                                    stopCommand.RaiseCanExecuteChanged();
                                    restartCommand.RaiseCanExecuteChanged();
                                }
                            };

                        i.Set("StartCommand", startCommand);
                        i.Set("StopCommand", stopCommand);
                        i.Set("RestartCommand", restartCommand);

                        return i;
                    }));
                State = NodeState.Connected;
                LastUpdatedTime = DateTime.Now;
            }
            else
            {
                m_LoginFailed = true;
                //login failed
                m_WebSocket.Close();
                ErrorMessage = "Logged in failed!";
            }
        }