Command Pattern Demystified

The Purpose of Command Patterns

What does the famous saying “your wish is my command“ mean? It means, whatever you wish for, I will do it as if it is a command. Let's assume you are sitting at your desk, reading this article and suddenly an Angel or a Genie appears in front of you and says the same phrase. You wish to have some Chocolates and the Angel waves the magic wand. Voila! You have Chocolates at your desk.



If you closely examine that in an object-oriented way, the Genie or Angel acts as in Invoker, takes your wish request and maps it into a command instance. The command instance does the action on a receiver. Finally the receiver is ready, the receiver actions are being abstracted from the Invoker. The Command Pattern decouples the invoker and the receiver, it encapsulates each request with a command instance. You should use a Command Pattern when it is necessary to issue request to objects without knowing anything about the operation being requested. This will be clear once you see the implementation.

Implementation

You are making a game application and you need to control a car instance with arrow keys. The car movements or actions must be controlled by arrow keys.

class Receiver_Car
{
    private int _speed = 0;


    public void Accelerate()
    {
        _speed = _speed + 5;

        Console.WriteLine("Speed increased to :" + _speed);
    }

    public void Deccelerate()
    {
        _speed = _speed - 5;

        Console.WriteLine("Speed decreased to :" + _speed);
    }

    public void Start()
    {
        _speed = 3;
        Console.WriteLine("Car started Speed :" + _speed);
    }
    public void Stop()
    {
        _speed = 0;
        Console.WriteLine("Car stopped Speed :" + _speed);
    }

}

Rather than using a bunch of if else statements and calling the car instance directly from the client, there should be a better way to code. If new keys need to be added for controlling the car, then it should not affect your client code. This is exactly where the Command Pattern is used. This is a behavioral design pattern from the GoF design patterns book.

You need to decouple the actions to be invoked on the receiver or the target object by bringing in an invoker class that encapsulates the various commands. The invoker class will store the reference of multiple command objects. All the commands should have the same behavior that is done using a common interface ICommand that contains an Execute() method as in the following:


ICommand interface

interface ICommand
{

   void Execute();
}

Command classes

class DownArrowCommand: ICommand
{
    public Receiver_Car _car;

    public DownArrowCommand(Receiver_Car car)
    {
        _car = car;
    }
    public void Execute()
    {
        _car.Stop();
    }
}

class LeftArrowCommand: ICommand
{
    public Receiver_Car _car;

    public LeftArrowCommand(Receiver_Car car)
    {
        _car = car;
    }

    public void Execute()
    {
        _car.Deccelerate();
    }
}
class RightArrowCommand: ICommand
{
    public Receiver_Car _car;

    public RightArrowCommand(Receiver_Car car)
    {
        _car = car;
    }
    public void Execute()
    {
        _car.Accelerate();
    }
}

class UpArrowCommand: ICommand
{
    public Receiver_Car _car;

    public UpArrowCommand(Receiver_Car car)
    {
        _car = car;
    }
    public void Execute()
    {
        _car.Start();
    }
}

The invoker creates instances of the Commands and stores them in a dictionary. It will execute a specific command based on the client request. That is, if the left arrow is pressed then the left command object is invoked. The invoker exposes an invoke method that executes the appropriate command object.

class Invoker_Keyboard
{
    private Dictionary<string, ICommand> _map;
    Receiver_Car _car;

    public Invoker_Keyboard() {

        _map = new Dictionary<string, ICommand>();
        _car =new Receiver_Car();

        UpArrowCommand cmdUp = new UpArrowCommand(_car);
        DownArrowCommand cmdDown = new DownArrowCommand(_car);
        LeftArrowCommand cmdLeft = new LeftArrowCommand(_car);
        RightArrowCommand cmdRight = new RightArrowCommand(_car);



        _map.Add("UpArrow", cmdUp);
        _map.Add("DownArrow", cmdDown);
        _map.Add("LeftArrow", cmdLeft);
        _map.Add("RightArrow", cmdRight);



    }

    public void Invoke(string cmdName)
    {

      ICommand currentCmd = _map[cmdName];
      currentCmd.Execute();
    }

}

This is how to decouple the Invoker and the Receiver in the Command Pattern.

class Program
{
    static void Main(string[] args)
    {
        ConsoleKeyInfo keyinfo;
        Invoker_Keyboard invoker = new Invoker_Keyboard();
        do
        {
            keyinfo = Console.ReadKey();



            // no need to change client code for adding new commands

            invoker.Invoke(keyinfo.Key.ToString());


        }
        while (keyinfo.Key != ConsoleKey.X);
    }
}

Output