What is Command Pattern in C#?

Introduction

The Command Pattern is a behavioral design pattern that turns a request into a stand-alone object, encapsulating all information about the request. This object can be parameterized with different requests, queued, and even logged for future use. It decouples the sender and receiver objects, allowing for more flexibility in handling commands.

In C#, the Command Pattern is particularly useful when you want to separate the sender of a request from the object that performs the request. This separation lets you parameterize clients with different requests, delay or queue requests, and support undoable operations.

Components of the Command Pattern

1. Command Interface: Create an interface that declares a command executing method. This typically includes a method like Execute().

   public interface ICommand
   {
       void Execute();
   }
   

2. Concrete Command Classes: Implement the ICommand interface with concrete command classes. Each class encapsulates a specific command and the necessary information for its execution.

   public class ConcreteCommand : ICommand
   {
       private Receiver _receiver;
   
       public ConcreteCommand(Receiver receiver)
       {
           _receiver = receiver;
       }
   
       public void Execute()
       {
           _receiver. Action();
       }
   }
   

3. Receiver Class: The Receiver knows how to perform the operation associated with a particular command.

   public class Receiver
   {
       public void Action()
       {
           Console.WriteLine("Receiver is performing the action");
       }
   }
   

4. Invoker Class: The Invoker asks the command to execute the request. It does not need to know anything about the concrete command, just that it implements the ICommand interface.

   public class Invoker
   {
       private ICommand _command;
   
       public void SetCommand(ICommand command)
       {
           _command = command;
       }
   
       public void ExecuteCommand()
       {
           _command. Execute();
       }
   }
   

5. Client Code: In the client code, you instantiate the command objects and associate them with the corresponding receivers. You then set these commands on the invoker and trigger their execution.

   class Program
   {
       static void Main()
       {
           Receiver receiver = new Receiver();
           ICommand command = new ConcreteCommand(receiver);
           Invoker invoker = new Invoker();
   
           invoker.SetCommand(command);
           invoker.ExecuteCommand();
       }
   }
   

Benefits of the Command Pattern

1. Decoupling: The Command Pattern decouples the sender and receiver objects, allowing them to vary independently. This promotes a more flexible and extensible design.
2. Undo/Redo Operations: The Command Pattern makes it easy to implement undo and redo operations by storing the state of the system before each command execution.
3. Command Queueing: Commands can be queued and executed in a specific order, providing a way to implement features like batch processing.
4. Ease of Adding New Commands: Introducing new commands is straightforward. You can create a new command class that implements the ICommand interface without modifying existing code.

Conclusion

The Command Pattern is a powerful tool for encapsulating requests as objects, providing a way to parameterize clients with different requests, queue requests, and support undoable operations. C# helps create a more modular, flexible, and maintainable codebase by promoting decoupling between objects. Understanding and implementing the Command Pattern can significantly enhance the design and architecture of your software applications.