编程模式之15---行为型----命令模式

定义

将一个请求封装成一个对象,让你可以用不同的请求对客户端进行参数化,对请求排队,纪录请求日志和支持可撤消操作.

有三个具体成员,请求的发送者,请求的接收者,还有就是请求本身(或者是命令).对客户端进行参数化,也就是客户端可以把请求对象当成一个参数,直接注入到请求发送者内部,不用管请求接收者;对请求排队,如果一个请求发送者发送了一个请求,有多个接收者会处理这个请求的话,那么就需要对命令排队,命令对象和请求接收者是一一对应的;纪录请求日志,当发出一个请求时,由命令对象来保存一些信息,证明本对象被使用了,也可以说是本命令被处理了;支持可撤消操作,比如一个加法命令,命令对象纪录下加数,通过减去这个加数就实现了一次撤消,通过再加上这个加数就实现了一次恢复.

结构组成

从定义中,可以看出,一次完整的命令(请求)处理需要有三种类型成员参与.

抽象命令类(Command):声明了执行请求的方法Execute,方法中调用请求接收者的处理方法.

具体命令类(ConcreteCommand):实现方法Execute,每个具体命令类对应一个请求处理者.

调用者(Invoke):发送命令者,维护一个命令对象的引用.调用命令类的Execute方法.

接收者(Receiver):定义了用于处理请求的业务方法.最终的处理还是在业务方法中.

示例

 　　

using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Reflection;

namespace 命令模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Configuration cfa = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
            string comm = cfa.AppSettings.Settings["commandfan"].Value;//这是得到风扇命令类
            Assembly assembly = Assembly.GetEntryAssembly();
            Command command =(Command) assembly.CreateInstance(comm);
            ButtonStart bs = new ButtonStart(command);//注入到调用者中
            bs.Start();//调用者执行调用,直接调用的是命令类对象的方法，实质最终的响应还是接收者完成
            Console.Read();
        }
    }
    class ButtonStart
    {
        private Command com = null;
        public ButtonStart(Command com)
        {
            this.com = com;
        }
        public void Start()
        {
            com.Execute();//执行命令类的方法
        }
    }
    abstract class Command
    {
        public abstract void Execute();
    }
    class FanCommand : Command//风扇命令类
    {
        private Fan fan = null;
        public FanCommand()
        {
            fan = new Fan();
        }
        public override void Execute()
        {
            fan.StartUP();
        }
    }
    class BulbCommand : Command
    {
        private Bulb bulb= null;
        public BulbCommand()
        {
            bulb = new Bulb();//调用命令接收者的业务方法
        }
        public override void Execute()
        {
            bulb.Light();//调用命令接收者的业务方法
        }
    }
    class Fan//风扇类，命令接收者
    {
        public void StartUP()
        {
            Console.WriteLine("风扇启动");
        }
    }
    class Bulb//灯泡类，命令接收者
    {
        public void Light()
        {
            Console.WriteLine("发光");
        }
    }
}

　　感觉实际上还是按一条链那样调用的样子。看不出太多的优势。

命令队列，纪录日志，撤消操作

 　　命令队列适用的情况：当一个请求发出后，会有多个请求接收者响应，也就是有多个命令对象来“中间处理”；在命令发送者类中，维护一个命令列表，当请求发出时，依次调用命令队列中命令对象的方法。示例如下：

　　

    class ButtonStart
    {
        private Command com = null;
        public List<Command> lstComm = new List<Command>();//维护命令队列
        public void StartAll()//启动所有命令
        {
            foreach (Command com in lstComm)
            {
                com.Execute();
            }
        }
        public ButtonStart()
        {
        }
        public ButtonStart(Command com)
        {
            this.com = com;
        }
        public void Start()
        {
            com.Execute();//执行命令类的方法
        }
    }



//客户端调用情况
            //命令队列
            ButtonStart bsque = new ButtonStart();
            bsque.lstComm.Add(new FanCommand());
            bsque.lstComm.Add(new BulbCommand());
            bsque.StartAll();

/*
在调用时，发送者类中的一次调用，就让所有命令对象来响应了，最终反映到所有接收者的响应中。
这次调用，也体现到了多态的作用。
*/

　　还可以把对多个命令的组织放到一个独立的对象中，对象对应的类结构大概如下：

    class QueueCommand
    {
        private List<Command> lstComm = new List<Command>();
        public void Add(Command com)//添加成员
        {
            lstComm.Add(com);
        }
        public void Execute()//执行此方法，循环调用多个命令对象的方法
        {
            foreach (Command com in lstComm)
            {
                com.Execute();
            }
        }
    }

　　纪录日志：

　　当一个命令执行前，把这个操作纪录下来。方法是在某个命令对象执行Excute方法时，在调用对应的接收者的业务方法前，把一些有纪录意义的文本保存到“日志文件”中。

    class BulbCommand : Command
    {
        public string blog = "发光日志";
        private Bulb bulb= null;
        public BulbCommand()
        {
            bulb = new Bulb();//调用命令接收者的业务方法
        }
        public override void Execute()
        {
            Console.WriteLine("模拟灯泡被开启日志"+blog);
            bulb.Light();//调用命令接收者的业务方法
        }
    }

　　结合序列化等，把对象序列化到硬盘上。

　　可撤消操作：

　　当一个命令对象执行Excute方法后，可以再调用一个与之相反的操作的方法就实现了撤消。比如加一个数后，保存此加数，让被加数送去加数，就实现一回撤消；如果实现多回撤消的话，把多次使用的加数保存到一个队列中，通过索引来得到某个加数，再用被减数减去它。

    class Command
    {
        public abstract int Execute(int x);
        public abstract int UnDo(int x);
    }
    class AddCommand : Command
    {
        private int value = 100;//传入的值和value相加操作
        public override int Execute(int x)
        {
            return x + value;
        }
        public override int UnDo(int x)
        {
            return x - value;
        }
    }

 

什么时候可以用

 　　系统需要把请求发送者和接收者解耦；系统需要撤消操作、或者把请求处理排队。