命令模式——“请求”封装成对象，以便使用不同的请求，队列或者日志来参数化其它对象。命令模式也支持可撤消的操作。（摘自《Head First Design Patterns》）
以下是自已用VS画了一个简图：
创建命令接口：
interface ICommand
{
void Execute();
void Undo();
}
实现三个命令：
class AttackCommand : ICommand
{
#region Command 成员
public void Execute()
{
Console.WriteLine("攻击");
}
public void Undo()
{
Console.WriteLine("撤消攻击");
}
#endregion
}
class RetreatCommand : ICommand
{
#region Command 成员
public void Execute()
{
Console.WriteLine("撤退");
}
public void Undo()
{
Console.WriteLine("撤消撤退");
}
#endregion
}
class NoCommand : ICommand
{
#region ICommand 成员
public void Execute()
{
}
public void Undo()
{
}
#endregion
}
其中空命令为了初始化使用，不必判断NULL了。创建一个司令官，用来发布命令：
class Commander
{
private ICommand UndoCommand = new NoCommand();
public void SetCommand(ICommand command)
{
command.Execute();
UndoCommand = command;
}
public void UndoLastCommand()
{
UndoCommand.Undo();
UndoCommand = new NoCommand();
}
}
测试一下：
Commander commander = new Commander();
AttackCommand attackCommand = new AttackCommand();
RetreatCommand retreatCommand = new RetreatCommand();
commander.SetCommand(attackCommand);
commander.UndoLastCommand();
commander.SetCommand(retreatCommand);
commander.UndoLastCommand();
commander.SetCommand(attackCommand);
commander.SetCommand(retreatCommand);
commander.UndoLastCommand();
commander.UndoLastCommand();//程序只实了一次撤消，因此这里的第二次撤消没有作用，用户可以创建撤消命令数组来存储实现多次撤消。
输出结果：
攻击
撤消攻击
撤退
撤消撤退
攻击
撤退
撤消撤退
在以前的观察者模式中，使用了发布命令，但是没用应用命令模式，现在结合命令模式重新改写一下以前的观察者模式：
下面是用VS画的一个简图：
其中原本用的接口改成了抽象类，为了简化一下代码，这里主要是为了我自己的这个例子。
/// <summary>
/// 主题对象接口
/// </summary>
public interface ISubject
{
List<Observer> Observers
{
get;
set;
}
void RegisterObserver(Observer observer);
void RemoveObserver(Observer observer);
void NotifyObservers();
}
/// <summary>
/// 观察者基类
/// </summary>
public abstract class Observer
{
public abstract void Update(Command command);
#region = Name =
private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
#endregion
#region = AttackSlogan =
private string _attackslogan;
public string AttackSlogan
{
get { return _attackslogan; }
set { _attackslogan = value; }
}
#endregion
#region = RetreatSlogan =
private string _retreatslogan;
public string RetreatSlogan
{
get { return _retreatslogan; }
set { _retreatslogan = value; }
}
#endregion
}
/// <summary>
/// 斧头小队－－观察者
/// </summary>
public class AxeTeam : Observer
{
#region Observer 成员
public AxeTeam()
{
this.Name = "斧头小队";
this.AttackSlogan = "用斧头攻击，势死如归！";
this.RetreatSlogan = "坚守阵地，死也不放弃！";
}
public override void Update(Command command)
{
command.Observer = this;
command.Execute();
}
#endregion
}
/// <summary>
/// 弓箭手小队－－观察者
/// </summary>
public class BowAndArrowTeam : Observer
{
#region Observer 成员
public BowAndArrowTeam()
{
this.Name = "弓箭手小队";
this.AttackSlogan = "弓箭手掩护，退后十步，射箭！";
this.RetreatSlogan = "边撤退，边掩护斧头小队！";
}
public override void Update(Command command)
{
command.Observer = this;
command.Execute();
}
#endregion
}
/// <summary>
/// 匕首小队－－观察者
/// </summary>
public class KnifeTeam : Observer
{
#region Observer 成员
public KnifeTeam()
{
this.Name = "匕首小队";
this.AttackSlogan = "匕首攻击，打不过就跑！";
this.RetreatSlogan = "快撤啊，我军大势已去！";
}
public override void Update(Command command)
{
command.Observer = this;
command.Execute();
}
#endregion
}
/// <summary>
/// 司令官---主题对象以及发布命令
/// </summary>
public class Commander : ISubject
{
#region ISubject 成员
private List<Observer> _observers;
public List<Observer> Observers
{
get
{
return _observers;
}
set
{
_observers = value;
}
}
public Command Command = new NoCommand();
public Commander()
{
_observers = new List<Observer>();
}
public void RegisterObserver(Observer observer)
{
this.Observers.Add(observer);
}
public void RemoveObserver(Observer observer)
{
this.Observers.Remove(observer);
}
public void NotifyObservers()
{
foreach (Observer observer in this.Observers)
{
observer.Update(this.Command);
}
}
#endregion
public void SetCommand(Command command)
{
this.Command = command;
NotifyObservers();
}
}
/// <summary>
/// 命令基类
/// </summary>
public abstract class Command
{
#region = Observer =
private Observer _observer;
public Observer Observer
{
get { return _observer; }
set { _observer = value; }
}
#endregion
public abstract void Execute();
}
/// <summary>
/// 攻击命令
/// </summary>
class AttackCommand : Command
{
#region Command 成员
public override void Execute()
{
Console.WriteLine(string.Format("{0}：{1}", this.Observer.Name, this.Observer.AttackSlogan));
}
#endregion
}
/// <summary>
/// 撤退命令
/// </summary>
class RetreatCommand : Command
{
#region Command 成员
public override void Execute()
{
Console.WriteLine(string.Format("{0}：{1}", this.Observer.Name, this.Observer.RetreatSlogan));
}
#endregion
}
/// <summary>
/// 空命令
/// </summary>
class NoCommand : Command
{
#region Command 成员
public override void Execute()
{
}
#endregion
}
测试一下：
//实例化司令官和三个小队
Commander commander = new Commander();
AxeTeam axe = new AxeTeam();
BowAndArrowTeam baa = new BowAndArrowTeam();
KnifeTeam knife = new KnifeTeam();
AttackCommand attackCommand = new AttackCommand();
RetreatCommand retreatCommand = new RetreatCommand();
//注册观察者
commander.RegisterObserver(axe);
commander.RegisterObserver(baa);
commander.RegisterObserver(knife);
//司令官下命令
commander.SetCommand(attackCommand);
commander.SetCommand(retreatCommand);
//匕首小队怕死，从军队中删除
Console.WriteLine("匕首小队怕死，从军队中删除");
commander.RemoveObserver(knife);
//司令官再次下命令
commander.SetCommand(attackCommand);
commander.SetCommand(retreatCommand);
观察者模式和命令模式已经结到一起，输出结果：
斧头小队：用斧头攻击，势死如归！
弓箭手小队：弓箭手掩护，退后十步，射箭！
匕首小队：匕首攻击，打不过就跑！
斧头小队：坚守阵地，死也不放弃！
弓箭手小队：边撤退，边掩护斧头小队！
匕首小队：快撤啊，我军大势已去！
匕首小队怕死，从军队中删除
斧头小队：用斧头攻击，势死如归！
弓箭手小队：弓箭手掩护，退后十步，射箭！
斧头小队：坚守阵地，死也不放弃！
弓箭手小队：边撤退，边掩护斧头小队！ －－－－－－－－－－－－－－－－－－－－－－－－－ 至此，全部介结完毕，有错误之处还请大家指出。
分享到：
相关推荐
将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。
Head First 设计模式 （六） 命令模式（Command pattern） C++实现
用最简单的例子理解命令模式(Command Pattern) 命令模式的需求源自想通过一个指令(比如这里IControl的Execute方法)来控制多个类的多个方法，包含了几个要素： 1、命令：让类的各种方法抽象成类实现一个接口 2、...
用java实现命令模式。展现命令模式类与类之间的继承，依赖关系。
命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。
命令模式(Command Pattern).pdf命令模式(Command Pattern).pdf命令模式(Command Pattern).pdf命令模式(Command Pattern).pdf命令模式(Command Pattern).pdf
主要介绍了C#命令模式(Command Pattern),以实例的形式讲述了命令模式通过一个指令来控制多个类的多个方法,需要的朋友可以参考下
设计模式C++学习之命令模式（Command）
命令模式（Command） 用意：把一个请求封装到一个对象中，把发出命令和执行命令的责任分开，委派给不同的对象实现。
Command设计模式ppt 代码示例 设计模式 Command ppt 代码实例 撤销重做实例
在软件系统中，“行为请求者”与“行为实现者”通常呈现一种...[GOF《设计模式》]Command模式结构图如下：图1Command模式结构图Command模式将一个请求封装为一个对象，从而使你可以使用不同的请求对客户进行参数化。
C#面向对象设计模式纵横谈(15)：(行为型模式) Command 命令模式
命令模式
命令模式是一种行为设计模式，它将一个请求封装成一个对象，从而允许用户根据不同的请求对客户进行参数化；同时，它也支持撤销操作。 命令模式的核心在于通过命令对象实现调用操作和实现操作的解耦。这种模式通常...
工厂方法模式(Factory Method Pattern) 观察者模式(Observer Pattern) 建造者模式(Builder Pattern) 解释器模式(Interpreter Pattern) 命令模式(Command Pattern) 模板方法模式(Template Method Pattern) 桥接模式...
命令模式(Command Pattern) 15. 迭代器模式(Iterator Pattern) 16. 观察者模式(Observer Pattern） 17. 解释器模式(Interpreter Pattern) 18. 中介者模式(Mediator Pattern) 19. 职责链模式(Chain of ...
命令模式（Command Pattern） 解释器模式（Interpreter Pattern） 迭代器模式（Iterator Pattern） 中介者模式（Mediator Pattern） 备忘录模式（Memento Pattern） 观察者模式（Observer Pattern） 状态模式...