命令设计模式

该设计模式的目的是对命令的请求者和实现接收者的解耦。

在下面的代码中对命令中接收者实现了两种注入：一种是构造函数参数注入；另一种是直接在内部生成一个接收者对象。具体代码如下：

    public class Receiver
    {
        public void DoSomething1()
        {

        }
        public void DoSomething2()
        {

        }
    }

    public interface Icommand
    {
        void Excute();
    }
    public class ConcrateCommand1 : Icommand
    {
        private Receiver receiver;
        public ConcrateCommand1()
        {
            receiver = new Receiver();
        }
        public ConcrateCommand1(Receiver preceiver)
        {
            receiver = preceiver;
        }
        public void Excute()
        {
            this.receiver.DoSomething1();
        }
    }
    public class ConcrateCommand2 : Icommand
    {
        private Receiver receiver;
        public ConcrateCommand2()
        {
            receiver = new Receiver();
        }
        public ConcrateCommand2(Receiver preceiver)
        {
            receiver = preceiver;
        }
        public void Excute()
        {
            this.receiver.DoSomething2();
        }
    }

    public class Invoke
    {
        public Icommand command { get; set; }
        public void GetSomething1()
        {
            command.Excute();
        }
        public void GetSomething2()
        {
            command.Excute();
        }
    }
    public class Test
    {
        public static void Main(string[] args)
        {
            Receiver receiver = new Receiver();
            Icommand command = new ConcrateCommand1(receiver);
            //Icommand command = new ConcrateCommand1();
            Invoke invoke = new Invoke();
            invoke.command = command;
            invoke.GetSomething1();

            command = new ConcrateCommand2(receiver);
            invoke.command = command;
            invoke.GetSomething2();

        }
    }

可能有人会说如果请求者直接调用接收实现者的类，不是更简单么？方法如下：

    public class Invoke
    {
        public Receiver receiver { get; set; }
        public void GetSomething1()
        {
            receiver.DoSomething1();
        }
        public void GetSomething2()
        {
            receiver.DoSomething2();
        }
    }

其实这个设计模式是有个大前提：

1：它的根本目的在于将“行为请求者”与“行为实现者”解耦。使用这样的一个中间层也是我们经常使用的手法，即把A对B的依赖转换为A对C的依赖

2：同时某些场合，比如要对行为进行“记录、撤销/重做、事务”等处理，如果还是客户端直接调用实现者，会导致客户端产生大量处理实现者的逻辑代码，这种无法抵御变化的紧耦合是不合适的。所以把函数层面的功能提到了类的层面，有点功能分解的味道。