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, );
       }
       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, );
       }
       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 = ;

         for (int i = handlers.Count - ; i >= ; 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 = ; 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, -);
     }

     /// <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 >  ? 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 - ; i >= ; 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>