WPF Custom Command And Binding

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

namespace WPF.Commands
{
  /// <summary>
  ///     This class allows delegating the commanding logic to methods passed as parameters,
  ///     and enables a View to bind commands to objects that are not part of the element tree.
  /// </summary>
  public class DelegateCommand : ICommand
  {
    #region Constructors

    /// <summary>
    /// Constructor
    /// </summary>
    public DelegateCommand(Action executeMethod)
        : this(executeMethod, null, false)
    {
    }

    /// <summary>
    ///     Constructor
    /// </summary>
    public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod)
        : this(executeMethod, canExecuteMethod, false)
    {
    }

    /// <summary>
    ///     Constructor
    /// </summary>
    public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod, bool isAutomaticRequeryDisabled)
    {
      if (executeMethod == null)
      {
        throw new ArgumentNullException("executeMethod");
      }

      _executeMethod = executeMethod;
      _canExecuteMethod = canExecuteMethod;
      _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled;
    }

    #endregion

    #region Public Methods

    /// <summary>
    ///     Method to determine if the command can be executed
    /// </summary>
    public bool CanExecute()
    {
      if (_canExecuteMethod != null)
      {
        return _canExecuteMethod();
      }
      return true;
    }

    /// <summary>
    ///     Execution of the command
    /// </summary>
    public void Execute()
    {
      if (_executeMethod != null)
      {
        _executeMethod();
      }
    }

    /// <summary>
    ///     Property to enable or disable CommandManager's automatic requery on this command
    /// </summary>
    public bool IsAutomaticRequeryDisabled
    {
      get
      {
        return _isAutomaticRequeryDisabled;
      }
      set
      {
        if (_isAutomaticRequeryDisabled != value)
        {
          if (value)
          {
            CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers);
          }
          else
          {
            CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers);
          }
          _isAutomaticRequeryDisabled = value;
        }
      }
    }

    /// <summary>
    ///     Raises the CanExecuteChaged event
    /// </summary>
    public void RaiseCanExecuteChanged()
    {
      OnCanExecuteChanged();
    }

    /// <summary>
    ///     Protected virtual method to raise CanExecuteChanged event
    /// </summary>
    protected virtual void OnCanExecuteChanged()
    {
      CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
    }

    #endregion

    #region ICommand Members

    /// <summary>
    /// ICommand.CanExecuteChanged implementation
    /// </summary>
    public event EventHandler CanExecuteChanged
    {
      add
      {
        if (!_isAutomaticRequeryDisabled)
        {
          CommandManager.RequerySuggested += value;
        }
        CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
      }
      remove
      {
        if (!_isAutomaticRequeryDisabled)
        {
          CommandManager.RequerySuggested -= value;
        }
        CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
      }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameter"></param>
    /// <returns></returns>
    bool ICommand.CanExecute(object parameter)
    {
      return CanExecute();
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameter"></param>
    void ICommand.Execute(object parameter)
    {
      Execute();
    }

    #endregion

    #region Data
    /// <summary>
    /// 
    /// </summary>
    private readonly Action _executeMethod = null;
    /// <summary>
    /// 
    /// </summary>
    private readonly Func<bool> _canExecuteMethod = null;
    /// <summary>
    /// 
    /// </summary>
    private bool _isAutomaticRequeryDisabled = false;
    /// <summary>
    /// 
    /// </summary>
    private List<WeakReference> _canExecuteChangedHandlers;

    #endregion
  }

  /// <summary>
  ///     This class allows delegating the commanding logic to methods passed as parameters,
  ///     and enables a View to bind commands to objects that are not part of the element tree.
  /// </summary>
  /// <typeparam name="TExecuteParameter">Type of the parameter passed to the delegates</typeparam>
  public class DelegateCommand<TExecuteParameter> : ICommand
  {
    #region Constructors

    /// <summary>
    ///     Constructor
    /// </summary>
    public DelegateCommand(Action<TExecuteParameter> onExecute)
        : this(onExecute, null, false)
    {
    }

    /// <summary>
    ///     Constructor
    /// </summary>
    public DelegateCommand(Action<TExecuteParameter> onExecute, Func<TExecuteParameter, bool> canExecute)
        : this(onExecute, canExecute, false)
    {
    }

    /// <summary>
    ///     Constructor
    /// </summary>
    public DelegateCommand(Action<TExecuteParameter> onExecute, Func<TExecuteParameter, bool> canExecute, bool isAutomaticRequeryDisabled)
    {
      if (onExecute == null)
      {
        throw new ArgumentNullException("executeMethod");
      }
      _onExecute = onExecute;
      _canExecute = canExecute;
      _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled;
    }

    #endregion

    #region Public Methods

    /// <summary>
    ///     Method to determine if the command can be executed
    /// </summary>
    public bool CanExecute(TExecuteParameter parameter)
    {
      if (_canExecute != null)
      {
        return _canExecute(parameter);
      }
      return true;
    }

    /// <summary>
    ///     Execution of the command
    /// </summary>
    public void Execute(TExecuteParameter parameter)
    {
      if (_onExecute != null)
      {
        _onExecute(parameter);
      }
    }

    /// <summary>
    ///     Raises the CanExecuteChaged event
    /// </summary>
    public void RaiseCanExecuteChanged()
    {
      OnCanExecuteChanged();
    }

    /// <summary>
    ///     Protected virtual method to raise CanExecuteChanged event
    /// </summary>
    protected virtual void OnCanExecuteChanged()
    {
      CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
    }

    /// <summary>
    ///     Property to enable or disable CommandManager's automatic requery on this command
    /// </summary>
    public bool IsAutomaticRequeryDisabled
    {
      get
      {
        return _isAutomaticRequeryDisabled;
      }
      set
      {
        if (_isAutomaticRequeryDisabled != value)
        {
          if (value)
          {
            CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers);
          }
          else
          {
            CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers);
          }
          _isAutomaticRequeryDisabled = value;
        }
      }
    }

    #endregion

    #region ICommand Members

    /// <summary>
    ///     ICommand.CanExecuteChanged implementation
    /// </summary>
    public event EventHandler CanExecuteChanged
    {
      add
      {
        if (!_isAutomaticRequeryDisabled)
        {
          CommandManager.RequerySuggested += value;
        }
        CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
      }
      remove
      {
        if (!_isAutomaticRequeryDisabled)
        {
          CommandManager.RequerySuggested -= value;
        }
        CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
      }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameter"></param>
    /// <returns></returns>
    bool ICommand.CanExecute(object parameter)
    {
      // if T is of value type and the parameter is not
      // set yet, then return false if CanExecute delegate
      // exists, else return true
      var type = typeof(TExecuteParameter);
      if (type.IsValueType && type.IsPrimitive)
      {
        if (int.TryParse(parameter.ToString(), out int intResult))
        {
          return CanExecute((TExecuteParameter)(object)intResult);
        }
      }

      if (parameter == null && type.IsValueType)
      {
        return (_canExecute == null);
      }
      return CanExecute((TExecuteParameter)parameter);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="parameter"></param>
    void ICommand.Execute(object parameter)
    {
      Execute((TExecuteParameter)parameter);
    }

    #endregion

    #region Data
    /// <summary>
    /// 
    /// </summary>
    private readonly Action<TExecuteParameter> _onExecute = null;
    /// <summary>
    /// 
    /// </summary>
    private readonly Func<TExecuteParameter, bool> _canExecute = null;
    /// <summary>
    /// 
    /// </summary>
    private bool _isAutomaticRequeryDisabled = false;
    /// <summary>
    /// 
    /// </summary>
    private List<WeakReference> _canExecuteChangedHandlers;

    #endregion
  }

  /// <summary>
  ///     This class contains methods for the CommandManager that help avoid memory leaks by
  ///     using weak references.
  /// </summary>
  internal class CommandManagerHelper
  {
    internal static void CallWeakReferenceHandlers(List<WeakReference> handlers)
    {
      if (handlers != null)
      {
        // Take a snapshot of the handlers before we call out to them since the handlers
        // could cause the array to me modified while we are reading it.

        EventHandler[] callees = new EventHandler[handlers.Count];
        int count = 0;

        for (int i = handlers.Count - 1; i >= 0; i--)
        {
          WeakReference reference = handlers[i];
          EventHandler handler = reference.Target as EventHandler;
          if (handler == null)
          {
            // Clean up old handlers that have been collected
            handlers.RemoveAt(i);
          }
          else
          {
            callees[count] = handler;
            count++;
          }
        }

        // Call the handlers that we snapshotted
        for (int i = 0; i < count; i++)
        {
          EventHandler handler = callees[i];
          handler(null, EventArgs.Empty);
        }
      }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="handlers"></param>
    internal static void AddHandlersToRequerySuggested(List<WeakReference> handlers)
    {
      if (handlers != null)
      {
        foreach (WeakReference handlerRef in handlers)
        {
          EventHandler handler = handlerRef.Target as EventHandler;
          if (handler != null)
          {
            CommandManager.RequerySuggested += handler;
          }
        }
      }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="handlers"></param>
    internal static void RemoveHandlersFromRequerySuggested(List<WeakReference> handlers)
    {
      if (handlers != null)
      {
        foreach (WeakReference handlerRef in handlers)
        {
          EventHandler handler = handlerRef.Target as EventHandler;
          if (handler != null)
          {
            CommandManager.RequerySuggested -= handler;
          }
        }
      }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="handlers"></param>
    /// <param name="handler"></param>
    internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler)
    {
      AddWeakReferenceHandler(ref handlers, handler, -1);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="handlers"></param>
    /// <param name="handler"></param>
    /// <param name="defaultListSize"></param>
    internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler, int defaultListSize)
    {
      if (handlers == null)
      {
        handlers = (defaultListSize > 0 ? new List<WeakReference>(defaultListSize) : new List<WeakReference>());
      }

      handlers.Add(new WeakReference(handler));
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="handlers"></param>
    /// <param name="handler"></param>
    internal static void RemoveWeakReferenceHandler(List<WeakReference> handlers, EventHandler handler)
    {
      if (handlers != null)
      {
        for (int i = handlers.Count - 1; i >= 0; i--)
        {
          WeakReference reference = handlers[i];
          EventHandler existingHandler = reference.Target as EventHandler;
          if ((existingHandler == null) || (existingHandler == handler))
          {
            // Clean up old handlers that have been collected
            // in addition to the handler that is to be removed.
            handlers.RemoveAt(i);
          }
        }
      }
    }
  }
}

<Button Width="60"
            Height="30"
            DataContext="{Binding RelativeSource={RelativeSource AncestorType=Window}}"
            Command="{Binding TestCommand}"
            CommandParameter="123">Test</Button>