设计模式——21.命令模式
命令模式（Command）
“行为变化”类模式
在组件的构建过程中，组件行为的变化经常导致组建本身剧烈的变化。“行为变化”类模式将组件的行为和组件本身进行解耦，从而支持组件行为的变化，实现两者之间的松耦合。
命令模式（Command）简介：
将请求封装成为一个对象，从而使我们可以使用不同的请求对客户端进行参数化，对请求进行排队，记录请求日志，以及支持可撤销的操作。
命令模式（Command）结构：
C++代码
//file: Command.h
#pragma once
//Command类，用了来声明执行操作的接口。
class Command
{
public:
Command();
virtual ~Command();
virtual void execute();
};
//Receiver类，确定一个与请求相关的操作。可以是任何一个类。
class Receiver
{
public:
Receiver();
virtual ~Receiver();
void action();
};
//Invoker类，要求该命令执行这个请求。
class Invoker
{
public:
Invoker(Command* pCommand);
virtual ~Invoker();
void executeCommand();
private:
Command* m_pCommand;
};
//file: Comamnd.cpp
#include "pch.h"
#include "Command.h"
#include <iostream>
using namespace std;
///Command
Command::Command() {}
Command::~Command() {}
void Command::execute() {}
///Receiver
Receiver::Receiver() {}
Receiver::~Receiver() {}
void Receiver::action()
{
cout << "Action Done ." << endl;
}
///Invoker
Invoker::Invoker(Command* pCommand) {
m_pCommand = pCommand;
}
Invoker::~Invoker() {}
void Invoker::executeCommand() {
cout << "Invoke Executing ." << endl;
m_pCommand->execute();
}
ConcreteCommand类，将一个接收者对象绑定一个动作，调用接收者相应的操作，执行Execute。
//file: ConcreteCommand.h
#pragma once
#include "Command.h"
#include <iostream>
class ConcreteCommand : public Command
{
public:
ConcreteCommand(Receiver* pReceiver);
virtual ~ConcreteCommand();
virtual void execute();
private:
Receiver* m_pReceiver;
};
//file: ConcreteCommand.cpp
#include "pch.h"
#include "ConcreteCommand.h"
ConcreteCommand::ConcreteCommand(Receiver* pReceiver) {
m_pReceiver = pReceiver;
}
ConcreteCommand::~ConcreteCommand() {}
void ConcreteCommand::execute() {
std::cout << "ConcreteCommand Executing ." << std::endl;
m_pReceiver->action();
}
客户端代码，创建一个具体的命令对象并设定该命令的接收者：
// ComamndPattern.cpp : This file contains the 'main' function. Program execution begins and ends there.
#include "pch.h"
#include "Command.h"
#include "ConcreteCommand.h"
using namespace std;
int main()
{
Receiver* pReceiver = new Receiver();
ConcreteCommand* pCommand = new ConcreteCommand(pReceiver);
Invoker* pInvoker = new Invoker(pCommand);
pInvoker->executeCommand();
delete pReceiver, pCommand, pInvoker;
return 0;
}
执行结果：
C#代码
Command，Receiver，Invoker类：
//Command类，用了来声明执行操作的接口。
public abstract class Command
{
protected Receiver receiver;
public Command(Receiver receiver)
{
this.receiver = receiver;
}
public abstract void Execute();
}
//Receiver类，确定一个与请求相关的操作。可以是任何一个类。
public class Receiver
{
public void Action()
{
Console.WriteLine("Action Done .");
}
}
//ConcreteCommand类，将一个接收者对象绑定一个动作，调用接收者相应的操作，执行Execute。
public class ConcreteCommand : Command
{
public ConcreteCommand(Receiver receiver) : base(receiver) { }
public override void Execute()
{
Console.WriteLine("ConcreteCommand Executing .");
this.receiver.Action();
}
}
//Invoker类，要求该命令执行这个请求。
public class Invoke
{
private Command command;
public void SetCommand(Command command)
{
this.command = command;
}
public void ExecuteComamnd()
{
Console.WriteLine("Invoke Executing .");
this.command.Execute();
}
}
客户端代码，创建一个具体的命令对象并设定该命令的接收者：
class Program
{
static void Main(string[] args)
{
Receiver r = new Receiver();
Command c = new ConcreteCommand(r);
Invoke i = new Invoke();
i.SetCommand(c);
i.ExecuteComamnd();
Console.Read();
}
}
执行结果：
REF
书籍：
设计模式与游戏开发、大话设计模式
GitHub：
