C# DelegateCommand.CanExecute方法代码示例

        public ItemListFilterViewModel(IEventAggregator iEventAggregator, int _numControls)
        {
            this.iEventAggregator = iEventAggregator;
            buttonActions = new string[] { "FILTER_RESET", "FILTER_TYPE", "FILTER_FILES" };
            Filter = "";
            FilterType = "Contains";
            numControls = _numControls;

            MoveRightCommand = new DelegateCommand(MoveRight, CanMoveRight);
            MoveLeftCommand = new DelegateCommand(MoveLeft, CanMoveLeft);
            RemoveLastCharFromFilterCommand = new DelegateCommand(RemoveLastCharFromFilter, CanRemoveLastCharFromFilter);
            ResetFiltersCommand = new DelegateCommand(ResetFilters, CanResetFilters);

            EventMap = new Dictionary<string, Action>()
            {
                {"FILTER_MOVE_LEFT", () =>
                    {
                        if (MoveLeftCommand.CanExecute())
                        {
                            MoveLeftCommand.Execute();
                        }
                    }
                },
                {"FILTER_MOVE_RIGHT", () =>
                    {
                        if (MoveRightCommand.CanExecute())
                        {
                            MoveRightCommand.Execute();
                        }
                    }
                },
                {"CHAR_BACK", () =>
                    {
                        if (RemoveLastCharFromFilterCommand.CanExecute())
                        {
                            RemoveLastCharFromFilterCommand.Execute();
                        }
                    }
                }

            };

            EventMapParam = new Dictionary<string, Action<string>>()
            {
                {"CHAR_SELECT", AppendToFilter},
                {"VOS_OPTION",  (_filterType) =>
                    {
                        FilterType = _filterType;
                    }
                }
            };

            filterViewToken = this.iEventAggregator.GetEvent<PubSubEvent<ViewEventArgs>>().Subscribe(
                (viewEventArgs) =>
                {
                    EventHandler(viewEventArgs);
                }
            );
        }

        public void ConstructorWithOnlyExecuteMethodForCanExecuteTest()
        {
            var command = new DelegateCommand(m_CommandManager,
                                              ExecuteMethod);

            Assert.True(command.CanExecute(),
                        "CanExecute");
        }

        public void Generic_DelegateCommand_Receives_CanExecute_Parameter()
        {
            int canExecuteParameter = 0;
            var command = new DelegateCommand<int>(x => { }, x => { canExecuteParameter = x; return true; });

            command.CanExecute(66);

            Assert.That(canExecuteParameter, Is.EqualTo(66));
        }

        public void CanExecute_ReturnsFalseIfNullParameter_GenericStruct()
        {
            MockCommandHandler<int> handler = new MockCommandHandler<int>() { CanExecuteValue = true };
            DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);

            Assert.IsFalse(command.CanExecute(null));
        }

        public void CanExecute_ReturnsTrueIfNullParameter_GenericClass()
        {
            MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>() { CanExecuteValue = true };
            DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);

            Assert.IsTrue(command.CanExecute(null));
        }

        public void CanExecute_ReturnsFalseIfIncorrectType_GenericStruct()
        {
            MockCommandHandler<int> handler = new MockCommandHandler<int>() { CanExecuteValue = true };
            DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);

            Assert.IsFalse(command.CanExecute(new MockArgumentClass()));
        }

        public void CanExecute_WillReturnFalse_GenericStruct()
        {
            MockCommandHandler<int> handler = new MockCommandHandler<int>() { CanExecuteValue = false };
            DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);

            Assert.IsFalse(command.CanExecute(42));
        }

        public void CanExecute_WillReturnFalse_GenericClass()
        {
            MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>() { CanExecuteValue = false };
            DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);

            Assert.IsFalse(command.CanExecute(new MockArgumentClass()));
        }

        public void CanExecute_WillReturnTrue_NonGeneric()
        {
            MockCommandHandler handler = new MockCommandHandler() { CanExecuteValue = true };
            DelegateCommand command = new DelegateCommand(handler.Execute, handler.CanExecute);

            Assert.IsTrue(command.CanExecute(new MockArgumentClass()));
        }

        public void CanExecute_PassesArgument_GenericStruct()
        {
            MockCommandHandler<int> handler = new MockCommandHandler<int>();
            DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);

            command.CanExecute(42);

            CollectionAssert.AreEqual(new[] { 42 }, (ICollection)handler.ArgumentList);
        }

        public void CanExecute_PassesArgument_GenericClass()
        {
            MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
            DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);
            MockArgumentClass argument = new MockArgumentClass();

            command.CanExecute(argument);

            CollectionAssert.AreEqual(new[] { argument }, (ICollection)handler.ArgumentList);
        }

        public void CanExecute_CallsCanExecuteMethod_GenericStruct()
        {
            MockCommandHandler<int> handler = new MockCommandHandler<int>();
            DelegateCommand<int> command = new DelegateCommand<int>(handler.Execute, handler.CanExecute);

            Assert.AreEqual(0, handler.CanExecuteCallCount);

            command.CanExecute(42);

            Assert.AreEqual(1, handler.CanExecuteCallCount);
        }

        public void CanExecute_CallsCanExecuteMethod_GenericClass()
        {
            MockCommandHandler<MockArgumentClass> handler = new MockCommandHandler<MockArgumentClass>();
            DelegateCommand<MockArgumentClass> command = new DelegateCommand<MockArgumentClass>(handler.Execute, handler.CanExecute);

            Assert.AreEqual(0, handler.CanExecuteCallCount);

            command.CanExecute(new MockArgumentClass());

            Assert.AreEqual(1, handler.CanExecuteCallCount);
        }

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

            Assert.That(command.CanExecute(true));
        }

        public void Calling_CanExecute_Evaluates_Predicate(bool predicateResult)
        {
            var command = new DelegateCommand(() => { }, () => predicateResult);

            Assert.That(command.CanExecute(null), Is.EqualTo(predicateResult));
        }