Command pattern in C#

 Hello, C# lovers! 😍

Today I want to talk to you about one of the most useful and versatile design patterns: the Command pattern. 🙌

The Command pattern is a behavioral pattern that allows you to encapsulate a request as an object and pass it to a receiver. This way, you can decouple the sender and the receiver of the request, and also support undo/redo operations. 🚀

Sounds cool, right? 😎

Let me show you how it works with a simple example in C#: a calculator that can perform different operations: add, subtract, multiply, or divide. 💻

First, we need to define an interface for the command object. It should have two methods: Execute and Unexecute. The Execute method performs the action of the command, and the Unexecute method reverses it.


// The command interface
public interface ICommand
{
    void Execute();
    void Unexecute();
}


Next, we need to create some concrete commands that implement this interface. For each operation, we can create a command that takes the operands and the receiver as parameters.


// A concrete command for addition public class AddCommand : ICommand { private int x; private int y; private CalculatorReceiver receiver; public AddCommand(int x, int y, CalculatorReceiver receiver) { this.x = x; this.y = y; this.receiver = receiver; } public void Execute() { receiver.Add(x, y); } public void Unexecute() { receiver.Subtract(x, y); // To undo addition, we need to subtract } } // A concrete command for subtraction public class SubtractCommand : ICommand { private int x; private int y; private CalculatorReceiver receiver; public SubtractCommand(int x, int y, CalculatorReceiver receiver) { this.x = x; this.y = y; this.receiver = receiver; } public void Execute() { receiver.Subtract(x, y); } public void Unexecute() { receiver.Add(x, y); // To undo subtraction, we need to add } } // A concrete command for multiplication public class MultiplyCommand : ICommand { private int x; private int y; private CalculatorReceiver receiver; public MultiplyCommand(int x, int y, CalculatorReceiver receiver) { this.x = x; this.y = y; this.receiver = receiver; } public void Execute() { receiver.Multiply(x, y); } public void Unexecute(){

        receiver.Divide(x, y); // To undo multiplication, we need to divide
    }
}


Similarly, we can implement the division command.

// A concrete command for division
public class DivideCommand : ICommand
{
    private int x;
    private int y;
    private CalculatorReceiver receiver;

    public DivideCommand(int x, int y, CalculatorReceiver receiver)
    {
        this.x = x;
        this.y = y;
        this.receiver = receiver;
    }

    public void Execute()
    {
        receiver.Divide(x, y);
    }

    public void Unexecute()
    {
        receiver.Multiply(x, y); // To undo division, we need to multiply
    }
}


Now we need a class that represents the receiver of the commands. This is the class that actually knows how to perform the actions of the commands. In our case, it is the calculator that can perform different operations and display the results.


// The receiver class
public class CalculatorReceiver
{
    public void Add(int x, int y)
    {
        Console.WriteLine($"{x} + {y} = {x + y}");
        // Some logic to perform addition
    }

    public void Subtract(int x, int y)
    {
        Console.WriteLine($"{x} - {y} = {x - y}");
        // Some logic to perform subtraction
    }

    public void Multiply(int x, int y)
    {
        Console.WriteLine($"{x} * {y} = {x * y}");
        // Some logic to perform multiplication
    }

    public void Divide(int x, int y){
        Console.WriteLine($"{x} / {y} = {x / y}");
        // Some logic to perform division
    }
}


Finally, we need a class that acts as the sender or invoker of the commands. This is the class that creates and executes the commands. In our case, it is the calculator service that can accept different operations from users. To support undo/redo functionality, we need to use a stack to store the executed commands.

// The invoker class
public class CalculatorService
{
    private Stack<ICommand> undoStack = new Stack<ICommand>(); // A stack of commands to undo
    private Stack<ICommand> redoStack = new Stack<ICommand>(); // A stack of commands to redo

    public void PerformOperation(ICommand command)
    {
        undoStack.Push(command); // Push the command to the undo stack
        redoStack.Clear(); // Clear the redo stack
        command.Execute(); // Execute the command
    }

    public void UndoOperation()
    {
        if (undoStack.Count > 0)
        {
            ICommand lastCommand = undoStack.Pop(); // Pop the last executed command from the undo stack
            redoStack.Push(lastCommand); // Push it to the redo stack
            lastCommand.Unexecute(); // Unexecute the command
            Console.WriteLine("Undoing last operation");
        }
        else
        {
            Console.WriteLine("No operations to undo");
        }
        
    }

    public void RedoOperation()
    {
        if (redoStack.Count > 0)
        {
            ICommand lastCommand = redoStack.Pop(); // Pop the last unexecuted command from the redo stack
            undoStack.Push(lastCommand); // Push it to the undo stack
            lastCommand.Execute(); // Execute the command
            Console.WriteLine("Redoing last operation");
        }
        else
        {
            Console.WriteLine("No operations to redo");
        }
        
    }
}
And that’s it! We have implemented the Command pattern with undo/redo functionality in C#. 🎉
Now we can use it like this:

// Create a calculator receiver object
CalculatorReceiver receiver = new CalculatorReceiver();

// Create a calculator service object
CalculatorService service = new CalculatorService();

// Create some operation commands with different operands and operations
ICommand addCommand = new AddCommand(10, 5, receiver);
ICommand subtractCommand = new SubtractCommand(10, 5, receiver);
ICommand multiplyCommand = new MultiplyCommand(10, 5, receiver);
ICommand divideCommand = new DivideCommand(10, 5, receiver);

// Use the calculator service to perform operations with different commands
service.PerformOperation(addCommand); // 10 + 5 = 15
service.PerformOperation(subtractCommand); // 10 - 5 = 5
service.PerformOperation(multiplyCommand); // 10 * 5 = 50
service.PerformOperation(divideCommand); // 10 / 5 = 2

// Use the calculator service to undo operations if needed
service.UndoOperation(); // Undoing last operation (10 / 5 = 2)
service.UndoOperation(); // Undoing last operation (10 * 5 = 50)
service.UndoOperation(); // Undoing last operation (10 - 5 = 5)
service.UndoOperation(); // Undoing last operation (10 + 5 = 15)
service.UndoOperation(); // No operations to undo

// Use the calculator service to redo operations if needed
service.RedoOperation(); // Redoing last operation (10 + 5 = 15)
service.RedoOperation(); // Redoing last operation (10 - 5 = 5)
service.RedoOperation(); // Redoing last operation (10 * 5 = 50)
service.RedoOperation(); // Redoing last operation (10 / 5 = 2)
service.RedoOperation(); // No operations to redo


As you can see, the Command pattern allows us to create flexible and extensible code that can handle different types of requests in a uniform way. It also makes it easy to support undo/redo operations by keeping track of the executed and unexecuted commands. 😊

If you want to learn more about the Command pattern and other design patterns in C#, I recommend you check out these resources:

I hope you enjoyed this article and learned something new. If you did, please share it with your friends and colleagues who might be interested in C#. And don’t forget to subscribe to my blog for more awesome content on C#. 😁

You can find the code examples here: source code

Happy coding! 👋

Comments

Post a Comment

Popular posts from this blog

Which GOF patterns are good for C#?

Hello, C# fans! 😊 In this article, I will answer a common question that many C# developers have: which GOF patterns are good for C#? 🤔 GOF patterns are the 23 design patterns that were described in the book “ Design Patterns: Elements of Reusable Object-Oriented Software ” by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. They are also known as the Gang of Four (GoF) patterns. They are divided into three categories: creational, structural, and behavioral. 📚 These patterns provide solutions to common software design problems that you may encounter in your projects. They help you write code that is more reusable, flexible, maintainable, and elegant. 😍 But not all GOF patterns are equally useful or applicable in C#. Some of them are more relevant and popular than others. Some are already supported by the language features or the .NET framework. Some of them may be outdated or replaced by newer patterns. 😮 So, which GOF patterns are good for C#?  Creational patterns...
Read more

Angular on a regular SharePoint page (part 2)

Image
In my  previous article , we have added an empty angular element to the SharePoint page.  And now we are ready to move forward and add some functionality to our elements. Before we begin      First of all, let's create in SharePoint Announcements list with the name "Announcements" and add a couple of items with some text. We will access data in our list via the SharePoint REST API, calling "/_api/web/lists/getbytitle('Announcements')/Items" endpoint. Angular project      Now, open the angular elements project which we have created in the previous article in VS Code.      For convenience let's create an interface to work with our data model. Create the "data" folder wonder the "src/app" and create a new file named Announcement.ts.      Add this code to it: export interface Announcement { ID : number ; Title : string ; Body : string ; }      We will use the service to get the data from our list. ...
Read more

Chain of Responsibility pattern in C#

Hello, C# lovers! 😍 Today I want to talk about a very useful design pattern called Chain of Responsibility. This pattern allows you to pass a request along a chain of handlers until one of them can handle it. This way, you can avoid coupling the sender of the request with the receiver, and you can dynamically compose the chain at runtime. Sounds cool, right? 😎 Let’s see an example of how to implement this pattern in C#. Suppose you have a simple ATM machine that can dispense bills of 10, 20, and 50 dollars. You want to write a program that can handle any amount of money requested by the user, using the least number of bills possible. To do this, you can create an abstract class called Handler that defines an interface for handling the requests. It also has a reference to the next handler in the chain, and a method to set it. // The 'Handler' abstract class public abstract class Handler { protected Handler successor; public void SetSuccessor ( Handler successo...
Read more