The Delegating Command

The RoutedCommand doesn’t quite make sense to me in the M-V-VM pattern. Why go through the effort of creating command bindings when you are holding an instance of the Command within your controller (or ViewModel). Just trust me when I say it’s convoluted.

At the other extreme, you would have to create a new class for each and every Command that your application provides. While there is a benefit to this scenario in some cases, in most instances it’s overkill. A happy medium is having a class that implements ICommand and exposes events for CanExecute and Execute. Hence I give you the DelegatingCommand.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Input;

namespace YourNamespaceHere
{
    /// <summary>
    /// Delegate for adding logic for determining if a 
    /// <see cref="DelegatingCommand"/> can be executed
    /// </summary>
    /// <param name="parameter">
    /// The parameter being passed to the command (can be null)
    /// </param>
    /// <returns>
    /// True if the command can be executed with the given parameter
    /// </returns>
    public delegate bool CanExecuteHandler(object parameter);

    /// <summary>
    /// Delegate for adding logic to execute a <see cref="DelegatingCommand"/>
    /// </summary>
    /// <param name="parameter">
    /// The parameter being passed to the command (can be null)
    /// </param>
    public delegate void ExecuteHandler(object parameter);

    /// <summary>
    /// The DelegatingCommand provides an implementation of <see cref="ICommand"/>
    /// that can delegate CanExecute and Execute calls to listeners. As opposed
    /// to the RoutedCommand, it does not require any custom wiring to the UI,
    /// just bind an instance to any <see cref="ICommand"/> (e.g.
    /// <see cref="Button"/> or <see cref="MenuItem"/>) using XAML. This is 
    /// useful when implementing the MVC pattern within WPF. The Controller can
    /// expose a DelegatingCommand as a property and the View can bind to it.
    /// Anyone aware of the instance can handle the CanExecuteRequested and/or
    /// ExecuteRequested events.
    /// </summary>
    public class DelegatingCommand : ICommand
    {
        public event CanExecuteHandler CanExecuteRequested;
        public event ExecuteHandler ExecuteRequested;

        public bool CanExecute(object parameter)
        {
            if (CanExecuteRequested != null)
                return CanExecuteRequested(parameter);
            return true;
        }

        private Object _Owner;
        public Object Owner
        {
            get { return _Owner; }
            set { _Owner = value; }
        }

        public event EventHandler CanExecuteChanged;

        public void Execute(object parameter)
        {
            if (ExecuteRequested != null)
                ExecuteRequested(parameter);
        }

    }

}