C# ICommand.CanExecute方法代码示例

        /// <summary>
        /// Creates a button and adds it to an application bar.
        /// </summary>
        /// <param name="appBar"></param>
        /// <param name="iconFilenameRelative"></param>
        /// <param name="command"></param>
        /// <param name="text"></param>
        /// <returns></returns>
        public static ApplicationBarIconButton CreateAndAddButton(this IApplicationBar appBar, string iconFilenameRelative, ICommand command, string text)
        {
            ApplicationBarIconButton btn = new ApplicationBarIconButton(new Uri("/icons/" + iconFilenameRelative, UriKind.Relative));

            // First-time values.
            btn.IsEnabled = command.CanExecute(btn);
            btn.Text = text;

            // Adds click handler to execute the command upon click.
            btn.Click += (o, e) =>
            {
                if (command.CanExecute(btn))
                {
                    command.Execute(btn);
                }
            };

            // Adds CanExecute changed handler.
            command.CanExecuteChanged += (o, e) =>
            {
                btn.IsEnabled = command.CanExecute(btn);
            };

            // Adds the button.
            appBar.Buttons.Add(btn);

            return btn;
        }

        /// <summary>
        /// Creates a menu item and adds it to an application bar.
        /// </summary>
        /// <param name="appBar"></param>
        /// <param name="command"></param>
        /// <param name="text"></param>
        /// <returns></returns>
        public static ApplicationBarMenuItem CreateAndAddMenuItem(this IApplicationBar appBar, ICommand command, string text)
        {
            ApplicationBarMenuItem mi = new ApplicationBarMenuItem(text);

            // First-time values.
            mi.IsEnabled = command.CanExecute(mi);

            // Adds click handler to execute the command upon click.
            mi.Click += (o, e) =>
            {
                if (command.CanExecute(mi))
                {
                    command.Execute(mi);
                }
            };

            // Adds CanExecute changed handler.
            command.CanExecuteChanged += (o, e) =>
            {
                mi.IsEnabled = command.CanExecute(mi);
            };

            // Adds the button.
            appBar.MenuItems.Add(mi);

            return mi;
        }

		public void Include (ICommand command)
		{
			command.CanExecuteChanged += (s, e) => {
				if (command.CanExecute (null))
					command.Execute (null);
			};
		}

 public static void Execute(ICommand command, object parameter, IInputElement target)
 {
     var routedCmd = command as RoutedCommand;
     if (routedCmd != null && routedCmd.CanExecute(parameter, target))
         routedCmd.Execute(parameter, target);
     else if (command != null && command.CanExecute(parameter))
         command.Execute(parameter);
 }

        public static bool CanExecute(ICommand command, object parameter, IInputElement target)
        {
            if (command == null)
                return false;

            var routedCommand = command as RoutedCommand;
            return routedCommand?.CanExecute(parameter, target) ?? command.CanExecute(parameter);
        }

        public static void ExecuteCommand(
			ICommand command, 
			GestureArgs parameter = null)
        {
            if (command != null &&
                command.CanExecute (parameter)) {
                command.Execute (parameter);
            }
        }

		public static bool CanExecuteCommand(ICommand command, object parameter, IInputElement target)
		{
			if (command == null)
				return false;
			RoutedCommand routed = command as RoutedCommand;
			if (routed != null)
				return routed.CanExecute(parameter, target);
			return command.CanExecute(parameter);
		}

        public void Run()
        {
            var objBindable = new DataObject();

            var myBinding = new Binding("Amount", objBindable, "Amount", true, DataSourceUpdateMode.OnPropertyChanged);

            var objWithBinding = new DataObjectWithBindable();
            objWithBinding.PropertyChanged += (sender, args) =>
            {
                Console.WriteLine(args.PropertyName);
            };
            objWithBinding.DataBindings.Add(myBinding);

            objBindable.Amount = 30 + 10;
            objBindable.Message = "test";

            objWithBinding.Amount = 55;

            objBindable.Amount = 54;

            HiButtonCommand = new RelayCommand(
                ShowMessage,
                param =>
                    {
                        var t = (DataObject)param;
                        return t.Amount < 10;
                    });

            HiButtonCommand.CanExecuteChanged += HiButtonCommandOnCanExecuteChanged;

            objBindable.Amount = 9;

            if (HiButtonCommand.CanExecute(objBindable))
            {
                HiButtonCommand.Execute(objBindable);
            }

            objBindable.Amount = 11;

            if (HiButtonCommand.CanExecute(objBindable))
            {
                HiButtonCommand.Execute(objBindable);
            }
        }

        protected virtual void ExecuteRefreshCommand(ICommand command)
        {
            if (command == null)
                return;

            if (!command.CanExecute(null))
                return;

            command.Execute(null);
        }

        /// <summary>
        /// Attempts to executes a command command.
        /// </summary>
        /// <param name="cmd">The command to be executed.</param>
        /// <param name="parameter">The command parameter.</param>
        /// <returns>True if the command was executed; otherwise false.</returns>
        private static bool ExecuteCommand(ICommand cmd, object parameter)
        {
            if (cmd != null && cmd.CanExecute(parameter))
            {
                cmd.Execute(parameter);
                return true;
            }

            return false;
        }

        public CommandPropertyItem(PropertyDescriptor property, object instance)
            : base(property, instance)
        {
            _command = property.GetValue(instance) as ICommand;
            if (_command != null)
            {
                _command.CanExecuteChanged += CanExecuteChanged;
            }

            _executeCommand = new Command<object>(o => _command.Execute(GetCommandParameter()), o => _command != null && _command.CanExecute(GetCommandParameter()));
        }

        public ChainCommand(ICommand postCommand, Action<object> execute, Func<object, bool> canExecute = null)
        {
            if (canExecute == null) canExecute = x => true;

            _execute = x => {
                execute(x);
                postCommand.Execute(x);
            };

            _canExecute = x => canExecute(x) && postCommand.CanExecute(x);
        }

  public JSCommand(HTMLViewContext context, IJavascriptToCSharpConverter converter, ICommand command)
  {
      _JavascriptToCSharpConverter = converter;
      _HTMLViewContext = context;
      _Command = command;
 
      try
      {
          _InitialCanExecute = _Command.CanExecute(null);
      }
      catch { }
  }

        protected virtual void ExecuteCommandOnItem(ICommand command)
        {
            if (command == null)
                return;

            var item = DataContext;
            if (item == null)
                return;

            if (!command.CanExecute(item))
                return;

            command.Execute(item);
        }

 private void ExecuteCommand(ICommand command, object parameter, IInputElement target)
 {
     RoutedCommand command2 = command as RoutedCommand;
     if (command2 != null)
     {
         if (command2.CanExecute(parameter, target))
         {
             command2.Execute(parameter, target);
         }
     }
     else if (command.CanExecute(parameter))
     {
         command.Execute(parameter);
     }
 }