What is CanExecuteChanged for?

Question

Can I use CanExecuteChanged to change the "can execute" condition?

Or else... "for what" its used?

Answer 1

No you can not use it to change the can execute state. It is an event and objects which participate in the ICommand pattern can choose to listen to this event e.g. a button may use this event to know when to re-query the commands state (by calling the can execute method) to set its enabled state.

In order for the can execute pattern to be useful there needs to be something that can be used to raise the event. Prism's DelegateCommand has a method you can call to manually raise this event so subscribers will re-query the can execute method if they have opted into the pattern.

• Assign command to button.
• Button subscribes to can execute changed event.
• Button execute can execute method and it returns false - disables button.
• You change state that can execute method depends on.
• You call raise can execute changed on Prism command.
• Can execute changed event is raised.
• Button event handler fires.
• Button calls command can execute method - button is enabled.

Example

In the following Prism based example we change the state of SaveCommand CanExecute from false to true whilst the save command is executing. The call toRaiseCanExecuteChanged will cause the CanExecuteChanged event to be raised, and clients to call the CanExecute method. In practice this would make a Save button that was bound to SaveCommand change its state from enabled to disabled and back to enabled again.

public class BlingViewModel
{
    private DelegateCommand<object> _saveCommand;
    private bool _canSaveExecute = true;

    public ICommand SaveCommand
    {
        get
        {
            if (_saveCommand == null)
            {
                _saveCommand = new DelegateCommand<object>
                    (
                    executeMethod: _ => Save()
                    ,
                    canExecuteMethod: _ => _canSaveExecute
                    );
            }
            return _saveCommand;
        }
    }

    private void Save()
    {
        _canSaveExecute = false;
        _saveCommand.RaiseCanExecuteChanged();

        Console.WriteLine("Saving...");

        _canSaveExecute = true;
        _saveCommand.RaiseCanExecuteChanged();
    }
}

Answer 2

Or just call System.Windows.Input.CommandManager.InvalidateRequerySuggested() so that your CanExecute handlers are re-evaluated.

Answer 3

public override event EventHandler CanExecuteChanged
{    
    add { CommandManager.RequerySuggested += value; }
    remove { CommandManager.RequerySuggested -= value; }
}

I don't know what the performance implications are for this; however, they don't seem to be too great, either way. This is what I use.