命令模式（Command Pattern）

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

 

/// <summary>
    /// Command类：抽象命令类，类中只需要确定命令最终执行者Receiver即可
    /// 声明执行操作的接口
    /// </summary>
    abstract class Command
    {
        protected Receiver reciever;

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

        abstract public void Execute();
    }

    /// <summary>
    /// ConcreteCommand类：将一个接受者对象绑定与一个动作，调用接受者Reciever相应的操作
    /// </summary>
    class ConcreteCommand : Command
    {
        public ConcreteCommand(Receiver reciever)
            : base(reciever)
        {
        }

        public override void Execute()
        {
            reciever.Action();
        }
    }

    /// <summary>
    /// Invoker类：要求该命令执行这个请求
    /// 不管用户想要什么，反正都是“命令”，只需要记录命令，然后通知接受者Reciever执行即可
    /// </summary>
    class Invoker
    {
        private Command command;

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

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

    /// <summary>
    /// Reciever类：命令最终执行者
    /// 知道如何实施与执行一个请求（命令）相关的操作，任何类都可能作为一个接受者
    /// </summary>
    class Receiver
    {
        public void Action()
        {
            Console.WriteLine("执行命令！");
        }
    }

    /// <summary>
    /// 客户端调用
    /// </summary>
    class Program
    {
        static void Main()
        {
            Receiver receiver = new Receiver();
            Command c = new ConcreteCommand(receiver);
            Invoker i = new Invoker();
            i.SetCommand(c);
            i.ExecuteCommand();
        }
    }

动机：
在软件系统中，“行为请求者”与“行为实现者”通常呈现一种“紧耦合”。
但在某些场合，比如要对行为进行“记录、撤销/重做、事务”等处理，这种无法抵御变化的紧耦合是不合适的。
在这种情况下，如何将“行为请求者”与“行为实现者”解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。

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

实例：餐馆点餐

客户点餐，发起命令请求，由服务员记录命令请求，最后传送给厨师，在整个过程中，客户（行为请求者）和厨师（行为实现者）
之间没有必然的联系，而是通过服务员达到了二者的松耦合。

 

/// <summary>
    /// Reciever类：接受者类，最终命令请求的执行者
    /// 烤肉串者
    /// </summary>
    public class Barbecuer
    {
        public void BakeMutton()
        {
            Console.WriteLine("烤羊肉串！");
        }

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

    /// <summary>
    /// Command类：抽象命令类
    /// 在此只需要知道‘烤肉串者’是谁，以及声明执行命令的接口
    /// </summary>
    public abstract class Command
    {
        protected Barbecuer receiver;
        public Command(Barbecuer receiver)
        {
            this.receiver = receiver;
        }

        public abstract void ExecuteCommand();
    }

    /// <summary>
    /// 具体的命令类
    /// 烤羊肉串类
    /// </summary>
    class BakeMuttonCommand : Command
    {
        public BakeMuttonCommand(Barbecuer receiver)
            : base(receiver)
        {

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

    /// <summary>
    /// 具体的命令类
    /// 烤鸡翅类
    /// </summary>
    class BakeChickenWingCommand : Command
    {
        public BakeChickenWingCommand(Barbecuer reveiver)
            : base(reveiver)
        {

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

    /// <summary>
    /// Invoker类：要求该命令执行这个请求
    /// 不管用户想要什么，反正都是“命令”，只需要记录命令，然后通知接受者Reciever执行即可
    /// 服务员类
    /// </summary>
    public class Waiter
    {
        /// <summary>
        /// 定义存放具体命令的容器
        /// </summary>
        private IList<Command> orders = new List<Command>();

        /// <summary>
        /// 设置订单
        /// </summary>
        /// <param name="c"></param>
        public void SetCommand(Command c)
        {
            //记录客户请求
            orders.Add(c);
            Console.WriteLine("增加订单：" + c.ToString() + " 时间:" + DateTime.Now.ToString());
        }

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

        /// <summary>
        /// 客户请求完毕，通知接受者Receiver执行请求
        /// </summary>
        public void Notify()
        {
            foreach (Command c in orders)
            {
                c.ExecuteCommand();
            }
        }
    }

    public class Program
    {
        public static void Main()
        {
            Barbecuer boy = new Barbecuer();
            Command c1 = new BakeMuttonCommand(boy);
            Command c2 = new BakeMuttonCommand(boy);
            Command c3 = new BakeChickenWingCommand(boy);

            Waiter girl = new Waiter();

            girl.SetCommand(c1);
            girl.SetCommand(c2);
            girl.SetCommand(c3);

            girl.CancelCommand(c1);
            girl.Notify();
        }
    }