Command Design Pattern in C#

Back to: Design Patterns in C# With Real-Time Examples

Command Design Pattern in C# with Examples

In this article, I will discuss the Command Design Pattern in C# with Examples. Please read our previous article discussing the Template Method Design Pattern in C# with Examples. The Command Design Pattern falls under the category of Behavioral Design Pattern. As part of this article, we will discuss the following pointers.

1. What is the Command Design Pattern?
2. Real-time Example of Command Design Pattern.
3. Command Design Pattern Implementation using C#.
4. Understanding the Class or UML Diagram of Command Design Pattern.
5. When to use Command Design Pattern in Real-time Application?

What is the Command Design Pattern?

According to the Gang of Four definitions, the Command Design Pattern is used to encapsulate a request as an object (i.e., a command) and pass it to an invoker, wherein the invoker does not know how to serve the request but uses the encapsulated command to perform an action.

Let us understand the above definition with an example. Please have a look at the following image. As you can see in the below image, the client will create the command object. The command object involves three things. First, the Command Object has the Request (i.e., what to do?). Second, it also has the Receiver Object Reference. The Receiver Object is nothing but the object which will handle the request. Third, the command object also has the Execute method. The Execute method will call the receiver object method, and the receiver object method will handle the request.

As per the Command Design Pattern, the Command Object will be passed to the Invoker Object. The Invoker Object does not know how to handle the request. What the Invoker will do is it will call the Execute method of the Command Object. The Execute method of the command object will be called the Receiver Object Method. The Receiver Object Method will perform the necessary action to handle the request. For a better understanding, please have a look at the following diagram.

This is how the command design pattern works. As per the Command Design Pattern, the command object has three things. The first one is the request, i.e., the command. The second one is the Receiver object reference, and the third is the Execute method, which will call the receiver object method to handle the request.

Real-Time Example of Command Design Pattern:

To make you better understand the Command Design Pattern, I have taken the example of a Restaurant. In a Restaurant, the Waiter will be there. What the Waiter will do is, the Waiter will take an order from the Customer. The Customer will tell the Waiter what kind of food he/she wants. The Waiter will note it down on a checklist. Then, the Waiter passes the checklist to the cook. The Cook is the one who will prepare the food and give it back to the Waiter, and the Waiter will give it back to the Customer.

In this example, the Customer is the Client. Order, i.e., what kind of food the customer wants, is the Command. The Waiter is the Invoker. The Waiter does not know how to cook the food. So, the Waiter passes the request to the Receiver, i.e., the Cook, who will prepare the food and give it back to the Waiter, and the Waiter gives it back to the customer.

Command Design Pattern Implementation using C#:

Please have a look at the following image. Here, you can see we have three commands. The first one is the Open Command. It has the request to open the document. Here, the Receiver Object is the Document Object. The Execute Method of the command object will be called the Open Method of the Document Object. Similarly, the Save Command has the request to save a document. Here, the Execute method will call the Save Method of the Document Object. In the same order, the Close Command has the request to close the document. The Execute Method will call the Close Method of the document object.

The Invoker Object (i.e., Menu Options) does not know how to handle the requests. So, what the Invoker Object will do is he will call the Execute method of the command object. As you can see, the menus have Open, Save, and Close options.

So, if the user clicks on the Open menu, then it will execute the Execute method of the Open command. The Execute method of the Open Command Object will call the Open method of the Document object (receiver object), which will open the document.

Similarly, suppose the user clicks on the Close menu. In that case, the Invoker Object will execute the Execute method of the Close command, and the Execute Method of the Close Command Object will call the Close method of the Document object to close the document.

In the same way, if the user clicks on the Save menu, the Invoker Object will execute the Execute method of the Save command, and the Execute Method of the Save Command Object will call the Save method of the Document object to save the document. Let us go ahead and implement the above example step by step using the Command Design Pattern in C#.

How to Implement Command Design Pattern in C#?

The Command design pattern encapsulates a request as an object, allowing users to parameterize clients with different requests, queue requests, log the requests, and support undoable operations. It involves separating objects that issue commands from objects that perform the command. Here’s a simple breakdown of the Command Design Pattern:

1. Command: This is an interface for executing an operation.
2. ConcreteCommand: This class extends the Command interface, implementing the Execute method by invoking the corresponding operation(s) on the Receiver object.
3. Receiver: This class knows how to perform the operations associated with carrying out a request. Any class may serve as a Receiver.
4. Invoker: This class asks the command to carry out the request.
5. Client: The client creates a ConcreteCommand object and sets its receiver.

Step 1: Creating Receiver Object

Create a class file named Document.cs and copy and paste the following code. Here, we created the receiver class with three methods, i.e., Open, Save, and Close. The Receiver class contains the business logic to perform the actual actions. The following methods will be executed whenever the Invoker calls the Execute Method on the command object. If the Invoker calls the Execute method on the Open Command Object, then the Open Method of the Document Object will be executed. Similarly, if the Invoker calls the Execute method on the Save Command Object, then the Save Method of the Document Object will be executed. And this is the same in the case of the Close Method.

using System;
namespace CommandDesignPattern
{
    // Receiver Object 
    // The Receiver contains the business logic. 
    // They know how to perform all kinds of operations
    // They Know how to handle the Request i.e. Performing the actual Operation
    public class Document
    {
        public void Open()
        {
            Console.WriteLine("Document Opened");
        }

        public void Save()
        {
            Console.WriteLine("Document Saved");
        }

        public void Close()
        {
            Console.WriteLine("Document Closed");
        }
    }
}

Step 2: Creating a Command

First, create an interface with the name ICommand.cs and copy and paste the following code. We declare one method (i.e., Execute) in this ICommand interface, which executes a command.

namespace CommandDesignPattern
{
    // Command Interface
    // It declares a method for executing a command
    public interface ICommand
    {
        void Execute();
    }
}

We need to create three command classes by implementing the above ICommand interface.

OpenCommand:

Create a class file named OpenCommand.cs, then copy and paste the following code. The following class contains three things. First, it has a reference to the Receiver Object, i.e., the Document object. Second, it has a constructor, which initializes the Receiver Object. Third, it has the Execute method, which calls the Open method of the Receiver Object, i.e., the Document object Open Method.

namespace CommandDesignPattern
{
    // ConcreteCommand A 
    // It defines a binding between a Receiver Object i.e. Document and an Action i.e. Open
    public class OpenCommand : ICommand
    {
        //Reference of Receiver Object
        private Document document;

        //Initializing the Receiver Object using the Constructor
        public OpenCommand(Document doc)
        {
            document = doc;
        }

        //Execute Method will internally call the Receiver Object Open Method
        public void Execute()
        {
            document.Open();
        }
    }
}

SaveCommand:

Create a class file named SaveCommand.cs and copy and paste the following code. The following class also contains three things. First, it has a reference to the Receiver Object, i.e., the Document object. Second, a constructor initializes the Receiver Object, i.e., the document. Third, it has the Execute method, which calls the Save method of the Receiver Object, i.e., the Document object Save Method.

namespace CommandDesignPattern
{
    //ConcreteCommand B 
    //It defines a binding between a Receiver Object i.e. Document and an Action i.e. Save
    class SaveCommand : ICommand
    {
        //Reference of Receiver Object
        private Document document;

        //Initializing the Receiver Object using the Constructor
        public SaveCommand(Document doc)
        {
            document = doc;
        }

        //Execute Method will internally call the Receiver Object Save Method
        public void Execute()
        {
            document.Save();
        }
    }
}

CloseCommand:

Create a class file called CloseCommand.cs and copy and paste the following code. The following class also does the same thing as the previous two classes. It has a reference to the Receiver Object, i.e. Document Object. Second, a constructor initializes the Receiver Object, i.e., the document. It also has the Execute method, which calls the Close method of the Receiver Object, i.e., the Document object Close Method.

namespace CommandDesignPattern
{
    //ConcreteCommand C 
    //It defines a binding between a Receiver Object i.e. Document and an Action i.e. Close
    class CloseCommand : ICommand
    {
        //Reference of Receiver Object
        private Document document;

        //Initializing the Receiver Object using the Constructor
        public CloseCommand(Document doc)
        {
            document = doc;
        }

        //Execute Method will internally call the Receiver Object Close Method
        public void Execute()
        {
            document.Close();
        }
    }
}

Step 3: Creating the Invoker

The Invoker will receive the command but can not handle that request. So, the one and only responsibility of the Invoker is to call the Execute method on the Receiver Object. So, Create a class file named MenuOptions.cs and copy and paste the following code. As you can see, this class contains three ICommand Type variables that are initialized using the constructor. This class also contains three methods, i.e., ClickOpen, ClickSave, and ClickClose, and within these methods, we call the command object Execute method.

namespace CommandDesignPattern
{
    // Invoker  
    // The Invoker is associated with one or several commands. 
    // It sends a request to the command.
    public class MenuOptions
    {
        private ICommand openCommand;
        private ICommand saveCommand;
        private ICommand closeCommand;

        public MenuOptions(ICommand open, ICommand save, ICommand close)
        {
            this.openCommand = open;
            this.saveCommand = save;
            this.closeCommand = close;
        }

        //The Invoker cannot handle the Request, so it internally calls the Execute Method
        //of the Command Object. 
        public void ClickOpen()
        {
            openCommand.Execute();
        }

        //The Invoker cannot handle the Request, so it internally calls the Execute Method
        //of the Command Object. 
        public void ClickSave()
        {
            saveCommand.Execute();
        }

        //The Invoker cannot handle the Request, so it internally calls the Execute Method
        //of the Command Object. 
        public void ClickClose()
        {
            closeCommand.Execute();
        }
    }
}

Note: The Invoker object does not depend on the concrete command or receiver classes. It passes the request to a receiver indirectly by executing a command.

Step 4: Client

The Main method of the Program class is going to be the Client. So, modify the Main method of the Program class as shown below. Here, you can see. First, we create an instance of the Receiver Object, i.e., Document. Then, we create three command objects by passing the Receiver Object as a parameter, i.e., the Document object. Then, we create an instance of the Invoke, i.e., MenuOptions, bypassing the command objects as parameters. And finally, calling the Invoker methods.

using System;
namespace CommandDesignPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //Create an Instance of Receiver
            Document document = new Document();

            //Create the Command Object by passing the Receiver Instance
            ICommand openCommand = new OpenCommand(document);
            ICommand saveCommand = new SaveCommand(document);
            ICommand closeCommand = new CloseCommand(document);

            //Create the Invoker instance by passing the command objects
            MenuOptions menu = new MenuOptions(openCommand, saveCommand, closeCommand);

            //Giving command to the Invoker to do the operation
            menu.ClickOpen();
            menu.ClickSave();
            menu.ClickClose();

            Console.ReadKey();
        }
    }
}

Output:

Command Design Pattern UML or Class Diagram:

Let us understand the Class Diagram or UML Diagram of the Command Design Pattern and the components involved. Please have a look at the following image.

As you can see in the above image, the Command Design Pattern consists of five components. They are as follows:

1. Receiver: This class contains the actual implementation of the method the client wants to call. Our example is the Document class’s Open, Save, and Close method.
2. Command: This will be an interface specifying the Execute operation. In our example, the ICommand interface has only one method, i.e., Execute.
3. ConcreteCommand: These classes will implement the ICommand interface and provide implementations for the Execute operation. As part of the Execute method, it will invoke operation(s) on the Receiver object. Our example is the OpenCommand, SaveCommand, and CloseCommand classes.
4. Invoker: The Invoker will be a class and ask the command to carry out the action. In our example, it is the MenuOptions class.
5. Client: This is the class that creates and executes the command object. In our example, it is the Main method of the Program class.

When to use Command Design Patterns in Real-Time Applications?

The Command Design Pattern is particularly useful when you need to decouple the sender of a request from its receiver or to parameterize objects with operations. This pattern can be very powerful when used appropriately. Here are several scenarios in real-time applications where the Command pattern can be beneficial:

• Decoupling: When you want to decouple the classes that invoke operations from the classes that perform these operations.
• Queueing of Operations: The Command pattern is ideal if you need to queue requests at runtime. The commands can be stored for later execution.
• Scheduling of Operations: If there’s a need to schedule commands for execution at specific times.
• Undo/Redo Mechanism: The Command pattern can support undo and redo operations in applications. Each action (like a text edit or shape move in a graphics editor) can be encapsulated in a command. Storing a history of commands enables the undo feature, and maintaining a redo stack can help redo the operations.
• Macro Recording: If you want to support macro recording in applications, it means recording a sequence of operations to be played later as a single action.
• Logging Operations: In scenarios where it’s required to keep a record of the sequence of operations, commands can be logged and then replayed if necessary.
• Networking: Sending commands across a network. Commands can be serialized and sent to be executed on a remote machine.
• GUI Buttons and Menu Items: Many GUI libraries implement buttons and menu items using the Command pattern. Each action associated with a button or a menu can be an object derived from a command.
• Parallel Processing and Job Queues: In modern software architectures, especially in systems that deal with parallel processing or distributed workload queues (like certain uses of the Task Queue), commands can be encapsulated as objects and then executed concurrently.
• Game Programming: For recording game moves, AI actions, or player inputs. Encapsulating each move or action as a command allows game states to be easily saved and replayed.
• Smart Home and IoT: In the Internet of Things scenarios, each device action (like switching a light on/off or adjusting a thermostat) can be encapsulated as a command, making it easier to program complex automation sequences.

So, whenever we need to abstract the creation of actions or decouple the sender and receivers of requests, the Command pattern is a robust design choice. So, we need to use a Command Design Pattern in Real-time Applications when

1. We need to parameterize objects according to the action performed.
2. we need to create and execute requests at different times.
3. Sending requests to different receivers can be handled in different ways.
4. We need to support rollback, logging, or transaction functionality.
5. We need to implement callback functionality.
6. The request’s source should be decoupled from the object that handles the request.

Advantages and Disadvantages of Command Design Patterns in C#:

The Command design pattern is versatile and powerful. Like all design patterns, it has strengths and weaknesses depending on the context in which it’s used. Here are the advantages and disadvantages of the Command design pattern, particularly in the context of C#:

Advantages of Command Design Patterns in C#:

1. Decoupling: The Command pattern decouples the invoker (which triggers a command) from the receiver (the one processing the command). This separation allows changes to be made to either side without affecting the other.
2. Flexibility: Adding new commands without altering existing code is easy, thus promoting the Open-Closed Principle.
3. Macro Commands: Multiple commands can be grouped together to form composite commands (often termed macro commands). This is useful for implementing complex operations composed of simpler ones.
4. Undo/Redo: The Command pattern makes implementing undo and redo operations more straightforward. You can reverse or replay operations by keeping a list of executed command objects.
5. Queuing and Delay: Since commands are objects, they can be queued up and executed at specific times, allowing for scheduling and deferred execution.
6. Logging and Auditing: The pattern makes it easier to log or audit commands, which can be invaluable in applications that need tracking operations.
7. Replay: If all user actions in an application are command objects, it becomes possible to save them and replay them later, a feature valuable in applications like games or simulation tools.

Disadvantages of Command Design Patterns in C#:

1. Overhead: Introducing command classes for every operation can increase the complexity and number of classes, which might be overkill for simple applications.
2. Learning Curve: It can introduce a steeper learning curve for developers unfamiliar with the pattern.
3. Indirection: The pattern introduces an extra level of indirection, which, while providing flexibility, can also make the code harder to follow than direct method calls.
4. Potential for Bloat: If not carefully managed, especially in large applications, the number of specific command classes can explode, leading to maintenance challenges.
5. State Management: Managing the state can become tricky, especially if supporting undo/redo functionality. It requires careful tracking of the command’s state and the application state.
6. Memory Concerns: Keeping a history of commands for undo/redo or logging purposes can consume more memory, especially if the history grows large.

So, while the Command pattern provides many benefits, especially in scenarios requiring decoupling, flexibility, and certain functionalities like undo/redo, it also introduces complexity. As with all design patterns, evaluating your application’s specific needs and context is essential before deciding to use it.

In the next article, I will discuss the Real-Time Examples of the Command Design Patterns in C#. Here, in this article, I try to explain the Command Design Pattern in C# with Examples. I hope you understand the need and use of the Command Design Pattern in C# with Examples.