ICommand and RelayCommand in WPF

To bind a command of a button you need to bind a property that is an implementation of an ICommand. AnICommand is composed by:

1. event EventHandler CanExecuteChanged;    
2. bool CanExecute(object parameter);    
3. void Execute(object parameter);    

CanExecuteChanged is invoked when changes occur that can change whether or not the command can be executed.

CanExecute will determine whether the command can be executed or not. If it returns false the button will be disabled on the interface.

Execute runs the command logic.

With a simple implementation of ICommand I can create the following:

1. public class NormalCommand : ICommand    
2. {    
3.     public event EventHandler CanExecuteChanged;    
4.      
5.     public bool CanExecute(object parameter)    
6.     {    
7.         throw new NotImplementedException();    
8.     }    
9.      
10.     public void Execute(object parameter)    
11.     {    
12.         throw new NotImplementedException();    
13.     }    
14. }   

However this does not allow me to have a different logic to my CanExecute or Execute. For each command I would need to implement a new class. To solve that problem there is the RelayCommandimplementationthat is a command that can be instantiated passing the actions to be executed as in the following:

1. public class RelayCommand : ICommand    
2. {    
3.     private Action<object> execute;    
4.     private Func<object, bool> canExecute;    
5.      
6.     public event EventHandler CanExecuteChanged    
7.     {    
8.         add { CommandManager.RequerySuggested += value; }    
9.         remove { CommandManager.RequerySuggested -= value; }    
10.     }    
11.      
12.     public RelayCommand(Action<object> execute, Func<object, bool> canExecute = null)    
13.     {    
14.         this.execute = execute;    
15.         this.canExecute = canExecute;    
16.     }    
17.      
18.     public bool CanExecute(object parameter)    
19.     {    
20.         return this.canExecute == null || this.canExecute(parameter);    
21.     }    
22.      
23.     public void Execute(object parameter)    
24.     {    
25.         this.execute(parameter);    
26.     }    
27. }  

With this implementation I can specify what I want to execute when I create the command, so I don't need to implement a new class for each different action I want to take. Then it could be called using the following:

1. var cmd1 = new RelayCommand(o => { /* do something 1 */ }, o => true);    
2. var cmd2 = new RelayCommand(o => { /* do something 2 */ }, o => true);   

The CommandManager.RequerySuggested handles events when something in the interface suggests that a requery should happen. If your ICommand adds the handlers to it then it will automatically update UI elements when the screen executes some actions. (For example, lose focus on a TextBox.)