C#:WinForm之Command

　　本文主要介绍WinForm项目中如何像WPF一样优雅的使用Command来实现业务操作。想必大家已经疲于双击控件生成事件处理方法来实现业务操作，如多控件（按钮、菜单、工具条、状态栏等命令控件）来做同一个动作，还要控制它们启用（Enabled）状态等等，使代码结构冗长且可读性差。下面具体介绍和实现WinForm中对Command的应用。

1. 命令（Command）
   

   顾 名思义，定义一个命令，继承至System.Windows.Input.ICommand接口，实现 Execute(object) ，CanExecute(object)方法和 CanExecuteChanged事件。由 CanExecute 确定是否调用 Execute 执行该命令。
   

       /// <summary>
       /// 定义一个执行的命令。
       /// </summary>
       public abstract class Command : ICommand
       {
           /// <summary>
           /// The can executable
           /// </summary>
           private bool canExecutable = true;
   
           /// <summary>
           /// 当出现影响是否应执行该命令的更改时发生。
           /// </summary>
           public event EventHandler CanExecuteChanged;
   
           /// <summary>
           /// 定义用于确定此命令是否可以在其当前状态下执行的方法。
           /// </summary>
           /// <param name="parameter">此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。</param>
           /// <returns>如果可以执行此命令，则为 true；否则为 false。</returns>
           public abstract bool CanExecute(object parameter);
   
           /// <summary>
           /// 定义在调用此命令时调用的方法。
           /// </summary>
           /// <param name="parameter">此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。</param>
           public abstract void Execute(object parameter);
   
   
           /// <summary>
           /// 提升命令状态更改。
           /// </summary>
           /// <param name="parameter">The parameter.</param>
           internal protected void RaiseCommandState(object parameter)
           {
               var able = CanExecute(parameter);
               if (able != canExecutable)
               {
                   canExecutable = able;
                   OnCanExecuteChanged(EventArgs.Empty);
               }
           }
   
           /// <summary>
           /// 触发当命令状态更改事件。
           /// </summary>
           /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
           protected virtual void OnCanExecuteChanged(EventArgs e)
           {
               if (CanExecuteChanged != null)
               {
                   CanExecuteChanged(this, e);
               }
           }
       }

2. 命令参数（CommandParameter）
   

   提供给命令执行时的参数，该对象主要由参数源（Source）和参数源的属性（Parameter）构成。参数源可继承至System.ComponentModels.INotifyPropertyChanged接口，实现属性值更改通知。此 Parameter 必须为属性（也可以是静态属性）。
   

       /// <summary>
       /// 表示命令参数。
       /// </summary>
       public sealed class CommandParameter
       {
           private readonly Type sourceType;
           private readonly object source;
           private readonly string propertyMember;
   
           private readonly bool booleanOppose = false;
           private Command command;
   
           /// <summary>
           /// 获取一个值，该值表示命令参数源。
           /// </summary>
           /// <value>The source.</value>
           public object Source
           {
               get { return source; }
           }
   
           /// <summary>
           /// 获取一个值，该值表示命令参数的类型若当前非静态类型绑定则为 Source 类型。
           /// </summary>
           /// <value>The type of the source.</value>
           public Type SourceType
           {
               get
               {
                   return sourceType;
               }
           }
   
           /// <summary>
           /// 获取一个值，该值表示命令执行参数。
           /// </summary>
           /// <value>The parameter.</value>
           public object Parameter { get { return ResolvePropertyValue(); } }
   
           /// <summary>
           /// 获取一个值，该值表示参数所属的命令。
           /// </summary>
           /// <value>The command.</value>
           public Command Command
           {
               get
               {
                   return command;
               }
               internal set
               {
                   if (value != command)
                   {
                       command = value;
                       command.RaiseCommandState(Parameter);
                   }
               }
           }
   
           /// <summary>
           /// 初始化 RelateCommandParameter 新实例。
           /// </summary>
           /// <param name="source">绑定源。</param>
           /// <param name="propertyMember">绑定成员（属性名称）。</param>
           /// <param name="booleanOppose">若值为System.Boolean时，是否取反。</param>
           public CommandParameter(object source, string propertyMember, bool booleanOppose = false)
           {
               this.source = source;
               this.sourceType = source.GetType();
               this.propertyMember = propertyMember;
               this.booleanOppose = booleanOppose;
               BindNotifyObject(source);
           }
   
           /// <summary>
           /// 初始化 RelateCommandParameter 新实例。
           /// </summary>
           /// <param name="source">绑定源。</param>
           /// <param name="propertyMember">绑定成员（属性名称）。</param>
           /// <param name="booleanOppose">若值为System.Boolean时，是否取反。</param>
           public CommandParameter(object source, Expression<Func<string>> propertyMember, bool booleanOppose = false)
               : this(source, ResolvePropertyName(propertyMember), booleanOppose)
           {
   
           }
   
           /// <summary>
           /// 初始化一个可指定静态成员的 RelateCommandParameter 新实例。
           /// </summary>
           /// <param name="staticSourceType">静态类类型。</param>
           /// <param name="propertyMember">绑定成员（属性名称）。</param>
           /// <param name="booleanOppose">若值为System.Boolean时，是否取反。</param>
           public CommandParameter(Type staticSourceType, string propertyMember, bool booleanOppose = false)
           {
               this.sourceType = staticSourceType;
               this.propertyMember = propertyMember;
               this.booleanOppose = booleanOppose;
           }
   
           private void BindNotifyObject(object source)
           {
               if (typeof(INotifyPropertyChanged).IsAssignableFrom(source.GetType()))
               {
                   ((INotifyPropertyChanged)source).PropertyChanged += SourcePropertyChanged;
               }
           }
   
           private void SourcePropertyChanged(object sender, PropertyChangedEventArgs e)
           {
               if (e.PropertyName == propertyMember)
               {
                   if (Command != null)
                   {
                       Command.RaiseCommandState(Parameter);
                   }
               }
           }
   
           private object ResolvePropertyValue()
           {
               var flags = System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic;
               if (source == null)
               {
                   flags |= System.Reflection.BindingFlags.Static;
               }
               else
               {
                   flags |= System.Reflection.BindingFlags.Instance;
               }
   
               var pro = sourceType.GetProperty(propertyMember, flags);
               if (pro == null)
               {
                   throw new MemberAccessException(string.Format("Not found {2} member "{0}" in "{1}"", propertyMember, sourceType, source == null ? "static" : "instance"));
               }
               if (Type.GetTypeCode(pro.PropertyType) == TypeCode.Boolean)
               {
                   if (booleanOppose)
                   {
                       return !((Boolean)pro.GetValue(source));
                   }
               }
               return pro.GetValue(source);
           }
   
           private static string ResolvePropertyName(Expression<Func<string>> propertyMember)
           {
               if (propertyMember != null)
               {
                   return ((MemberExpression)propertyMember.Body).Member.Name;
               }
               else
               {
                   throw new ArgumentNullException("propertyMember");
               }
           }
       }

3. 命令绑定（CommandBinding）
   

   将命令和命令参数组合构建成一个绑定对象。
   

       /// <summary>
       /// 定义命令绑定对象。
       /// </summary>
       public sealed class CommandBinding
       {
           /// <summary>
           /// 获取一个值，该值表示命令绑定的对象。
           /// </summary>
           /// <value>The command.</value>
           public Command Command { get; private set; }
   
           /// <summary>
           /// 获取一个值，该值表示命令执行参数。
           /// </summary>
           /// <value>The command parameter.</value>
           public CommandParameter CommandParameter { get; private set; }
   
           /// <summary>
           /// 初始化 <see cref="CommandBinding"/> 新实例。
           /// </summary>
           /// <param name="command">要绑定的命令。</param>
           public CommandBinding(Command command)
               : this(command, null)
           {
   
           }
   
           /// <summary>
           /// 初始化 <see cref="CommandBinding"/> 新实例。
           /// </summary>
           /// <param name="command">要绑定的命令。</param>
           /// <param name="commandParameter">要绑定的命令参数。</param>
           public CommandBinding(Command command, CommandParameter commandParameter)
           {
               this.Command = command;
               this.CommandParameter = commandParameter;
               if (this.CommandParameter != null)
               {
                   this.CommandParameter.Command = this.Command;
               }
           }
   
           /// <summary>
           /// 初始化 <see cref="CommandBinding"/> 新实例。
           /// </summary>
           /// <param name="command">要绑定的命令。</param>
           /// <param name="source">要绑定的命令参数的实例。</param>
           /// <param name="propertyMember">要绑定的命令参数的属性名称。</param>
           /// <param name="booleanOppose">若值为System.Boolean值时，是否取反向值。</param>
           public CommandBinding(Command command, object source, string propertyMember, bool booleanOppose = false)
               : this(command, CreateCommandParameter(source, propertyMember, booleanOppose))
           {
   
           }
   
           /// <summary>
           /// 初始化 <see cref="CommandBinding"/> 新实例。
           /// </summary>
           /// <param name="command">要绑定的命令。</param>
           /// <param name="staticSourceType">静态类类型。</param>
           /// <param name="propertyMember">绑定成员（属性名称）。</param>
           /// <param name="booleanOppose">若值为System.Boolean时，是否取反。</param>
           public CommandBinding(Command command, Type staticSourceType, string propertyMember, bool booleanOppose = false)
               : this(command, new CommandParameter(staticSourceType, propertyMember, booleanOppose))
           {
           }
   
           private static CommandParameter CreateCommandParameter(object source, string propertyMember, bool booleanOppose = false)
           {
               return new CommandParameter(source, propertyMember, booleanOppose);
           } 
       }

4. 命令目标（CommandTarget）
   

   此为最终执行命令的目标，构建此对象实例时指定一个绑定（CommandBinding），监视WinForm命令控件（如Control、ToolStripItem）等包含 Click 事件和 Enabled 属性的对象。
   

       /// <summary>
       /// 表示命令绑定的执行目标。
       /// </summary>
       public sealed class CommandTarget : IDisposable
       {
           private readonly object target;
           private bool disposed = false;
   
           /// <summary>
           /// 获取一个值，该值表示目标是否已释放。
           /// </summary>
           /// <value><c>true</c> if disposed; otherwise, <c>false</c>.</value>
           public bool Disposed { get { return disposed; } }
   
           /// <summary>
           /// 获取一个值，该值表示目标的命令绑定源。
           /// </summary>
           /// <value>The command binding.</value>
           public CommandBinding CommandBinding { get; private set; }
   
           /// <summary>
           /// 初始化 CommandTarget 新实例。
           /// </summary> 
           /// <param name="binding">命令绑定源。</param>
           private CommandTarget(CommandBinding binding)
           {
               CommandBinding = binding;
               CommandBinding.Command.CanExecuteChanged += CommandStateChanged;
           }
   
   
           /// <summary>
           /// 初始化 CommandTarget 新实例。
           /// </summary>
           /// <param name="control">绑定目标。</param>
           /// <param name="commandBinding">命令绑定源。</param>
           public CommandTarget(Control control, CommandBinding commandBinding)
               : this(commandBinding)
           {
               target = control;
               control.Click += OnClick;
               var parameter = GetParameterValue();
               control.Enabled = commandBinding.Command.CanExecute(parameter);
           }
   
           /// <summary>
           /// 初始化 CommandTarget 新实例。
           /// </summary>
           /// <param name="item">绑定目标。</param>
           /// <param name="commandBinding">命令绑定源。</param>
           public CommandTarget(ToolStripItem item, CommandBinding commandBinding)
               : this(commandBinding)
           {
               target = item;
               item.Click += OnClick;
               var parameter = GetParameterValue();
               item.Enabled = commandBinding.Command.CanExecute(parameter);
           }
   
   
           /// <summary>
           /// Handles the <see cref="E:Click" /> event.
           /// </summary>
           /// <param name="sender">The sender.</param>
           /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
           private void OnClick(object sender, EventArgs e)
           {
               object parameter = null;
               if (CommandBinding.CommandParameter != null)
               {
                   parameter = CommandBinding.CommandParameter.Parameter;
               }
               var command = CommandBinding.Command;
               if (command.CanExecute(parameter))
               {
                   command.Execute(parameter);
               }
           }
           /// <summary>
           /// Commands the state changed.
           /// </summary>
           /// <param name="sender">The sender.</param>
           /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
           private void CommandStateChanged(object sender, EventArgs e)
           {
               var property = target.GetType().GetProperty("Enabled");
               if (property != null)
               {
                   var parameter = GetParameterValue();
                   var enable = CommandBinding.Command.CanExecute(parameter);
                   property.SetValue(target, enable);
               }
           }
   
           private object GetParameterValue()
           {
               if (CommandBinding.CommandParameter == null)
               {
                   return null;
               }
               return CommandBinding.CommandParameter.Parameter;
           }
   
           /// <summary>
           /// 执行与释放或重置非托管资源相关的应用程序定义的任务。
           /// </summary>
           public void Dispose()
           {
               if (disposed)
               {
                   return;
               }
               disposed = true;
               CommandBindingManager.Unregister(this);
               CommandBinding.Command.CanExecuteChanged -= CommandStateChanged;
               if (target is Control)
               {
                   ((Control)target).Click -= OnClick;
               }
               if (target is ToolStripItem)
               {
                   ((Control)target).Click -= OnClick;
               }
           } 
       }

5. 命令绑定管理器（CommandBindingManager）
   

   命令绑定管理器提供命令绑定（CommandBinding）与命令控件（WinForm控件）注册与反注册功能。
   

       /// <summary>
       /// 表示命令注册管理器。
       /// </summary>
       public static class CommandBindingManager
       {
           private static readonly List<CommandTarget> targets = new List<CommandTarget>();
   
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="control">绑定目标。</param>
           /// <param name="commandBinding">命令绑定源。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(Control control, CommandBinding commandBinding)
           {
               var target = new CommandTarget(control, commandBinding);
               targets.Add(target);
               return target;
           }
   
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="stripItem">绑定目标。</param>
           /// <param name="commandBinding">命令绑定源。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(ToolStripItem stripItem, CommandBinding commandBinding)
           {
               var target = new CommandTarget(stripItem, commandBinding);
               targets.Add(target);
               return target;
           }
   
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="control">绑定目标。</param>
           /// <param name="command">绑定命令。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(Control control, Command command)
           {
               return Register(control, new CommandBinding(command));
           }
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="stripItem">绑定目标。</param>
           /// <param name="command">绑定命令。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(ToolStripItem stripItem, Command command)
           {
               return Register(stripItem, new CommandBinding(command));
           }
   
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="control">绑定目标。</param>
           /// <param name="command">绑定命令。</param>
           /// <param name="source">构造命令参数的源。</param>
           /// <param name="propertyName">构造命令参数的名称。</param>
           /// <param name="booleanOppose">若值为System.Boolean值时，是否取反向值。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(Control control, Command command, object source, string propertyName, bool booleanOppose = false)
           {
               var commandBinding = new CommandBinding(command, source, propertyName, booleanOppose);
               return Register(control, commandBinding);
           }
   
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="stripItem">绑定目标。</param>
           /// <param name="command">绑定命令。</param>
           /// <param name="source">构造命令参数的源。</param>
           /// <param name="propertyName">构造命令参数的名称。</param>
           /// <param name="booleanOppose">若值为System.Boolean值时，是否取反向值。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(ToolStripItem stripItem, Command command, object source, string propertyName, bool booleanOppose = false)
           {
               var commandBinding = new CommandBinding(command, source, propertyName, booleanOppose);
               return Register(stripItem, commandBinding);
           }
   
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="control">绑定目标。</param>
           /// <param name="command">绑定命令。</param>
           /// <param name="staticSourceType">静态类类型。</param>
           /// <param name="propertyName">构造命令参数的名称。</param>
           /// <param name="booleanOppose">若值为System.Boolean值时，是否取反向值。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(Control control, Command command, Type staticSourceType, string propertyName, bool booleanOppose = false)
           {
               var commandBinding = new CommandBinding(command, staticSourceType, propertyName, booleanOppose);
               return Register(control, commandBinding);
           }
           /// <summary>
           /// 注册命令道指定的命令控件。
           /// </summary>
           /// <param name="stripItem">绑定目标。</param>
           /// <param name="command">绑定命令。</param>
           /// <param name="staticSourceType">静态类类型。</param>
           /// <param name="propertyName">构造命令参数的名称。</param>
           /// <param name="booleanOppose">若值为System.Boolean值时，是否取反向值。</param>
           /// <returns>返回一个命令目标实例。</returns>
           public static CommandTarget Register(ToolStripItem stripItem, Command command, Type staticSourceType, string propertyName, bool booleanOppose = false)
           {
               var commandBinding = new CommandBinding(command, staticSourceType, propertyName, booleanOppose);
               return Register(stripItem, commandBinding);
           }
            
           /// <summary>
           /// 反注册命令。
           /// </summary>
           /// <param name="target">注销的命令目标。</param>
           public static void Unregister(CommandTarget target)
           {
               if (target == null)
               {
                   return;
               }
               if (targets.Contains(target))
               {
                   targets.Remove(target);
                   target.Dispose();
               }
           }
       }

最后附上委托命令（DegelateCommand）的实现。

    /// <summary>
    /// 表示一个可被执行委托的方法的命令。
    /// </summary>
    public sealed class DelegateCommand : Command
    {
        private Action<object> execute;
        private Func<object, bool> canExecute;
        /// <summary>
        /// 初始化 <see cref="DelegateCommand"/> 新实例。
        /// </summary>
        /// <param name="execute">当命令被调用时，指定的方法。</param>
        /// <param name="canExecute">当命令被确定是否能执行时，执行的方法。</param>
        public DelegateCommand(Action<object> execute, Func<object, bool> canExecute = null)
        {
            this.execute = execute;
            this.canExecute = canExecute;
        }
        /// <summary>
        /// 定义用于确定此命令是否可以在其当前状态下执行的方法。
        /// </summary>
        /// <param name="parameter">此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。</param>
        /// <returns>如果可以执行此命令，则为 true；否则为 false。</returns>
        public override bool CanExecute(object parameter)
        {
            if (canExecute == null)
            {
                return true;
            }
            return canExecute(parameter);
        }

        /// <summary>
        /// 定义在调用此命令时调用的方法。
        /// </summary>
        /// <param name="parameter">此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。</param>
        public override void Execute(object parameter)
        {
            if (CanExecute(parameter))
            {
                execute(parameter);
            }
        }
    } 

　　 补充：不好意思，忘记附上Demo示例，现补上，请前往 百度网盘 下载

 

　　本文如有纰漏，欢迎大家批评指正！