命令模式

1.命令模式：在类A中存在对象B，并且在A的方法中调用B的方法。这是一种强耦合关系。为了解耦，插入一个中间层类C。

　　　　　　就像Soa一样，web调用wcf A，如果把wcf A注册到另外一个wcf B中，web通过访问wcf B来访问wcf A。

　　　　　　相当于把被调用的方法映射为一个command对象。

常规调用：

    class Program
    {
        static void Main(string[] args)
        {
            Receiver receiver = new Receiver();
            Invoke invoke = new Invoke(receiver);
            invoke.InvokeCommand();
            Console.Read();
        }
    }

    /// <summary>
    /// 接受命令者
    /// </summary>
    public class Receiver
    {
        public void Run100Meter()
        {
            Console.WriteLine("run 100 meter");
        }
    }

    /// <summary>
    /// 发送命令者
    /// </summary>
    public class Invoke
    {
        private Receiver _receiver;
        public Invoke(Receiver receiver)
        {
            this._receiver = receiver;
        }

        /// <summary>
        /// 发送命令
        /// </summary>
        public void InvokeCommand()
        {
            _receiver.Run100Meter();
        }
    }

2.命令模式：

    class Program
    {
        static void Main(string[] args)
        {
            Receiver receiver = new Receiver();
            Command command = new CommandImp(receiver);
            Invoke invoke = new Invoke(command);
            invoke.ExcuteCommand();
            Console.Read();
        }
    }

    public class Receiver
    {
        public void Run100Meter()
        {
            Console.WriteLine("Run 100 Meter");
        }
    }

    public abstract class Command
    {
        protected Receiver _receiver;

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

        public abstract void Action();
    }

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

        public override void Action()
        {
            _receiver.Run100Meter();
        }
    }

    public class Invoke
    {
        private Command _command;

        public Invoke(Command command)
        {
            this._command = command;
        }

        public void ExcuteCommand()
        {
            _command.Action();
        }
    }

优点：

　　1.可知命令模式很容易添加到系统中，因为只需要一个调用方和被调用方，当然，如果被调用方很多的话，可以实现多个命令。

　　2.因为命令是抽象实现的，可以把命令对象聚合在一起，合成为合成命令。合成命令式合成模式的应用。（此处不懂）

缺点：

　　1.合成模式如果没有对应的场合，不要滥用。

　　2.如果被调用方有多个需要被调用的命令方法A，B,就需要有两个CommandImp，分别调用A和B，方法越多，关系会混乱。

　　　太多具体的命令实现类就会显得不符合实际。

场景：

　　命令需要撤销。（感觉可以用委托）