二.行为型——命令模式

0.DP

• 解决问题：为衔接应用程序和用户界面对象，当用户界面对象被触发时，应用程序向用户界面对象提供一个特定的Command对象，用户界面对象调用Command对象的execute方法执行。

  以一个图形编辑器为例：在一次图形编辑过程中，如果当前一个图形对象被选中时，用户界面上的Copy菜单被触发，则图形编辑应用程序应该包装一个Command对象给Copy菜单，其中包含对这个图形对象的Copy方法的调用。

• 优点：

  菜单不必知道命令的接收者是谁，也不必知道它怎样执行命令
  命令的接收者不必知道谁以怎样的方式请求这个命令的执行，可以是通过菜单，也可以是通过快捷键，或其它方式。

• 协作：

  Client创建一个ConcreteCommand对象并指定它的Receiver；
  Client把这个ConcreteCommand对象提供给一个Invoker；
  Invoker调用这个ConcreteCommand的Execute方法；
  在这个ConcreteCommand的Execute方法中对应的Receiver的一些操作被调用，完成实际的工作。

• 优点

  保持触发操作的对象和知道怎样实现这个操作的对象之间的松耦合。
  每个Command都是一般意义上的一个对象，可以把它看作普通对象进行各种处理（例如用队列或者栈对其进行管理）。
  可以把多个Command装配成一个复合Command，复合Command通常采用Composite模式组合各个Command。
  可以很方便地实例化Command，建立不同的命令。

1. 问题

• 烧烤摊很多人点烧烤，老板经常记错。问题出在：

  ​ 客户和烤羊肉串老板的’紧耦合"，所以使得容易出借，容易混乱，也容易挑剔。这其实就是’行为请求者’与’行为实现者’的紧耦合。

• 解决：

  做日志：需要记录哪个人要几串羊肉串，有没有特殊要求，付没付过钱，谁先谁后
  撤销和重做：可能有人需要退回请求，或者要求烤肉重烤

  客户只需要给服务员说我们要什么就可以了，他记录请求，然后再由他去通知烤肉师傅做。

  所有的客户都有订单，烤肉师傅可以按先后顺序操作，不会混乱，也不会遗忘了

2. 解决烤串问题的代码

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0bL8Ai6v-1642074826719)(C:\Users\49436\AppData\Roaming\Typora\typora-user-images\image-20211208181241224.png)]

• 烤肉串者：

  //烤肉串者
  public class Barbecuer
  {
      //烤羊肉
      public void BakeMutton()
      {
          Console .WriteLine ("烤羊肉串!");
      }
      //烤鸡翅
      public void BakeChickenWing()
      {
          Console.WriteLine ("烤鸡翅!");
      }
  }
  

• 命令类：

  具体命令是依赖烤肉串者类，因为是烤肉串者发出的命令。命令类是为了让客户端更方便让服务员执行一些重复的命令。

  抽象命令类：

  public abstract class Command
  {
      protected Barbecuer receiver;
      public Command(Barbecuer receiver)
      {
          this.receiver = receiver;        
      }
      //执行命令
      abstract public void ExcuteCommand();
  }
  

  具体命令类：

  //烤羊肉串命令
  class BakeMuttonCommand extends Command
  {
      //继承父类，有一个属性receiver
      @override
      public void ExcuteCommand()
      {
          receiver.BakeMutton();
      }
  }
  
  //烤鸡翅命令
  class BakeChickenWingCommand extends Command
  {
      public override void ExcuteCommand()
      {
          receiver.BakeChickenWing();    
      }
  }
  

• **服务员类：**客户端给服务员下达命令，服务员记录后让厨师执行

  public class Waiter
  {
      //订单记录
      private List<Command> orders = new List<Command>();
      
      // 在客户提出请求时，对没货的烧烤进行回绝
      public void SetOrder(Command command)
      {
          if command.ToString()=="命令模式.BakeChickenWingCommand"
          {
              Console.WriteLine("服务员∶鸡翅没有了，请点别的烧烤。");
          }
          //记录客户所点的烧烤的日志，以准备算账收钱
          else
          {
              orders.Add (command);
              Console.writeLine("增加订单∶"+ command+"时间∶"+DateTime.Now());  
          }
      }
  
      //取消订单
      public void CancelOrder(Command command)
      {
          orders.Remove (command);
          Console.WriteLine("取消订单∶"+ command.ToString()+" 时间∶"+DateTime.Now.ToString());
      }
      
      //通知全部执行
      public void Notify()
      {
          for(Command cmd : orders);
          cmd.ExcuteCommand();
      }
  }
  

• 客户端：

  static void Main(string[]] args)
  {
      //开店前的准备
      Barbecuer boy = new Barbecuer ();
      Command bakeMuttonCommandl = new BakeMuttonCommand(boy);
      Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
      Command bakeChickenWingCommandl = new BakeChickenWingCommand(boy);
      Waiter girl = new Waiter();
  
      //开门营业顾客点菜
      girl.SetOrder(bakeMuttonCommandl);
      girl.SetOrder(bakeMuttonCommand2);
      girl.SetOrder(bakeChickenWingCommandl);
  
      //点菜完毕，通知厨房 
      girl.Notify();	
  
      Console.Read() ;
  }
  

  执行结果:

  增加订单：命令模式.烤羊肉串 时间：200x-xx-xx xx:xx:xx

  增加订单：命令模式.烤羊肉串 时间：200x-xx-xx xx:xx:xx

  服务员：鸡翅没有了，清点别的烧烤。

  烤羊肉串！

  烤羊肉串！

3. 命令模式

• 命令模式（Command）：将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rSi5Epsr-1642074826720)(C:\Users\49436\AppData\Roaming\Typora\typora-user-images\image-20211208182402617.png)]

• Command类：用来声明执行操作的接口。

  abstract class Command
  {
      protected Receiver receiver;
      public Command(Receiver receiver)
      {
          this.receiver = receiver;
      }
      abstract public void Execute();
  }
  

• ConcreteCommand类：一个接收者对象和一个具体操作联系在一起，在execute方法中调用接收者相应的操作

  class ConcreteCommand extends Command
  {
      //继承父类，有个receiver属性
      @override
      public void Execute()
      {
          receiver.Action();        
      }
  }
  

• Invoker类：负责发出请求，记录和控制命令执行。

  class Invoker
  {
      private List<Command> commandlist=new List();
      
      public void SetCommand(Command command)
      {
          commandList.add(command);
      }
  
      public void DeleteCommand(Command command)
      {
          commandList.remove(command);
      }
  
      public void Executecommand()
      {
          for(Command c:commandList)
          {
              command.Execute();    
          }
      }
  }
  

• Receiver类：知道如何实施与执行一个与请求相关的操作。

  class Receiver
  {
      public void Action()
      {
          Console.WriteLine ("执行xx请求！");
      }
  }
  

• 客户端代码：创建Invoker，创建具体命令对象并设定它的接收者。

  static void Main(string[] args)
  {
      Receiver r = new Receiver();
      Command c = new ConcreteCommand(r);
      Invoker i = new Invoker();
      i.SetCommand(c); 
      i.Executecommand();
      Console.Read();
  }
  

4. 作用

• 作用：

  1. 第一，它能较容易地设计一个命令队列
  2. 第二，在需要的情况下，可以较容易地将命令记入日志；
  3. 第三，允许接收请求的一方决定是否要否决请求
  4. 可以容易地实现对请求的撤销和重做
  5. 第五，由于加进新的具体命令类不影响其他的类，因此増加新的具体命令类很容易。
  6. 最关键的优点：命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开

• 什么时候不用命令模式呢？
  　 命令模式支持撤销/恢复操作功能，但还不清楚是否需要这个功能时，不要实现命令模式：
  　敏捷开发原则告诉我们，不要为代码添加基于猜测的、实际不需要的功能。事实上，在需要的时候通过重构实现这个模式并不困难，只有在真正需要如撤销/恢复操作等功能时，把原来的代码重构为命令模式才有意义。