Design Patterns
Command
05/09/2024 1
Agenda
Command Pattern
Head First Example (Remote Control)
Lab
History of Undo Operations
Simple Logging
Complex Logging
Case Study: Command Management
Distributed Command Pattern
05/09/2024 2
Remote Control
Given remote control with seven programmable slots.
A different device can be put into each slot.
There is an On and Off switch for each device slot.
Global Undo button undoes the last button pressed.
Also given a CD with different vendor classes that have
already been written (for the different devices, TV, Light,
Sprinkler, etc)
05/09/2024 3
First Thoughts
We know that there are seven programmable slots for
different devices…so each device may possibly adhere
to some common interface.
We know that we need to turn each device “on” or
“off”..so that needs to be commonly done for any device.
Undo needs to work for any device as well.
05/09/2024 4
What Varies? What stays the same?
What Varies
The actual device assigned to a slot
The instruction for “On” on a specific device
The instruction for “Off” on a specific device
What Stays the Same
Device with seven slots
Capability to assign a slot to a device
Capability to request that a device turn On or Off
Capability to undo the last action requested against the device
05/09/2024 5
The Vendor Classes (pg 194)
Vendor classes have been provided to us via a CD.
Ceiling Light
TV
Hottub
We know that each device needs an “On” or “Off” state.
Since the capability to turn a device “On” or “Off” is something
that “stays the same”.
However, each vendor class has their own unique way of doing
“On” or “Off”.
05/09/2024 6
One possible solution…
if (slot1 == Light) Problems:
light.on();
The Remote needs to be
Else if (slot1 == Hottub) { aware of all the details about
hottub.prepareJets(); turning a device on (or off).
hottub.jetsOn();
If device On/Off mechanism
changes, the Remote code
} Else if (slot1 == TV) will need to be changed.
tv.on();
If a new device is added, this
etc code would need to be
changed.
Is this Open for Extension??
05/09/2024 Also…what about undo???? 7
Separation of Concerns
The Vendor Class
One (or more) methods that define “On”
One (or more) methods that define “Off”
The Command
Sends a message to a device (On or Off)
Handle the undo of a message
Possible future enhancements
Logging request
Queue request
The Remote – handles one or more Commands. The
Remote doesn’t know anything about the actual vendor
class specifics.
05/09/2024 8
The Command Pattern
“Allows you to decouple the requestor of the action from
the object that performs the action.”
“A Command object encapsulates a request to do
something.”
Note: A Command object handles a single request.
05/09/2024 9
Command Interface (pg203)
public interface Command {
public void execute();
}
The Command interface (in this example) just does one
thing..executes a command.
10
05/09/2024
LightOnCommand (pg203)
public class LightOnCommand implements Command {
The command is
Light light; composed of a vendor
class.
public LightOnCommand(Light light) {
this.light = light;
} Constructor takes the
vendor class as
parameter.
public void execute() {
light.on();
}
}
Here the command delegates
execution to the vendor class.
Note: This is a simple
example..there could be more
steps.
05/09/2024 11
SimpleRemoteControl (pg204)
This version of the
public class SimpleRemoteControl { remote just has one
Command slot; slot.
public SimpleRemoteControl() {}
public void setCommand(Command command) {
slot = command; setCommand
} assigns a Command
to a slot.
public void buttonWasPressed() {
slot.execute(); Tells the command to
} execute. Note that any
} command would work
here. The remote
doesn’t know anything
about the specific
vendor class.
05/09/2024 12
RemoteControlTest (pg204)
SimpleRemoteControl remote = new
SimpleRemoteControl();
Create two vendor
Light light = new Light(); classes.
GarageDoor garageDoor = new GarageDoor();
LightOnCommand lightOn = Create two commands
new LightOnCommand(light); based on these vendor
classes.
GarageDoorOpenCommand garageOpen =
new GarageDoorOpenCommand(garageDoor);
remote.setCommand(lightOn);
Set the command and press
remote.buttonWasPressed();
button
remote.setCommand(garageOpen);
remote.buttonWasPressed();
05/09/2024 13
The Command Pattern
GoF Intent: “Encapsulates a request as an object,
thereby letting you parameterize other objects with
different requests, queue or log requests, and support
undoable operations.”
See diagrams on pg 206
Command encapsulates a Receiver object
Different commands can fit into a Remote Slot (which exists in
the Remote Control)
05/09/2024 14
05/09/2024 15
Definitions (see Diagram on pg 207)
Client (RemoteControlTest) – creates command and
associates command with receiver.
Receiver (TV, HotTub, ec)– knows how to perform the
work.
Concrete Command (LightOnCommand) -
implementation of Command interface
Command Interface – defines interface for all
commands.
Invoker (Remote Control) – holds reference to a
command and calls execute() method against it. 16
Lab Part I
We get a new vendor class for DVD. To turn on the
DVD, call the function TurnPowerOn(). To turn off, you
call TurnPowerOff().
Create an On and Off command object for the DVD
player.
05/09/2024 17
Lab Part II
The customer wants to be able to turn the DVD and TV
on (and off) at the same time.
Create a command that will set up the DVD and TV with
one button click.
05/09/2024 18
Lab Part III (Design Challenge!)
Look at the LightOnCommand and LightOffCommand on
pg 217.
Note that there is a duplication of code between these two
objects.
Can you create an abstract class called Command that
can help remove this duplication of code…and yet support
Undo??
05/09/2024 19
Lab Part I Answer
public class DVDOnCommand : Command {
DVD dvd;
public DVDOnCommand(DVD d)
{
this.dvd = d;
}
public void execute()
{
dvd.TurnPowerOn();
}
}
05/09/2024 20
Lab Part I Answer (cont)
public class DVDOffCommand : Command {
DVD dvd;
public DVDOffCommand(DVD d)
{
this.dvd = d;
}
public void execute()
{
dvd.TurnPowerOff();
}
}
05/09/2024 21
Lab Part II Answer
public class DVDTvOnCommand : Command {
DVD dvd;
TV tv;
public DVDTvOnCommand(DVD d, TV t)
{
this.dvd = d;
this.tv = t;
}
public void execute()
{
tv.on();
tv.changeInputToDvd();
dvd.TurnPowerOn();
}
}
05/09/2024 22
Lab Part III (Answer)
public enum CommandState
{
NOTSET,
ON,
OFF
}
05/09/2024 23
Lab Part III (Answer)
public abstract class CommandBase
{
CommandState state;
public CommandBase()
{
state = CommandState.NOTSET;
}
abstract protected void executeOn();
abstract protected void executeOff();
05/09/2024 24
public void on() {
state = CommandState.ON;
We don’t want on(), off(), and
executeOn();
undo() to be overridden.
}
public void off() {
state = CommandState.OFF;
executeOff();
}
public void undo() {
if (state == CommandState.ON)
off();
else if (state == CommandState.OFF)
on();
else if (state == CommandState.NOTSET)
{
//do nothing
}
}
25
Lab Part III
public class LightCommand : CommandBase
{
Light light;
public LightCommand(Light l) {
this.light = l;
}
protected override void executeOn()
{
light.on();
}
protected override void executeOff()
{
light.off();
}
}
05/09/2024 26
Lab Part III
The client that calls this code…
CommandBase c = new LightCommand(new Light());
c.on();
c.undo();
05/09/2024 27
History of Undo Operations
If the Undo button is pressed multiple times, we want to
undo each command that had been previously applied.
Which object should we enhance to store a history of
each command applied? Why?
Client (RemoteControlTest)
Receiver (TV, DVD, etc)
ConcreteCommand (LightOnCommand, LightOffCommand, etc)
Invoker (RemoteControl)
We need to be able to add commands to a list and then
later get the most recent one. What kind of object can
we use?
05/09/2024 28
History of Undo Operations
public class RemoteControl {
Stack<Command> undoStack; //this gets initialized in
//constructor.
public void onButtonWasPushed(int slot) {
onCommands[slot].execute();
undoStack.push(onCommands[slot]);
}
public void offButtonWasPushed(int slot) {
offCommands[slot].execute();
undoStack.push(offCommands[slot]);
}
public void undoButtonWasPushed() {
Command c = undoStack.pop();
c.undo();
}
29
Simple Logging
We want to enhance the Remote Control again to log
every time a Command is executed (on or off).
Which object should we enhance??
05/09/2024 30
Simple Logging
Changes to RemoteControl…
public void onButtonWasPushed(int slot) {
onCommands[slot].execute();
//Log here
}
public void offButtonWasPushed(int slot) {
offCommands[slot].execute();
//Log here
}
Advantage: We can add logging in the Invoker. No change is needed in any
of the Command or Receiver objects!
05/09/2024 31
Complex Logging
Let’s say we had a spreadsheet application and we know it
may crash often.
For failure recovery, we could periodically store a backup of
the spreadsheet every 5 minutes...or we could
periodically persist the list of commands executed on the
spreadsheet since the last save point.
When a crash occurs, we load the last saved document
and re-apply the persisted commands.
05/09/2024 32
Complex Logging
public void onButtonWasPushed(int slot) { Once again, we can
onCommands[slot].execute(); make these
StoreToDisk(onCommands[slot]); changes in one
} place (the Invoker)
public void offButtonWasPushed(int slot) {
offCommands[slot].execute();
StoreToDisk(offCommands[slot]);
}
public void SaveButtonPressed() {
//Delete stored commands from disk.
}
public void RestoreCommands() {
//load last saved state
Commands[] storedCommands = GetCommandsFromDisk();
//for each Command, call execute()
}
05/09/2024 33
Case Study: Command Management
The File menu contains the
items:
• Open
• Save
• Print
Also menu item “Edit
Copy “ which is enabled
when text is selected.
Same toolbar buttons for
each menu item.
05/09/2024 34
Question
Imagine that there is a Command for each action
Open
Save
Print
Copy
How would you associate each Menu/Toolbar pair with a
Command?
05/09/2024 35
Possible Solutions
In both the Menu and Toolbar click events, write all of the
code for performing the command.
(or) Consolidate all of the logic in one place and have the
Menu and Toolbar events call the same logic.
What are the disadvantages of this approach?
05/09/2024 36
Disadvantages
The developer would need to enforce that each UI
element calls the right command.
Managing state can be become an issue.
For example, input form with three different UI elements for
Save. (Menu Item, Toolbar Button, Button next to the Form)
When the form is in Edit mode all of these elements should be
Enabled. When the form is not in Edit mode, they need to be
disabled.
saveMenuItem.Enabled = false;
saveButton.Enabled = false;
saveToolbar.Enabled = false
05/09/2024 37
Command Management Framework
Based on the Command Pattern
Framework for associating multiple UI Elements to the
same Command
Can associate UI Elements and Commands in one
place.
You can send a message to a Command
“Tell all of your UI Elements to Turn On or Off”
05/09/2024 38
Example
// Create Command Manager object
cmdMgr = new CommandManager();
//Create a Command “Edit Copy” with a Execute and Copy
//functionality.
cmdMgr.Commands.Add( new Command(
"EditCopy",
new Command.ExecuteHandler(OnCopy),
new Command.UpdateHandler(UpdateCopyCommand)));
//Associate Command “Edit Copy” with different UI elements (Menu and
Toolbar)
cmdMgr.Commands["EditCopy"].CommandInstances.Add(
new Object[]{mnuEditCopy, tlbMain.Buttons[4]});
05/09/2024 39
Command Manager
The Commands property
contains a list of all
possible Commands.
CommandsList contains
a List object internally for
storing each possible
Command. It also has a
reference to
CommandManager.
05/09/2024 40
Command Object
ExecuteHandler = delegate that represents the logic for executing the
actual Command logic. Triggered when the command is executed. Gets
associated with OnExecute event.
UpdateHandler = delegate that represents the logic for executing the
logic to update the state of a command. (For example, Edit Copy
should be enabled if text has been selected). Associated with OnUpdate
event. 41
Command Constructor
public Command( string strTag,
ExecuteHandler handlerExecute,
UpdateHandler handlerUpdate)
{
this.strTag = strTag;
Associates events
OnExecute += handlerExecute; to delegates
OnUpdate += handlerUpdate;
}
//Delegates
public delegate void ExecuteHandler(Command cmd);
public delegate void UpdateHandler(Command cmd);
// Events
public event ExecuteHandler OnExecute;
public event UpdateHandler OnUpdate;
05/09/2024 42
Command: Execute() and ProcessUpdates()
// Methods to trigger events
public void Execute()
{
Will call the function
if (OnExecute != null)
passed in as
OnExecute(this);
ExecuteHandler
}
internal void ProcessUpdates()
{ Will call the function
if (OnUpdate != null) passed in as
OnUpdate(this); UpdateHandler
}
How is this Command.Execute() different than the RemoteControl example??
43
Re-look at EditCopy
cmdMgr.Commands.Add( new Command(
"EditCopy",
new Command.ExecuteHandler(OnCopy),
new Command.UpdateHandler(UpdateCopyCommand)));
//Here is the logic of the actual command
public void OnCopy(Command cmd) {
Clipboard.SetDataObject(txtEditor.SelectedText);
}
//Defines the condition for when the command should be “on”
public void UpdateCopyCommand(Command cmd) {
cmd.Enabled = txtEditor.SelectedText.Length > 0;
}
Will discuss later
05/09/2024 44
So far..
Command #1
Tag = “Edit Copy”
OnExecute = OnCopy
OnUpdate = UpdateCopyCommand
Command #2
Tag = “File Open”
OnExecute = OnFileOpen
OnUpdate = null
05/09/2024 45
Associating UI Elements to a Command
//Associate Command “Edit Copy” with different UI elements
//(Menu and Toolbar)
cmdMgr.Commands["EditCopy"].CommandInstances.Add(
new Object[]{mnuEditCopy, tlbMain.Buttons[4]});
What object contains the CommandInstances property??
05/09/2024 46
CommandInstances
Contain a list of all UI Elements
associated with a Command
05/09/2024 47
So far..
Two items:
mnuEditCopy
tlbMain.Buttons[4]
Command #1
Tag = “Edit Copy”
OnExecute = OnCopy
OnUpdate = UpdateCopyCommand
All we have done so far
is store information…
05/09/2024 48
How do we enable a Command???
In CommandManager, there is an event handler for the
Application Idle Event:
private void OnIdle(object sender, System.EventArgs args)
{
IDictionaryEnumerator myEnumerator =
(IDictionaryEnumerator)Commands.GetEnumerator();
while ( myEnumerator.MoveNext() )
{
Command cmd = myEnumerator.Value as Command;
if (cmd != null)
cmd.ProcessUpdates();
Are you enabled???
}
}
49
Command.ProcessUpdates()
internal void ProcessUpdates()
{
if (OnUpdate != null)
OnUpdate(this);
}
For Edit Copy, the following code will be called:
public void UpdateCopyCommand(Command cmd) {
cmd.Enabled = txtEditor.SelectedText.Length > 0;
}
If we do need to enable (or disable) the Command, who do we need to tell
to “go enable/disable yourself?”
05/09/2024 50
Command.Enabled Property
The psuedo-code for this property is the following:
Enabled = true or false //we got this information
externally
foreach (object in CommandInstances)
//enable or disable yourself.
End for
So if there is a Menu Item, ToolBar, etc, we want to enable
each one. But note that CommandInstances is just a
collection of generic objects…
05/09/2024 51
Command.Enabled (Psuedo-Code)
foreach (object in CommandInstances)
if (object is MenuItem) {
MenuItem m = (MenuItem)object;
m.Enabled = (true or false);
} else if (object is Toolbar) {
Toolbar t = (Toolbar)object;
t.Enabled = (true or false);
} else {…}
End for
Question: Any problems with this code???
05/09/2024 52
Command.Enabled (Psuedo-Code)
foreach (object in CommandInstances)
commandExecutor =
GetCommandExecutor(typeof(object);
commandExecutor.Enable( object, true/false);
End for
05/09/2024 53
CommandExecutor
Enable() is abstract. Toolbar and Menu subclasses must
define how Enable needs to work.
05/09/2024 54
CommandExecutor
public abstract class CommandExecutor
{
public abstract void Enable(object item, bool bEnable);
}
public class MenuCommandExecutor : CommandExecutor
{
public override void Enable(object item, bool bEnable)
{
MenuItem mi = (MenuItem)item;
mi.Enabled = bEnable;
}
}
05/09/2024 55
Command.Enabled (Real Code)
public bool Enabled
{
get
{
return enabled;
}
set
{
enabled = value;
foreach(object instance in commandInstances)
{
Manager.GetCommandExecutor(instance).Enable(
instance, enabled);
}
}
}
CommandManager actually contains all possible
CommandExecutors. These are registered during start-up for
each possible type of UI element. (CommandManager
constructor) 56
CommandExecutor - Execution
These objects also help establish the connection between
the UI Event and a Command.
For example, MenuCommandExecutor establishes a link
between the event MenuItem.Click and the associated
Command execution method (command.Execute)
05/09/2024 57
Called when
MenuCommandExecutor we added UI
element to
public class MenuCommandExecutor : CommandExecutor Command
{
public override void InstanceAdded(object item, Command cmd)
{
MenuItem mi = (MenuItem)item;
mi.Click += new System.EventHandler(menuItem_Click);
base.InstanceAdded(item, cmd); //Stores UI/Command
//relationship in
hashtable
}
private void menuItem_Click(object sender, System.EventArgs e)
{
Command cmd = GetCommandForInstance(sender);
cmd.Execute();
}
} 05/09/2024 58
Example (Again)
// Create Command Manager object
cmdMgr = new CommandManager();
//Create a Command “Edit Copy” with a Execute and Copy
//functionality.
cmdMgr.Commands.Add( new Command(
"EditCopy",
new Command.ExecuteHandler(OnCopy),
new Command.UpdateHandler(UpdateCopyCommand)));
//Associate Command “Edit Copy” with different UI elements (Menu and
Toolbar)
cmdMgr.Commands["EditCopy"].CommandInstances.Add(
new Object[]{mnuEditCopy, tlbMain.Buttons[4]});
05/09/2024 59
Confused?
http://msdn.microsoft.com/en-us/magazine/cc188928.aspx
You can download the code!
05/09/2024 60
Distributed Command Pattern
Address Chat Window Problem
http://www.codeproject.com/KB/architecture/
distributedcommandpattern.aspx
05/09/2024 61
