Command

 /// <summary>
    /// Class RelayCommand
    /// </summary>
    public class RelayCommand : ICommand
    {
        #region ... Variables  ...
        /// <summary>
        /// 
        /// </summary>
        readonly Action mExecute;
        /// <summary>
        /// 
        /// </summary>
        readonly Func<bool> mCanExecute;
        #endregion ...Variables...

        #region ... Events     ...

        #endregion ...Events...

        #region ... Constructor...
        /// <summary>
        /// Creates a new command that can always execute.
        /// </summary>
        /// <param name="execute">The execution logic.</param>
        public RelayCommand(Action execute)
            : this(execute, null)
        {
        }
        /// <summary>
        /// Creates a new command.
        /// </summary>
        /// <param name="execute">The execution logic.</param>
        /// <param name="canExecute">The execution status logic.</param>
        public RelayCommand(Action execute, Func<bool> canExecute)
        {
            mExecute = execute;
            mCanExecute = canExecute;
        }
        #endregion ...Constructor...

        #region ... Properties ...

        #endregion ...Properties...

        #region ... Methods    ...
        /// <summary>
        /// 定义用于确定此命令是否可以在其当前状态下执行的方法。
        /// </summary>
        /// <param name="parameter">此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。</param>
        /// <returns>
        /// 如果可以执行此命令，则为 true；否则为 false。
        /// </returns>
        [DebuggerStepThrough]
        public bool CanExecute(object parameter)
        {
            return mCanExecute == null ? true : mCanExecute();
        }
        /// <summary>
        /// 当出现影响是否应执行该命令的更改时发生。
        /// </summary>
        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (mCanExecute != null)
                    CommandManager.RequerySuggested += value;
            }
            remove
            {
                if (mCanExecute != null)
                    CommandManager.RequerySuggested -= value;
            }
        }
        /// <summary>
        /// 定义在调用此命令时调用的方法。
        /// </summary>
        /// <param name="parameter">此命令使用的数据。 如果此命令不需要传递数据，则该对象可以设置为 null。</param>
        public void Execute(object parameter)
        {
            mExecute();
        }
        #endregion ...Methods...

        #region ... Interfaces ...

        #endregion ...Interfaces...
    }

使用时

        /// <summary>
        /// Gets up tag command.
        /// </summary>
        /// <value>Up tag command.</value>
        public ICommand UpTagCommand
        {
            get
            {
                if (mUpTagCommand == null)
                {
                    mUpTagCommand = new RelayCommand(() =>
                        {
                            ExecuteUpTagCommand();
                        });
                }
                return mUpTagCommand;
            }
        }

需要command传递参数时

    /// <summary>
    /// A command whose sole purpose is to 
    /// relay its functionality to other
    /// objects by invoking delegates. The
    /// default return value for the CanExecute
    /// method is 'true'.
    /// </summary>
    public class RelayCommand<T> : ICommand
    {
        #region ... Variables  ...
        /// <summary>
        /// The execute
        /// </summary>
        readonly Action<T> mExecute = null;
        readonly Predicate<T> mCanExecute = null;
        #endregion ...Variables...

        #region ... Events     ...
        /// <summary>
        /// 当出现影响是否应执行该命令的更改时发生。
        /// </summary>
        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (mCanExecute != null)
                    CommandManager.RequerySuggested += value;
            }
            remove
            {
                if (mCanExecute != null)
                    CommandManager.RequerySuggested -= value;
            }
        }
        #endregion ...Events...

        #region ... Constructor...
        /// <summary>
        /// 
        /// </summary>
        /// <param name="execute"></param>
        public RelayCommand(Action<T> execute)
            : this(execute, null)
        {
        }
        /// <summary>
        /// Creates a new command.
        /// </summary>
        /// <param name="execute">The execution logic.</param>
        /// <param name="canExecute">The execution status logic.</param>
        public RelayCommand(Action<T> execute, Predicate<T> canExecute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");

            mExecute = execute;
            mCanExecute = canExecute;
        }

        #endregion ...Constructor...

        #region ... Properties ...

        #endregion ...Properties...

        #region ... Methods    ...
        /// <summary>
        /// 
        /// </summary>
        /// <param name="parameter"></param>
        /// <returns></returns>
        [DebuggerStepThrough]
        public bool CanExecute(object parameter)
        {
            return mCanExecute == null ? true : mCanExecute((T)parameter);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="parameter"></param>
        public void Execute(object parameter)
        {
            mExecute((T)parameter);
        }
        #endregion ...Methods...

        #region ... Interfaces ...

        #endregion ...Interfaces...

    }

使用

            <Button Grid.Row="1" Grid.Column="1" Name="btnCenter"  Height="33" Width="33" Margin="6" Command="{Binding VCHMoveCommand}" CommandParameter="MiddleCommand">

                <Image Source="../Resources/Center.ico"></Image>
            </Button>

        /// <summary>
        /// Gets the VCH move command.
        /// </summary>
        /// <value>The VCH move command.</value>
        public ICommand VCHMoveCommand
        {
            get
            {
                if (mVCHMoveCommand == null)
                {
                    mVCHMoveCommand = new RelayCommand<string>((parameter) =>
                    {
                        ExecuteVCHMoveCommand(parameter);
                    });
                }
                return mVCHMoveCommand;
            }
        }