C#设计模式之11:命令模式

C#设计模式之11:命令模式

命令模式

命令模式用来解决一些复杂业务逻辑的时候会很有用,比如,你的一个方法中到处充斥着if else 这种结构的时候,用命令模式来解决这种问题就会让事情变得简单很多。

命令模式是封装的一个全新的境界:把方法调用封装起来。通过封装方法调用,可以把运算快封装成形,所以调用此运算对象不需要知道事情是如何进行的。通过封装方法调用,可以实现一些很聪明的事,比如日志记录,比如重复使用这些封装来实现撤销(undo)。

命令模式可将“动作的请求者”从“动作的执行者对象中解耦。

定义:命令模式将”请求“封装成对象,以便使用不同的请求,队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

下面是命令模式的UML定义:

Command:定义命令的接口,声明执行的方法。

ConcreteCommand:命令接口实现对象,是“虚”的实现;通常会持有接收者,并调用接收者的功能来完成命令要执行的操作。
Receiver:接收者,真正执行命令的对象。任何类都可能成为一个接收者,只要它能够实现命令要求实现的相应功能。
Invoker:要求命令对象执行请求,通常会持有命令对象,可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方,也就是说相当于使用命令对象的入口。
Client:创建具体的命令对象,并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端,而是在组装命令对象和接收者,或许,把这个Client称为装配者会更好理解,因为真正使用命令的客户端是从Invoker来触发执行。

命令对象通过在特定的接收者上绑定一组动作来封装一个请求,要达到这一点,命令对象将动作和接收者抱紧对象中。这个对象只暴露出一个execute()方法,当此方法被调用的时候,接收者就会进行这些动作。从外面来看,其他对象不知道究竟那个接收者进行了那些动作,只知道如果调用execute()方法,请求的目的就能达到。

实现命令模式

背景:假设某个公司需要设计一个多用功能的遥控器。基本的需求如下:

该遥控器有可以控制风扇,白炽灯,热水器等等的多对开关,而且可能还有其他的电器,暂时不做其功能,但是希望可以保留接口,用的时间可以方便的扩展。

除上面的需求之外,还需要有个按钮,可以撤销上一步的操作。基本功能如下图:

 

设计遥控器

 public class RemoteControl
    {
        private readonly ICommand[] _onCommands;
        private readonly ICommand[] _offCommands;

        public RemoteControl()
        {
            _onCommands = new ICommand[7];//因为遥控器上面只有7个插槽(插槽对应Command)
            _offCommands = new ICommand[7];//因为遥控器上面只有7个插槽(插槽对应Command)
            var noCommand = new NoCommand();
            for (int index = 0; index < 7; index++)
            {
                _onCommands[index] = noCommand;
            }
        }

        public void SetCommand(int index, ICommand onCommand, ICommand offCommand)
        {
            _onCommands[index] = onCommand;
            _offCommands[index] = offCommand;
        }

        public void OnButtonWasPushed(int index)
        {
            _onCommands[index].Execute();
        }

        public void OffButtonWasPushed(int index)
        {
            _offCommands[index].Execute();
        }
    }

设计命令

上面我们初始化RemoteControl的时候用到了一个nocommand,这个命令什么都不做,我们只是将遥控器上面的插槽都初始化成一个空命令,这个空命令格式如下:

 public class NoCommand : ICommand
    {
        public void Execute()
        {
            Console.WriteLine("No command was executed!");
        }
    }

NoCommand对象是一个空对象,当你不想返回一个有意义的对象时,空对象就很有用。客户也可以将处理null的责任交给空对象,举例来说,遥控器不可能一出场就设置了有意义的命令对象,所以提供了NoCommand对象作为代用品。当调用它的execute()方法时,这种对象什么事情也不做。

然后,我们做一个开关灯的命令:

public class LightOnCommand : ICommand
    {
        private readonly Light _light;//这个字段就是ConcreteCommand中的一个Receiver,多用组合少用继承!

        public LightOnCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.On();
        }
    }

可以看到LightOnCommand就是一个控制灯开的命令,它对应命令模式中的ConcreteCommand,里面有一个_light字段,这个_light字段对应的是Receiver,真正的动作执行都是由Receiver来决定的。同样,我们可以设计一个关灯的Command:

 public class LightOffCommand : ICommand
    {
        private readonly Light _light;

        public LightOffCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.Off();
        }
    }

代码结构基本相同,不在赘述

一个Receiver,我们上面代码中是一个灯,他就是一个类,真正执行动作的就是这个灯,Receiver:

public class Light
    {
        public void On()
        {
            Console.WriteLine("light's on");
        }

        public void Off()
        {
            Console.WriteLine("light's off");
        }
    }

这样,关键的几个角色就已经设计完毕,我们看一下效果:

 class Program
    {
        static void Main(string[] args)
        {
            var control = new RemoteControl();
            var light = new Light();
            var lightOnCommand = new LightOnCommand(light);
            var lightOffCommand = new LightOffCommand(light);

            control.SetCommand(0, lightOnCommand, lightOffCommand);
            control.OnButtonWasPushed(0);
            Console.ReadKey();
        }
    }

运行一下,效果良好,能够实现我们的目的。

实现撤销功能

接下来我们需要为命令设计一个撤销按钮,首先我们要给ICommand接口来设计一个Undo动作:

 public interface ICommand
    {
        void Execute();
        void Undo();
    }

然后让关灯和开灯等实现这个新的接口方法:

 public class LightOffCommand : ICommand
    {
        private readonly Light _light;

        public LightOffCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.Off();
        }

        public void Undo()
        {
            _light.On();
        }
    }
    public class LightOnCommand : ICommand
    {
        private readonly Light _light;//这个字段就是ConcreteCommand中的一个Receiver,多用组合少用继承!

        public LightOnCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.On();
        }

        public void Undo()
        {
            _light.Off();
        }
    }

可以看出修改这个还是非常容易的,Undo就是Execute的反向操作。

在添加了Undo接口方法后,还有一个问题需要解决,那就是我们需要记录当前按下开关的对应的是哪一个Command,因为我们的Undo按钮只有一个。我们开始这个设计:

public class RemoteControl
    {
        private readonly ICommand[] _onCommands;
        private readonly ICommand[] _offCommands;
        private ICommand _undoCommand;
        public RemoteControl()
        {
            _onCommands = new ICommand[7];//因为遥控器上面只有7个插槽(插槽对应Command)
            _offCommands = new ICommand[7];//因为遥控器上面只有7个插槽(插槽对应Command)       
            var noCommand = new NoCommand();
            _undoCommand = noCommand;
            for (int index = 0; index < 7; index++)
            {
                _onCommands[index] = noCommand;
            }
        }

        public void SetCommand(int index, ICommand onCommand, ICommand offCommand)
        {
            _onCommands[index] = onCommand;
            _offCommands[index] = offCommand;
        }

        public void OnButtonWasPushed(int index)
        {
            _onCommands[index].Execute();
            _undoCommand = _onCommands[index];
        }

        public void OffButtonWasPushed(int index)
        {
            _offCommands[index].Execute();
            _undoCommand = _offCommands[index];
        }

        public void UndoButtonWasPushed()
        {
            _undoCommand.Undo();
        }
    }

首先,我们添加了一个_undoCommand的字段,它表示当前需要执行撤销操作的那个command,然后,我们在每次执行OnButtonWasPushed或OffButtonWasPushed方法后,记录或更新这个command,让它成为一个UndoCommand。最后,添加一个UndoButtonWasPushed方法,来表示执行一个Undo操作,里面就是调用当前_undoCommand对象上面的Undo方法。

锁的思考

当我们完成上面的操作后,实际上还有一个问题在里面,那就是锁的操作。当我们在遥控器上面乱按一通的话,因为_undoCommand这个对象在多个方法上出现,当不同的线程都在执行这些方法时,_undoCommand这个对象的状态是会不断的变化的,如果我们不给这个对象加一个锁,那么操作就不是原子的,当我们执行UndoButtonWasPushed这个方法的时候,由于其他线程上面对于_undoCommand的访问可能没有用结束,那么这个时候我们执行撤销操作,里面的这个Undo对象可能不是最新的,我们来解决这个问题:

 public class RemoteControl
    {
        private readonly ICommand[] _onCommands;
        private readonly ICommand[] _offCommands;
        private ICommand _undoCommand;
        private readonly static object Lock = new object();//使用lock代码块的必备字段

        public RemoteControl()
        {
            _onCommands = new ICommand[7];//因为遥控器上面只有7个插槽(插槽对应Command)
            _offCommands = new ICommand[7];//因为遥控器上面只有7个插槽(插槽对应Command)       
            var noCommand = new NoCommand();
            _undoCommand = noCommand;
            for (int index = 0; index < 7; index++)
            {
                _onCommands[index] = noCommand;
            }
        }

        public void SetCommand(int index, ICommand onCommand, ICommand offCommand)
        {
            _onCommands[index] = onCommand;
            _offCommands[index] = offCommand;
        }
        public void OnButtonWasPushed(int index)
        {
            _onCommands[index].Execute();
            lock (Lock)//加锁
            {
                _undoCommand = _onCommands[index];
            }
        }
        public void OffButtonWasPushed(int index)
        {
            _offCommands[index].Execute();
            lock (Lock)//加锁
            {
                _undoCommand = _offCommands[index];
            }
        }
        public void UndoButtonWasPushed()
        {
            lock (Lock)//加锁
            {
                _undoCommand.Undo();
            }
        }
    }
原文地址:https://www.cnblogs.com/pangjianxin/p/10813552.html