命令模式

命令模式

解决命令扩展和可撤销等典型问题。

用不同的遥控器，控制电视。

这个业务逻辑复杂吗？

把声音和频道的改变都写在电视上。

遥控器委托到命令，去执行改变电视的状态。

两句话就可以概括的简单逻辑。

遥控器和电机机之间没有依赖关系。

http://www.cnblogs.com/luxiaofeng54/archive/2013/04/08/3008672.html

 

 

命令模式适应于事务和可撤销命令的应用：

解决命令的接受者和命令的发起者之间的耦合关系。
如，一个接受对象封装了对数据库的所有操作，保存增加、删除、修改、更新等。
可以从发起者直接调用该对象。但是当发起者没有所有操作权限的时候，可以用命令模式，封装有权限的几个命令，来实现该功能。
首先接受者对象实现如下：

 interface IReceiver
    {
        void Add();
        void Delete();
        void Clear();
    }

    class StactReceiver:IReceiver
    {
        Stack<char> chars = new Stack<char>();

        public void Add()
        {
            Random r = new Random();
            chars.Push((char)r.Next(61, 97));
        }

        public void Delete()
        {
            chars.Pop();
        }

        public void Clear()
        {
            chars.Clear();
        }

    }

　　

 然后封装一个Add命令和一个clear命令。

  interface ICommand
    {
        void Do();
        void UnDo();
    }

    class AddCommand:ICommand
    {
        IReceiver receiver;

        public AddCommand(IReceiver receiver)
        {
            this.receiver = receiver;
        }

        public void Do()
        {
            receiver.Add();
        }

        public void UnDo()
        {
            receiver.Delete();
        }
    }

    class ClearCommand:ICommand
    {
        IReceiver receiver;

        public ClearCommand(IReceiver receiver)
        {
            this.receiver = receiver;
        }

        public void Do()
        {
            receiver.Clear();
        }

        public void UnDo()
        {
            
        }
    }

　　最后，Invoke在一个事务中执行命令。实现所有命令执行的完整性。

class Invoke
    {
        Stack<ICommand> commands = new Stack<ICommand>();

        public void AddCommand(ICommand cmd)
        {
            commands.Push(cmd);
        }

        public void Execute()
        {
            using (TransactionScope tran=new TransactionScope())
            {
                foreach (var item in commands)
                {
                    item.Do();
                }
            }
        }

        public void UnExecute()
        {
            using (TransactionScope tran=new TransactionScope())
            {
                foreach (var item in commands)
                {
                    item.UnDo();
                }
            }
        }
    }

　　客户端：

 class CommandClient
	{
		public void Run()
        {
            IReceiver receiver=new StactReceiver();
            ICommand addCommand=new AddCommand(receiver);
            ICommand addCommand2=new AddCommand(receiver);
            ICommand clearComand=new ClearCommand(receiver);

            Invoke invoke=new Invoke();
            invoke.AddCommand(clearComand);
            invoke.AddCommand(addCommand);
            invoke.AddCommand(addCommand2);

            invoke.Execute();

        }
	}