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

落日映苍穹つ 2021-12-16 23:21 280阅读 0赞

# C\#设计模式之11：命令模式 #

## 命令模式 ##

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

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

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

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

下面是命令模式的**UML定义：**

**![1071603-20190505115655872-1031593045.png][]**

**Command：**定义命令的接口，声明执行的方法。

**ConcreteCommand：**命令接口实现对象，是“虚”的实现；通常会持有接收者，并调用接收者的功能来完成命令要执行的操作。

**Receiver：**接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能。

**Invoker：**要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方，也就是说相当于使用命令对象的入口。

**Client：**创建具体的命令对象，并且设置命令对象的接收者。注意这个不是我们常规意义上的客户端，而是在 **组装**命令对象和接收者，或许， 把这个Client称为装配者会更好理解，因为真正使用命令的客户端是从Invoker来触发执行。

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

## 实现命令模式 ##

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

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

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

![1071603-20190505151124219-1708950254.png][]

**设计遥控器**

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

[1071603-20190505115655872-1031593045.png]: /images/20211214/edc335b89b444c4e862fc81ff642baab.png
[1071603-20190505151124219-1708950254.png]: /images/20211214/6976f1ca774e4ae2a7bae2c5a70be6cb.png