Command Design Pattern Using A C# Sample

Introduction

A Command Design pattern is a behavioural design pattern. In which a request can be turned to action.

Where to use a Command Design Pattern?

When we want to,

Do/undo action
When you want to pass a method as an argument or when you want call callbackfunction
When you want to log or track commands

Why use a Command Design Pattern?

Command Design Pattern is a request-driven design pattern. A request will help to choose which command needs to get executed without knowing which object.method to call. In this case, command design patterns play a key role which will make this easy by using ICommand. A Command design pattern actually decouples command manager and command execution logic i.e. Actual implementation.

Players in this pattern:

ICommand – its interface which will do action undo action
ConcreateCommand – it’s one who implements ICommand
Invoker – One who carries out the action
Receiver: One who receives action from invoker and perform action

Example

Problem definition - Provide an interface to the user to open and close the door. And if the user wants, they should be able to undo his/her last action.

This example actually showcases the use case of Do and undo action requirement. For other requirements, I will write separate articles.

In this:

ICommand – ICommand
ConcreateCommand – DoorCommand
Invoker – client, in our case we will client operation in main function
Receiver – Door

Below is the ICommand interface which will define contact to implement:

namespace Command.Design.Pattern
{
public interface ICommand
{
void Execute(Action action);
void UndoExecute();
}
}

We will create enum for peroming Action

public enum Action
{
DOOR_OPEN,
DOOR_CLSOE
}

Below is the DoorCommand class which implements the ICommand contract :

namespace Command.Design.Pattern
{
public class DoorCommand : ICommand
{
private readonly Door door;
Action lastAction { get; set; }
public DoorCommand()
{
door = new Door();
}
public void Execute(Action doorAction)
{
switch (doorAction)
{
case Action.DOOR_OPEN:
door.Open();
break;
case Action.DOOR_CLSOE:
door.Close();
break;
default:
return;
}
lastAction = doorAction;
}
public void UndoExecute()
{
switch (lastAction)
{
case Action.DOOR_OPEN:
door.Close();
break;
case Action.DOOR_CLSOE:
door.Open();
break;
default:
return;
}
}
}
}

Below is the Door class, it actually has core logic implementation:

using static System.Console;
namespace Command.Design.Pattern
{
public class Door
{
public void Open() => WriteLine("------------Door Opened---------------");
public void Close()=> WriteLine("------------Door Closed---------------");
}
}

Below is the Invoker, which requests some action:

using static System.Console;
namespace Command.Design.Pattern
{
class Home
{
static void Main(string[] args)
{
ICommand command = new DoorCommand();
command.Execute(Action.DOOR_OPEN);
command.Execute(Action.DOOR_CLSOE);
command.UndoExecute();
ReadLine();
}
}
}

Below is the output window:

Summary

In this article, we learned of usage of the command design pattern, mainly concentrating on the do and undo operation.