设计模式之七 命令模式（Command Pattern）

概述

客户端只是想要发出命令或者请求，不关心请求的真正接收者是谁，也不关心具体如何实现，而且同一个请求的动作可以有不同的请求内容，当然具体的处理功能也不一样，请问该怎么实现？下面我们来学习命令模式

目的

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

结构图

详细解析

Command：
定义命令的接口，声明执行的方法。
ConcreteCommand：
命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。
Receiver：
接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。
Invoker：
要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。
Client：
创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在组装命令对象和接收者，或许，把这个Client称为装配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。

对应代码

class Program
    {
        static void Main(string[] args)
        {
            Receiver r = new Receiver();
            Command c = new ConcreteCommand(r);
            Invoker i = new Invoker();

            // Set and execute command 
            i.SetCommand(c);
            i.ExecuteCommand();

            Console.Read();

        }
    }
    //用来声明执行操作的接口
    abstract class Command
    {
        protected Receiver receiver;

        public Command(Receiver receiver)
        {
            this.receiver = receiver;
        }

        abstract public void Execute();
    }
    //ConcreteCommand类，将一个接收者对象绑定于一个操作，调用接收者相应的操作，以实现Execute

    class ConcreteCommand : Command
    {
        public ConcreteCommand(Receiver receiver)
            :
          base(receiver) { }

        public override void Execute()
        {
            receiver.Action();
        }
    }
    //知道如何实施与执行一个与请求相关的操作，任何类都可能作为一个接收者
    class Receiver
    {
        public void Action()
        {
            Console.WriteLine("执行请求！");
        }
    }
    //要该命令执行这个请求
    class Invoker
    {
        private Command command;

        public void SetCommand(Command command)
        {
            this.command = command;
        }

        public void ExecuteCommand()
        {
            command.Execute();
        }
    }

生活中得例子

Command模式将一个请求封装为一个对象，从而使不同的请求对客户进行参数化，用餐时的账单是Command模式的一个例子，服务员接受顾客的点单，把它记在账单上封装，这个点单被排队等待做，账单不依赖菜单的，它可以被不同的顾客使用，也可以添加入不同的点单项目。

Command模式实例剖析

Command模式它封装的是命令，把命令的发出者的责任和命令执行者的责任分开，我们知道，一个类是一组操作和相应变量的结合，在订餐的过程中有如下一个类Waiter

//服务员
    public class Waiter
    {
        private IList<Command> orders = new List<Command>();

        //设置订单
        public void SetOrder(Command command)
        {
            if (command.ToString() == "命令模式.BakeChickenWingCommand")
            {
                Console.WriteLine("服务员：鸡翅没有了，请点别的烧烤。");
            }
            else
            {
                orders.Add(command);
                Console.WriteLine("增加订单：" + command.ToString() + "  时间：" + DateTime.Now.ToString());
            }
        }

        //取消订单
        public void CancelOrder(Command command)
        {
            orders.Remove(command);
            Console.WriteLine("取消订单：" + command.ToString() + "  时间：" + DateTime.Now.ToString());
        }

        //通知全部执行
        public void Notify()
        {
            foreach (Command cmd in orders)
            {
                cmd.ExcuteCommand();
            }
        }
    }

下面我们得抽象一个抽象的命令，Setorder、CancelOrder、等方法都是Command所具有的，如果单独出来一个命令对象，那就把函数层面的功能提到了类的层面，对命令的抽象是很重要之处。，其他具体的方法命令类都继承于该抽象类。

//抽象命令
    public abstract class Command
    {
        protected Barbecuer receiver;

        public Command(Barbecuer receiver)
        {
            this.receiver = receiver;
        }

        //执行命令
        abstract public void ExcuteCommand();
    }

    //烤羊肉串命令
    class BakeMuttonCommand : Command
    {
        public BakeMuttonCommand(Barbecuer receiver)
            : base(receiver)
        { }

        public override void ExcuteCommand()
        {
            receiver.BakeMutton();
        }
    }

    //烤鸡翅命令
    class BakeChickenWingCommand : Command
    {
        public BakeChickenWingCommand(Barbecuer receiver)
            : base(receiver)
        { }

        public override void ExcuteCommand()
        {
            receiver.BakeChickenWing();
        }
    }

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

        public void BakeChickenWing()
        {
            Console.WriteLine("烤鸡翅!");
        }
    }

客户端的调用

 static void Main(string[] args)
        {
            //开店前的准备
            Barbecuer boy = new Barbecuer();
            Command bakeMuttonCommand1 = new BakeMuttonCommand(boy);
            Command bakeMuttonCommand2 = new BakeMuttonCommand(boy);
            Command bakeChickenWingCommand1 = new BakeChickenWingCommand(boy);
            Waiter girl = new Waiter();

            //开门营业 顾客点菜
            girl.SetOrder(bakeMuttonCommand1);
            girl.SetOrder(bakeMuttonCommand2);
            girl.SetOrder(bakeChickenWingCommand1);

            //点菜完闭，通知厨房
            girl.Notify();

            Console.Read();

        }

在客户端的程序中，不依赖于Waiter的SetOrder、CancelOrder、Notify、修改订单等命令，通过Command对这些命令进行了封装，使得它的一个关键抽象类是Command类，它定义了一个操作的接口，同时我们可以看到，这三个命令是方法而已，但是通过Command模式把它们提到了类的层面，虽然违背了面向对象的原则，但它解决了分离命令的请求者和命令的执行者的问题。

Command命令的时机

1：需要在不同的时间指定请求、将请求排队。

2：系统需要支持命令的撤销。

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

命令模式的作用

1：它很容易的设计一个命令队列

2：在需要的情况下，可以教容易的将命令计入日志

3：允许接收请求的一方决定是否要否决请求

4：可以很容易的实现对请求的撤销和重做

5:由于加紧新的具体命令类不影响其它的类，因此增加新的具体命令类很容易，命令模式把请求的一个操作的对象与知道怎么执行一个操作的对象分隔开。

总结

Command模式轻松的实现了“行为请求者”与“行为实现者”的解耦。