设计模式（六）（Command Pattern)命令模式

定义
- 将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。
- 结构图：
命令模式的角色划分：
- Reciever(命令的接收者):接收命令，并知道如何进行必要的工作，实现具体的处理。任何类都可以当接收者。
- Invoker（命令调用者）:命令调用者持有一个命令对象，并在某个时间点调用命令对象的Execute()方法，将请求付诸实行。
- Command（命令接口）:Command为所有命令声明了一个接口。调用命令对象的Execute()方法，就可以让接收者进行相应的动作。这个接口也具备一个UnDo()方法，为了回滚动作使用，也可以不定义该方法。
- ConcreteCommand（命令）:ConcreateCommand定义了动作与接收者之间的绑定关系。调用者Execute()就可以发出请求，然后由ConcreateCommand调用就接收者的一个或者多个动作。

应用示例：

我们知道灯可以开、关，如果我们用程序去演示等的开关可以这么写：

 1 public class Program
 2 {
 3     public static void Main(string[] args)
 4     {
 5     Light light=new Light("light0001");
 6     // light turn on.
 7     light.On();
 8     // light turn off.
 9     light.Off();
10     }
11 }
12 
13 public class Light
14 {
15     public string Name { get; set; }
16 
17     public Light(string name)
18     {
19         this.Name = name;
20     }
21 
22     /// <summary>
23     /// Turn on the light
24     /// </summary>
25     public void On()
26     {
27         Console.WriteLine("light:{0} is turn on.", this.Name);
28     }
29 
30     /// <summary>
31     /// Turn off the light
32     /// </summary>
33     public void Off()
34     {
35         Console.WriteLine("light:{0} is turn off.", this.Name);
36     }
37 }

上边的示例把灯的开、关动作调用都直接写在了Main的代码块中。但针对该例子这样写似乎没有看出有什么不妥的，但是如果是FTP的服务端接收命令解析时，我们把接收到的100左右个命令,分别定义出对应的函数到一个类中，这时就会发现这样做耦合度太高了，维护起来就不像单独On(),Off()两个动作这么轻松。
试想，如果把FTP服务器端，接收到的命令拆分成不同的“命令”，有单一的“命令调用者”，这样会不会把结构划分的更清晰？
备注：FTP向服务端请求命令：LS、DIR、MLS、MDIR、MKDIR、RMDIR
LS有点像UNIX下的LS(LIST）命令：

DIR相当于LS-L(LIST-LONG）；

MLS只是将远端某目录下的文件存于LOCAL端的某文件里；

MDIR相当于MLS；

MKDIR像DOS下的MD（创建子目录）一样：

RMDIR像DOS下的RD（删除子目录）一样。

下边我们将上边的例子Light按照Command设计模式来改写，看下效果：

命令接口:Command

1 public interface ICommand
2 {
3 
4     void Execute();
5 
6 }

命令的接收者:Reciever

 1 public class Light
 2 {
 3     public string Name { get; set; }
 4 
 5     public Light(string name)
 6     {
 7         this.Name = name;
 8     }
 9 
10     /// <summary>
11     /// Turn on the light
12     /// </summary>
13     public void On()
14     {
15         Console.WriteLine("light:{0} is turn on.", this.Name);
16     }
17 
18     /// <summary>
19     /// Turn off the light
20     /// </summary>
21     public void Off()
22     {
23         Console.WriteLine("light:{0} is turn off.", this.Name);
24     }
25 }

命令的封装者：ConcreateCommand

 1 public class LightOnCommand : ICommand
 2 {
 3     private Light light;
 4 
 5     public LightOnCommand(Light light)
 6     {
 7         this.light = light;
 8     }
 9 
10     public void Execute()
11     {
12         this.light.On();
13     }
14 }

命令的封装者：ConcreateCommand

 1 public class LightOffCommand : ICommand
 2 {
 3     private Light light;
 4 
 5     public LightOffCommand(Light light)
 6     {
 7         this.light = light;
 8     }
 9 
10     public void Execute()
11     {
12         this.light.Off();
13     }
14 }

命令的封装者：命令的Invoker

 1 public class CommandControl
 2 {
 3     private ICommand command;
 4 
 5     public CommandControl() { }
 6 
 7     public void SetCommand(ICommand command)
 8     {
 9         this.command = command;
10     }
11 
12     public void ButtonPresssed()
13     {
14         this.command.Execute();
15     }
16 }

客户端：client

 1 class Program
 2 {
 3     static void Main(string[] args)
 4     {
 5         CommandControl control = new CommandControl();
 6         Light light = new Light("light_001");
 7         LightOnCommand lightOn = new LightOnCommand(light);
 8         LightOffCommand lightOff = new LightOffCommand(light);
 9 
10         control.SetCommand(lightOn);
11         control.ButtonPresssed();
12 
13         control.SetCommand(lightOff);
14         control.ButtonPresssed();
15 
16         control.SetCommand(lightOn);
17         control.ButtonPresssed();
18 
19         control.SetCommand(lightOff);
20         control.ButtonPresssed();
21 
22         Console.ReadKey();
23     }
24 }

开发中用到：
- 　　　　
- 怎么调用：
  - 　　
- Command:
  - 　　
- Reciever:
  - 　　
应用场景：
- 多级UnDo操作的应用场景；
  - 　　如何实现多层撤销操作？
  - 　　首先，不要只是记录最后一个被执行的命令，而使用一个堆栈记录操作过程的每一个命令。
  - 　　然后，不管什么时候操作了什么，都可以从堆栈中取出最上层的命令，然后调用它的UnDo()方法。
- 　命令可以将运算块打包（一个接收者和一组动作），让后将它传来传去，就像是一般的对象一样。现在，即使在命令对象被创建许久之后，运算依然可以被调用。事实上，它甚至可以在不同的线程中被调用。我们可以衍生一些应用，例如：日程安排（Scheduler）、线程池、工作队列等。
- 日志请求：某些应用需要我们将所有的动作都记录在日志中，并能在系统死机之后，重新调用这些动作恢复到之前的状态。通过两个方法 Store(),Load()，命令模式就能够支持这一点。
总结&优缺点：
- 命令模式的实际应用还是挺广泛的，在FTP服务器端Socket接收到客户端命令请求，每个命令都需要做出对应的操作，为了业务的明细化，我们习惯上把这样的请求参数化，例如：SupperSocket.FTP中就是一个很好的命令模式的应用。
- 优点：把‘请求’作为参数传递，将调用、参数、动作分开，解耦，业务更加清晰，代码逻辑更加明晰化，职责也更单一；
- 缺点：子类划分的更多了，没出现一个新的请求，都需要new更多的类。