设计模式——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：

https://github.com/me115/design_patterns