命令（Command）模式

命令模式涉及到五个角色，它们分别是：

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

命令模式的示意性源代码:

 

//  Command pattern -- Structural example   
using  System; 
 
//  "Command" 
abstract   class  Command 
... { 
  // Fields 
  protected Receiver receiver; 
 
  // Constructors 
  public Command( Receiver receiver ) 
  ...{ 
    this.receiver = receiver; 
  } 
 
  // Methods 
  abstract public void Execute(); 
}  
 
//  "ConcreteCommand" 
class  ConcreteCommand : Command 
... { 
  // Constructors 
  public ConcreteCommand( Receiver receiver ) : 
    base ( receiver ) ...{} 
 
  // Methods 
  public override void Execute() 
  ...{ 
    receiver.Action(); 
  } 
}  
 
//  "Receiver" 
class  Receiver 
... { 
  // Methods 
  public void Action() 
  ...{ 
    Console.WriteLine("Called Receiver.Action()"); 
  } 
}  
 
//  "Invoker" 
class  Invoker 
... { 
  // Fields 
  private Command command; 
 
  // Methods 
  public void SetCommand( Command command ) 
  ...{ 
    this.command = command; 
  } 
 
  public void ExecuteCommand() 
  ...{ 
    command.Execute(); 
  } 
}  
 
/**/ /**/ /**/ /// <summary> 
///  Client test 
/// </summary> 
public   class  Client 
... { 
  public static void Main( string[] args ) 
  ...{ 
    // Create receiver, command, and invoker 
    Receiver r = new Receiver(); 
    Command c = new ConcreteCommand( r ); 
    Invoker i = new Invoker(); 
 
    // Set and execute command 
    i.SetCommand(c); 
    i.ExecuteCommand(); 
  } 
}  

 命令模式的实现

首先命令应当"重"一些还是"轻"一些。在不同的情况下，可以做不同的选择。如果把命令设计得"轻"，那么它只是提供了一个请求者和接收者之间的耦合而己，命令代表请求者实现请求。

相反，如果把命令设计的"重"，那么它就应当实现所有的细节，包括请求所代表的操作，而不再需要接收者了。当一个系统没有接收者时，就可以采用这种做法。

更常见的是处于最"轻"和最"重"的两个极端之间时情况。命令类动态地决定调用哪一个接收者类。

其次是否支持undo和redo。如果一个命令类提供一个方法，比如叫unExecute()，以恢复其操作的效果，那么命令类就可以支持undo和redo。具体命令类需要存储状态信息，包括：

1. 接收者对象实际上实施请求所代表的操作；
2. 对接收者对象所作的操作所需要的参数；
3. 接收者类的最初的状态。接收者必须提供适当的方法，使命令类可以通过调用这个方法，以便接收者类恢复原有状态。

如果只需要提供一层的undo和redo，那么系统只需要存储最后被执行的那个命令对象。如果需要支持多层的undo和redo，那么系统就需要存储曾经被执行过的命令的清单，清单能允许的最大的长度便是系统所支持的undo和redo的层数。沿着清单逆着执行清单上的命令的反命令（unExecute()）便是undo；沿着清单顺着执行清单上的命令便是redo。

命令模式的实际应用案例:

 

//  Command pattern -- Real World example   
using  System;
using  System.Collections;

//  "Command" 
abstract   class  Command
... {
    // Methods 
    abstract public void Execute();
    abstract public void UnExecute();
}

//  "ConcreteCommand" 
class  CalculatorCommand : Command
... {
    // Fields 
    char @operator;
    int operand;
    Calculator calculator;

    // Constructor 
    public CalculatorCommand(Calculator calculator,
      char @operator, int operand)
    ...{
        this.calculator = calculator;
        this.@operator = @operator;
        this.operand = operand;
    }

    // Properties 
    public char Operator
    ...{
        set ...{ @operator = value; }
    }

    public int Operand
    ...{
        set ...{ operand = value; }
    }

    // Methods 
    override public void Execute()
    ...{
        calculator.Operation(@operator, operand);
    }

    override public void UnExecute()
    ...{
        calculator.Operation(Undo(@operator), operand);
    }

    // Private helper function 
    private char Undo(char @operator)
    ...{
        char undo = ' ';
        switch (@operator)
        ...{
            case '+': undo = '-'; break;
            case '-': undo = '+'; break;
            case '*': undo = '/'; break;
            case '/': undo = '*'; break;
        }
        return undo;
    }
}

//  "Receiver" 
class  Calculator
... {
    // Fields 
    private int total = 0;

    // Methods 
    public void Operation(char @operator, int operand)
    ...{
        switch (@operator)
        ...{
            case '+': total += operand; break;
            case '-': total -= operand; break;
            case '*': total *= operand; break;
            case '/': total /= operand; break;
        }
        Console.WriteLine("Total = {0} (following {1} {2})",
          total, @operator, operand);
    }
}

//  "Invoker" 
class  User
... {
    // Fields 
    private Calculator calculator = new Calculator();
    private ArrayList commands = new ArrayList();
    private int current = 0;

    // Methods 
    public void Redo(int levels)
    ...{
        Console.WriteLine("---- Redo {0} levels ", levels);
        // Perform redo operations 
        for (int i = 0; i < levels; i++)
            if (current < commands.Count - 1)
                ((Command)commands[current++]).Execute();
    }

    public void Undo(int levels)
    ...{
        Console.WriteLine("---- Undo {0} levels ", levels);
        // Perform undo operations 
        for (int i = 0; i < levels; i++)
            if (current > 0)
                ((Command)commands[--current]).UnExecute();
    }

    public void Compute(char @operator, int operand)
    ...{
        // Create command operation and execute it 
        Command command = new CalculatorCommand(
          calculator, @operator, operand);
        command.Execute();

        // Add command to undo list 
        commands.Add(command);
        current++;
    }
}

/**/ /**/
/**/ /// <summary> 
/// CommandApp test 
/// </summary> 
public   class  Client
... {
    public static void Main(string[] args)
    ...{
        // Create user and let her compute 
        User user = new User();

        user.Compute('+', 100);
        user.Compute('-', 50);
        user.Compute('*', 10);
        user.Compute('/', 2);

        // Undo and then redo some commands 
        user.Undo(4);
        user.Redo(3);
    }
}

 

在什么情况下应当使用命令模式

在下面的情况下应当考虑使用命令模式：

1、使用命令模式作为"CallBack"在面向对象系统中的替代。"CallBack"讲的便是先将一个函数登记上，然后在以后调用此函数。

2、需要在不同的时间指定请求、将请求排队。一个命令对象和原先的请求发出者可以有不同的生命期。换言之，原先的请求发出者可能已经不在了，而命令对象本身仍然是活动的。这时命令的接收者可以是在本地，也可以在网络的另外一个地址。命令对象可以在串形化之后传送到另外一台机器上去。

3、系统需要支持命令的撤消(undo)。命令对象可以把状态存储起来，等到客户端需要撤销命令所产生的效果时，可以调用undo()方法，把命令所产生的效果撤销掉。命令对象还可以提供redo()方法，以供客户端在需要时，再重新实施命令效果。

4、如果一个系统要将系统中所有的数据更新到日志里，以便在系统崩溃时，可以根据日志里读回所有的数据更新命令，重新调用Execute()方法一条一条执行这些命令，从而恢复系统在崩溃前所做的数据更新。

5、一个系统需要支持交易(Transaction)。一个交易结构封装了一组数据更新命令。使用命令模式来实现交易结构可以使系统增加新的交易类型。

使用命令模式的优点和缺点

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

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

命令模式的缺点如下：

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