1

カスタムコントロール（ボタンと同様）にICommandSourceを実装しようとしています。現在、実装は、ICommandSourceのmsdnページに表示され、ButtonBaseソースコードに表示されているようなものです。

CanExecuteは、コントロールのロード時に起動しますが、プロパティが変更されたときには起動しません。通常のボタンに渡される同じコマンドは問題なく機能します。変更するはずのプロパティが変更されると、CanExecuteが起動し、ボタンが有効になります。コマンドは委任コマンドです。

CommandManager.InvalidateRequerySuggested（）;を試しました。しかし、それはうまくいきませんでした。

何か案は？

カスタムコントロールの実装は次のとおりです。

private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
    CollapsibleSplitButton csb = (CollapsibleSplitButton)d;
    csb.OnCommandChanged((ICommand)e.OldValue, (ICommand)e.NewValue);
}

private void OnCommandChanged(ICommand oldCommand, ICommand newCommand)
{
    if (oldCommand != null) UnhookCommand(oldCommand);
    if (newCommand != null) HookCommand(newCommand);
}

private void UnhookCommand(ICommand command)
{
    command.CanExecuteChanged -= OnCanExecuteChanged;
    UpdateCanExecute();
}

private void HookCommand(ICommand command)
{
    command.CanExecuteChanged += OnCanExecuteChanged;
    UpdateCanExecute();
}
private void OnCanExecuteChanged(object sender, EventArgs e)
{
    UpdateCanExecute();
}

private void UpdateCanExecute()
{
    if (Command != null)
        CanExecute = Command.CanExecute(CommandParameter);
    else
        CanExecute = true;
}

protected override bool IsEnabledCore
{
    get { return base.IsEnabledCore && CanExecute; }
}

私が持っているコマンドを設定する場所：

...
    MyCommand = new DelegatingCommand(DoStuff, CanDoStuff);
...

private bool CanDoStuff()
{
    return (DueDate == null);
}

private void DoStuff() {//do stuff}
4

2 に答える 2

1

delegateコマンドを使用すると、UI で更新する必要があると思われるときはいつでも、明示的に を発生させる必要CanExecuteChangedがあります。RelayCommand-と呼ばれるこのバージョンのコマンドを使用してみてください

public class RelayCommand<T> : ICommand
{
   #region Fields

   readonly Action<T> _execute = null;
   readonly Predicate<T> _canExecute = null;

   #endregion

    #region Constructors

    /// <summary>
    /// Initializes a new instance of <see cref="DelegateCommand{T}"/>.
    /// </summary>
    /// <param name="execute">Delegate to execute when Execute is called on the command.
    ///This can be null to just hook up a CanExecute delegate.</param>
    /// <remarks><seealso cref="CanExecute"/> will always return true.</remarks>
    public RelayCommand(Action<T> execute)
            : this(execute, null)
    {
    }

    /// <summary>
    /// Creates a new command.
    /// </summary>
    /// <param name="execute">The execution logic.</param>
    /// <param name="canExecute">The execution status logic.</param>
    public RelayCommand(Action<T> execute, Predicate<T> canExecute)
    {
       if (execute == null)
          throw new ArgumentNullException("execute");

       _execute = execute;
       _canExecute = canExecute;
    }

    #endregion

    #region ICommand Members

    ///<summary>
    ///Defines the method that determines whether the command can execute in its current 
    ///state.
    ///</summary>
    ///<param name="parameter">Data used by the command.  If the command does not require 
    /// data to be passed, this object can be set to null.</param>
    ///<returns>
    ///true if this command can be executed; otherwise, false.
    ///</returns>
    public bool CanExecute(object parameter)
    {
        return _canExecute == null ? true : _canExecute((T)parameter);
    }

    ///<summary>
    ///Occurs when changes occur that affect whether or not the command should execute.
    ///</summary>
    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    ///<summary>
    ///Defines the method to be called when the command is invoked.
    ///</summary>
    ///<param name="parameter">Data used by the command. If the command does not require 
    ///data to be passed, this object can be set to <see langword="null" />.</param>
    public void Execute(object parameter)
    {
        _execute((T)parameter);
    }

    #endregion
}

そして、クラスに同様のDelegateコマンドを登録します-

public ICommand TestCommand { get; private set; }
TestCommand = new RelayCommand<object>(CommandMethod, CanExecuteCommand);

編集

CommandManager.InvalidateRequerySuggested();あなたのCanExecute-を入れてみてください

private void OnCanExecuteChanged(object sender, EventArgs e)
{
    CommandManager.InvalidateRequerySuggested();
    UpdateCanExecute();
}
于 2012-10-24T06:31:24.200 に答える
0

コールバックを EventHandler にラップすることで問題を解決できました。

private EventHandler currentHandler;

private void UnhookCommand(ICommand command)
{
    if (currentHandler != null)
        command.CanExecuteChanged -= currentHandler;
    UpdateCanExecute();
}

private void HookCommand(ICommand command)
{
    if (currentHandler == null) return;

    command.CanExecuteChanged += currentHandler;
    UpdateCanExecute();
}
于 2012-10-31T18:21:53.697 に答える