Command pattern

Command pattern

Another design pattern it is very popular.I’s used inter alia in approach CQRS (for more information about CQRS).
What is command pattern and when to use it:
Sometimes, you don’t want to do execute your functions immediately.You can use the Command pattern to add work to a queue, to be done later. You can use it to retry, if a command cannot execute properly. You might be able to use this to add “undo” capabilities to a program.
commandpattern
Source: Here

Invokerthe object that executes commands by calling execute() on the object passed to it.

Commandinterface that defines the operations that must support each command (to perform tasks, rollbacks etc.).

Concrete commandclass providing implementation of the interface command, focusing on serving a single task.

Reciever receives the results of the command action

Example

Our example will be a program consisting of a trainer who gives command to sportsmans.

Let’s write an interface to our commands.It has two methods execute() and undo()

// Command
public interface ICommand
{
    void Execute();
    void Undo();
}

And our concrete commands.

Running:

// ConcreteCommand
public class Running : ICommand
{
    public Sportsperson player { get; set; }
    public Running(Sportsperson _player)
    {
        player = _player;
    }
    public void Execute()
    {
        Console.WriteLine("{0} runs\n", player.name);
    }

    public void Undo()
    {
        Console.WriteLine("{0} - remove runs from your training plan\n", player.name);
    }
}

Jumping:

// ConcreteCommand
public class Jumping : ICommand
{
    public Sportsperson player { get; set; }
    public Jumping(Sportsperson _player)
    {
        player = _player;
    }
    public void Execute()
    {
        Console.WriteLine("{0} jumps\n", player.name);
    }

    public void Undo()
    {
        Console.WriteLine("{0} - remove jumping from your training plan\n", player.name);
    }
}

And workout at the gym:

// ConcreteCommand
public class Gym : ICommand
{
    public Sportsperson player { get; set; }
    public Gym(Sportsperson _player)
    {
        player = _player;
    }
    public void Execute()
    {
        Console.WriteLine("{0} lifts weights at the gym\n", player.name);
    }

    public void Undo()
    {
        Console.WriteLine("{0} - remove lifts weights at the gym from your training plan\n", player.name);
    }
}

Our reciver is sportsperson, issued commands will affect on him.

// Receiver
public class Sportsperson
{
    public string name { get; set; }
    public Sportsperson(string _name)
    {
        name = _name;
    }
}

Class Trener is the invoker. Adds specific commands and then execute operations on them in the order they were added and can also remove some training.

// Invoker
public class Trener
{
    private readonly List<ICommand> traning = new List<ICommand>();
    public void AddTraning(ICommand _traning)
    {
        traning.Add(_traning);
    }

    public void Train()
    {
        // Apply traning in the order they were added.
        foreach (ICommand train in traning)
        {
            train.Execute();
        }
    }
    public void RemoveTrain(int index)
    {
        var train = traning[index];
        train.Undo();
        traning.Remove(train);
    }
}

Let’s see how it’s works.

Trainer will work out a training plan for the two sportsmans and then tells them to do it. And next he removing the specific training, in this case workout at the gym.

static void Main(string[] args)
{
    Trener enduranceTraning = new Trener();
    Trener strengthTraining = new Trener();
    Sportsperson sabina = new Sportsperson("Sabina");
    Sportsperson pawel = new Sportsperson("Pawel");

    WriteDiffrentColor("'Sabina' traning");
    enduranceTraning.AddTraning(new Running(sabina));
    enduranceTraning.AddTraning(new Jumping(sabina));
    enduranceTraning.AddTraning(new Gym(sabina));
    enduranceTraning.Train();

    WriteDiffrentColor("'Pawel' traning");
    strengthTraining.AddTraning(new Gym(pawel));
    strengthTraining.AddTraning(new Running(pawel));
    strengthTraining.Train();

    WriteDiffrentColor("Remove the gym from a training plan 'Sabina'");
    enduranceTraning.RemoveTrain(2);
    enduranceTraning.Train();

    WriteDiffrentColor("Remove the gym from a training plan 'Pawel'");
    strengthTraining.RemoveTrain(0);
    strengthTraining.Train();
    Console.ReadKey();
}
static void WriteDiffrentColor(string value)
{
    Console.ForegroundColor = ConsoleColor.DarkGreen;
    Console.WriteLine(value.PadRight(Console.WindowWidth - 1));
    Console.ResetColor();
}
 Result:
command pattern

Summary

If we add to this pattern – dependency injection. We get nicely composed applications eg. CQRS.

Link to the projekt HERE

One Comment on “Command pattern”

Leave a Reply

Your email address will not be published. Required fields are marked *