设计模式Command命令模式

   命令模式是对命令的封装。通过封装把发出命令的责任和执行命令的责任分割开，委派给不同的对象。 命令（Command）模式属于对象的行为模式【GOF95】，它又称为行动（Action）模式或交易（Transaction）模式。
   每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式允许请求的一方和接收的一方独立开来，使得请求 的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。
命令模式涉及到五个角色，它们分别是：

1、客户（Client）角色：创建了一个具体命令(ConcreteCommand)对象并确定其接收者。 
2、命令（Command）角色：声明了一个给所有具体命令类的抽象接口。这是一个抽象角色。 
3、具体命令（ConcreteCommand）角色：定义一个接受者和行为之间的弱耦合；实现Execute()方法，负责调用接收考的相应操作。Execute()方法通常叫做执方法。 
4、请求者（Invoker）角色：负责调用命令对象执行请求，相关的方法叫做行动方法。 
5、接收者（Receiver）角色：负责具体实施和执行一个请求。任何一个类都可以成为接收者，实施和执行请求的方法叫做行动方法。

    代码实现：
   根据命令（Command）角色所要负责的工作，我们可分为两种方式来实现：

   1、一种是Seperate方式，此方式下命令（Command）角色仅确定一个接收者和执行该请求的动作，因此，它需要在子类中完成具体的命令操作，并通过请求者（Invoker）角色这一中间层来与接收者互动。
   2、另一种是Combine方式，此时命令（Command）角色要自己实现所有命令功能，根本不需要请求者（Invoker）角色，它自己充当了中间层来与接收者互动。

   下面我们来用代码说明如何理解Command命令模式,程序如下图:
            
  一、传统的做法：不采用Command模式的情况
  1、定义一个类Car

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

namespace CommandCar
{
    //一个类是一组操作和相应的一些变量的集合，现在有这样一个类Car，它有如下的一些操作
    public  class Car
    {
        public string curStateStr;
        public Car()
        {
            curStateStr = "";
        }


        public void Start()
        {
            Console.WriteLine("车子起动");
        }
        public void MoveForwards()
        {
            Console.WriteLine("车子前进");
        }

        public void MoveBackwards()
        {
            Console.WriteLine("车子倒退");
        }

        public void Stop()
        {
            Console.WriteLine("车子停止");
        }
    }
}

  2、使用这个类及其相关操作,写在Programme.cs中

            #region  通常的操作(紧耦合方式)
            //通常的操作使得行为的请求者和行为的实现者之间呈现一种紧耦合,如果我们要对相关操作进行Redo，Undo等操作则这种紧耦合方式就显得很复杂
            //可以看到，客户程序是依赖于具体Car的命令（方法）的，引入Command模式，需要对Car中的4个命令进行抽象
            //在抽象前，在我们看来Start(),MoveForwards(),MoveBackwards(),Stop()这几个方法都应该是Car所具有的，
            //如果单独抽象出来成一个命令对象，那就是把函数层面的功能提到了类的层面

             Car mycar = new Car();
            Console.WriteLine("--------常规方式执行效果如下----------");
            mycar.Start();
            mycar.MoveForwards();
            mycar.MoveBackwards();
            mycar.Stop();
            // Console.ReadLine();
            #endregion

  这种情况下，把命令的接收者Car与行为(Start,Stop等操作)紧密耦合

  二、Seperate方式
  仍使用上面定义的类Car(它就是接收者Receiver角色),不同的是我们要加入以下角色
  1、命令Command角色CarSeperateCommand

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

namespace CommandCar
{
    //定义抽象类CarSeperateCommand，对于Function方式而言，它仅确定一个接收者Car和执行该请求的动作Excute。
    //所以，在抽象类CarSeperateCommand中，只声明一个Excute的方法。这个方法在其子类(StartCommand类,MoveForwardsCommand类,MoveBackwardsCommand类,StopCommand类)中进行实现。
    //（当然这个CarSeperateCommand还可以定义成接口）
    //Car所具有的其他的具体命令类(StartCommand类,MoveForwardsCommand类,MoveBackwardsCommand类,StopCommand类)都继承于该抽象类
    //StartCommand类,MoveForwardsCommand类,MoveBackwardsCommand类,StopCommand类将用于封装对应的操作命令

    public abstract  class CarSeperateCommand
    {
        Car _car;
        public CarSeperateCommand(Car mycar)
        {
            this._car = mycar;
        }

        public abstract void Excute();
    }
}

  
  2、具体命令（ConcreteCommand）角色:CarSeperateCommandClasses中内含的(StartCommand类,MoveForwardsCommand类,MoveBackwardsCommand类,StopCommand类)

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

namespace CommandCar
{
    //定义StartCommand类,MoveForwardsCommand类,MoveBackwardsCommand类,StopCommand类
    //这四个类都继承自抽象类CarFunctionCommand，它们实现了对Car对象自身所具备的Start(),MoveForwards(),MoveBackwards(),Stop()四个命令分别进行了封装
    //它们都把Car对象实例做为传入的参数

    #region StartCommand命令类
    public class StartCommand : CarSeperateCommand
    {
        Car _car;
        ArrayList CarState;

        public StartCommand(Car car,ArrayList state)
            : base(car)
        {
            this._car = car;
            CarState = state;
        }

        public override void Excute()
        {
            _car.Start();
            _car.curStateStr += "-Start";
            CarState.Add(_car.curStateStr);
        }
    }
    #endregion

    #region MoveForwardsCommand命令类
    public class MoveForwardsCommand : CarSeperateCommand
    {
        Car _car;
        ArrayList CarState;
        public MoveForwardsCommand(Car car, ArrayList state)
            : base(car)
        {
            this._car = car;
            CarState = state;
        }

        public override void Excute()
        {
            _car.MoveForwards();
            _car.curStateStr += "-MoveForwards";
            CarState.Add(_car.curStateStr);
        }
    }
    #endregion

    #region MoveBackwardsCommand命令类
    public class MoveBackwardsCommand : CarSeperateCommand
    {
        Car _car;
        ArrayList CarState;
        public MoveBackwardsCommand(Car car, ArrayList state)
            : base(car)
        {
            this._car = car;
            CarState = state;
        }

        public override void Excute()
        {
            _car.MoveBackwards();
            _car.curStateStr += "-MoveBackwards";
            CarState.Add(_car.curStateStr);
        }
    }
    #endregion

    #region  StopCommand命令类

    public class StopCommand : CarSeperateCommand
    {
        Car _car;
        ArrayList CarState;
        public StopCommand(Car car, ArrayList state)
            : base(car)
        {
            this._car = car;
            CarState = state;
        }

        public override void Excute()
        {
            _car.Stop();
            _car.curStateStr += "-Stop";
            CarState.Add(_car.curStateStr);
        }
    }
    #endregion

    #region Undo命令
    //此处的撤销操作只是意思上的表达，并无精确含义
    //主要是示范在命令模式下，我们要注意维护对象的状态信息
    public class UnDoCommand : CarSeperateCommand
    {
        Car _car;
        ArrayList CarState;
        public UnDoCommand(Car car, ArrayList state)
            : base(car)
        {
            this._car = car;
            CarState = state;
        }

        public override void Excute()
        {

            int count = CarState.Count;
 
            if (count<1)
            {
                Console.WriteLine("无法再回退操作!");
            }
            if (count == 1)
            {
                _car.curStateStr = (string)CarState[0];
                CarState.Clear();
            }

            if (count >1)
            {
                _car.curStateStr = (string)CarState[count-2];
                CarState.RemoveAt(count-1);
            }

        }
    }



    #endregion
}

 
  3、请求者（Invoker）角色：CarSeperateInvoker，它充当客户与操作的中间层

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

namespace CommandCar
{
    //这是一个中间角色CarSeperateInvoker，
    //通过这个中间角色，把对象Car对CarSeperateCommand的依赖转换为Car对CarSeperateInvoker的依赖。
    class CarSeperateInvoker
    {
        CarSeperateCommand _start;
        CarSeperateCommand _moveforwards;
        CarSeperateCommand _movebackwards;
        CarSeperateCommand _stop;
        CarSeperateCommand _undo;

        public CarSeperateInvoker(  CarSeperateCommand start,
                                    CarSeperateCommand moveforwards,
                                    CarSeperateCommand movebackwards,
                                    CarSeperateCommand stop,
                                    CarSeperateCommand undo)
        {
            this._start = start;
            this._moveforwards = moveforwards;
            this._movebackwards = movebackwards;
            this._stop = stop;
            this._undo = undo;
        }

        public void Start()
        {
            _start.Excute();
        }

        public void MoveForwards()
        {
            _moveforwards.Excute();
        }

        public void MoveBackwards()
        {
            _movebackwards.Excute();
        }

        public void Stop()
        {
            _stop.Excute();
        }
        public void Undo()
        {
            _undo.Excute();
        }
    }
}

  4、客户（Client）角色：写在Programme.cs中

  #region Seperate方式
            //在客户程序中，不再依赖于Car的Start(),MoveForwards(),MoveBackwards(),Stop()命令，
            //通过StartCommand类,MoveForwardCommand类,MoveBackwardCommand类,StopCommand类对这些命令进行了封装，使用它们的一个关键就是抽象的CarFunctionCommand类，它定义了一个操作的接口。
            //而StartCommand类,MoveForwardCommand类,MoveBackwardCommand类,StopCommand类四个对应于相关命令的类继承自CarFunctionCommand这个接口并实现接口中定义的Excute功能
            //同时我们也可以看到，本来这四个命令仅仅是四个方法而已，但是通过Command模式却把它们提到了类的层面，
            //它通过违背面向对象的原则为代价，解决了分离命令的请求者和命令的执行者的问题。
            Car mycar1 = new Car();
            Console.WriteLine("--------Seperate方式执行效果如下----------");
            Console.WriteLine("请输入下一步操作(str,f,b,stp,u,exit):");
            string CarOperation = Console.ReadLine();
            ArrayList CarState = new ArrayList();//Record state

            CarSeperateCommand carStart = new StartCommand(mycar1, CarState);
            CarSeperateCommand carMoveForwards = new MoveForwardsCommand(mycar1, CarState);
            CarSeperateCommand carMoveBackwards = new MoveBackwardsCommand(mycar1, CarState);
            CarSeperateCommand carStop = new StopCommand(mycar1, CarState);
            CarSeperateCommand carUndo = new UnDoCommand(mycar1, CarState);
            CarSeperateInvoker carInvoker = new CarSeperateInvoker(carStart, carMoveForwards, carMoveBackwards, carStop, carUndo);

            while (CarOperation != "Exit")
            {
                switch (CarOperation.ToLower())
                {

                    case "str": //启动
                        carInvoker.Start();
                        Console.WriteLine("Start Operation:" + mycar1.curStateStr);

                        break;

                    case "f": //前进
                        carInvoker.MoveForwards();
                        Console.WriteLine("MoveForwards Operation:" + mycar1.curStateStr);

                        break;
                    case "b": //后退
                        carInvoker.MoveBackwards();
                        Console.WriteLine("MoveBackwards Operation:" + mycar1.curStateStr);

                        break;
                    case "stp"://停止
                        carInvoker.Stop();
                        Console.WriteLine("Stop Operation:" + mycar1.curStateStr);
                        break;
                    case "u": //回退操作
                        carInvoker.Undo();
                        Console.WriteLine("Undo Operation:" + mycar1.curStateStr);
                        break;

                    default:

                        Console.WriteLine("命令输入错误:");

                        break;

                }

                Console.WriteLine("请输入下一步操作(str,f,b,stp,u,exit):");

                CarOperation = Console.ReadLine();

            }


           #endregion

  运行效果如下: 
                        

  三、Combine方式
   仍使用上面定义的类Car(它就是接收者Receiver角色),不同的是我们要加入以下角色
   1、命令Command角色CarCombineCommand：此处与Seperate方式最大的不同在于它要定义所有相关命令的接口，而不再是只定义一个Excute命令实现。

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

namespace CommandCar
{
    //与Seperate方式不同，在Combine方式中我们在CarCombineCommand抽象类中定义了需要实现的所有命令操作Start(),MoveForwards(),MoveBackwards(),Stop()
    //而在Seperate方式中则只定义了一个Excute操作，Car所具有的Start(),MoveForwards(),MoveBackwards(),Stop()操作需要创建四个子类来分别封装
    //在Combine方式，我们只需要定义一个CarCombineCommandAll子类来封装所有命令即可，当然它要继承自此处定义的CarCombineCommand抽象类
    abstract  class CarCombineCommand
    {
        public CarCombineCommand()
        { }

        public abstract void Start();
        public abstract void MoveForwards();
        public abstract void MoveBackwards();
        public abstract void Stop();

    }
}

   2、具体命令（ConcreteCommand）角色:此处与Seperate方式最大的不同在于它是在一个类中打包实现所以命令，它充当客户与操作的中间层。

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

namespace CommandCar
{
    class CarCombineCommandAll:CarCombineCommand 
    {
        private   Car _car;
        #region 构造函数
        public CarCombineCommandAll(Car mycar)
        {
            this._car = mycar;
        }
        #endregion

        #region Start操作
        public override void Start()
        {
            _car.Start();
        }
        #endregion

        #region MoveForwards操作
        public override void MoveForwards()
        {
            _car.MoveForwards();
        }
        #endregion

        #region MoveBackwards操作
        public override void MoveBackwards()
        {
            _car.MoveBackwards();
        }
        #endregion

        #region Stop操作
        public override void Stop()
        {
            _car.Stop();
        }
        #endregion

    }
}

   
   3、客户（Client）角色：写在Program.cs中

            #region Combine方式
            //在此可以看到与Seperate方式不同，我们不再针对Car所具有的Car的Start(),MoveForwards(),MoveBackwards(),Stop()命令分别提供一个对应的封装类
            //而是提供一个打包类CarCombineCommandAll，由它来实现统一的封装，当然，它要继承自抽象类CarCombineCommand，这个抽象类定义了所有操作命令接口，而不再是一个Excute命令

            Car mycar2 = new Car();
            CarCombineCommandAll ca = new CarCombineCommandAll(mycar2);

            Console.WriteLine("--------Combine方式执行效果如下----------");
            ca.Start();
            ca.MoveForwards();
            ca.MoveBackwards();
            ca.Stop();
            Console.ReadLine();

            #endregion

   运行效果如下:

                        

总结:

在什么情况下应当使用命令模式
1、使用命令模式作为"CallBack"在面向对象系统中的替代。"CallBack"讲的便是先将一个函数登记上，然后在以后调用此函数。
2、需要在不同的时间指定请求、将请求排队。一个命令对象和原先的请求发出者可以有不同的生命期。换言之，原先的请求发出者可能已经不在了，而命令对象本 身仍然是活动的。这时命令的接收者可以是在本地，也可以在网络的另外一个地址。命令对象可以在串形化之后传送到另外一台机器上去。
3、系统需要支持命令的撤消(undo)。命令对象可以把状态存储起来，等到客户端需要撤销命令所产生的效果时，可以调用undo()方法，把命令所产生的效果撤销掉。命令对象还可以提供redo()方法，以供客户端在需要时，再重新实施命令效果。
4、如果一个系统要将系统中所有的数据更新到日志里，以便在系统崩溃时，可以根据日志里读回所有的数据更新命令，重新调用Execute()方法一条一条执行这些命令，从而恢复系统在崩溃前所做的数据更新。
5、一个系统需要支持交易(Transaction)。一个交易结构封装了一组数据更新命令。使用命令模式来实现交易结构可以使系统增加新的交易类型。

使用命令模式的优点和缺点
命令允许请求的一方和接收请求的一方能够独立演化，从而且有以下的优点：

命令模式使新的命令很容易地被加入到系统里。
允许接收请求的一方决定是否要否决（Veto）请求。
能较容易地设计-个命令队列。
可以容易地实现对请求的Undo和Redo。
在需要的情况下，可以较容易地将命令记入日志。
命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。
命令类与其他任何别的类一样，可以修改和推广。
你可以把命令对象聚合在一起，合成为合成命令。比如宏命令便是合成命令的例子。合成命令是合成模式的应用。
由于加进新的具体命令类不影响其他的类，因此增加新的具体命令类很容易。
命令模式的缺点如下：

使用命令模式会导致某些系统有过多的具体命令类。某些系统可能需要几十个，几百个甚至几千个具体命令类，这会使命令模式在这样的系统里变得不实际

Command模式的几个要点：

1、  Command模式的根本目的在于将“行为请求者”与“行为实现者”解耦，在面向对象语言中，常见的实现手段是“将行为抽象为对象”。
2、  实现Command接口的具体命令对象ConcreteCommand 有时候根据需要可能会保存一些额外的状态信息。
3、  通过使用Composite模式，可以将多个“命名”封装为一个“复合命令”MacroCommand。
4、  Command模式与C#中的Delegate有些类似。但两者定义行为接口的规范有所区别：Command以面向对象中的“接口-实现”类定义行为接口规范，更严格，更符合抽象原则：Delegate以函数签名来定义行为接口规范，更灵活，但抽象能力比较弱

前往：设计模式学习笔记清单