Real-Time Examples of Command Design Pattern in C#

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

Real-Time Examples of Command Design Patterns in C#

I will discuss the Real-Time Examples of the Command Design Pattern in C# in this article. Please read our previous article discussing the basic concepts of Command Design Patterns in C# with Examples. At the end of this article, you will understand the following Real-time Examples using the Command Design Pattern in C#.

Remote Control for a Television
Restaurant Order System
Smart Home System
Simple Graphics Editor
Banking System
Text Editor
Music Player Application
E-Commerce Shopping Cart System

Real-Time Example of Command Design Pattern in C#: Remote Control for a Television

Suppose you have a remote control with buttons for turning the TV on, turning it off, increasing the volume, and decreasing the volume. Each button press is a command the TV (the receiver) must execute. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
namespace CommandDesignPattern
{
    //Command Interface
    public interface ICommand
    {
        void Execute();
    }

    //Receiver - Television
    public class Television
    {
        public void TurnOn()
        {
            Console.WriteLine("TV is ON");
        }

        public void TurnOff()
        {
            Console.WriteLine("TV is OFF");
        }

        public void VolumeUp()
        {
            Console.WriteLine("Volume Increased");
        }

        public void VolumeDown()
        {
            Console.WriteLine("Volume Decreased");
        }
    }

    //Concrete Commands
    public class TurnOnCommand : ICommand
    {
        private Television _tv;

        public TurnOnCommand(Television tv)
        {
            _tv = tv;
        }

        public void Execute()
        {
            _tv.TurnOn();
        }
    }

    public class TurnOffCommand : ICommand
    {
        private Television _tv;

        public TurnOffCommand(Television tv)
        {
            _tv = tv;
        }

        public void Execute()
        {
            _tv.TurnOff();
        }
    }

    public class VolumeUpCommand : ICommand
    {
        private Television _tv;

        public VolumeUpCommand(Television tv)
        {
            _tv = tv;
        }

        public void Execute()
        {
            _tv.VolumeUp();
        }
    }

    public class VolumeDownCommand : ICommand
    {
        private Television _tv;

        public VolumeDownCommand(Television tv)
        {
            _tv = tv;
        }

        public void Execute()
        {
            _tv.VolumeDown();
        }
    }

    //Invoker - Remote Control
    public class RemoteControl
    {
        private ICommand _command;

        public void SetCommand(ICommand command)
        {
            _command = command;
        }

        public void PressButton()
        {
            _command.Execute();
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            Television tv = new Television();

            ICommand turnOn = new TurnOnCommand(tv);
            ICommand turnOff = new TurnOffCommand(tv);
            ICommand volumeUp = new VolumeUpCommand(tv);
            ICommand volumeDown = new VolumeDownCommand(tv);

            RemoteControl remote = new RemoteControl();

            remote.SetCommand(turnOn);
            remote.PressButton();

            remote.SetCommand(volumeUp);
            remote.PressButton();
            remote.PressButton();  // Increase volume again

            remote.SetCommand(turnOff);
            remote.PressButton();

            Console.ReadKey();
        }
    }
}

This example demonstrates how the Command pattern allows for creating a flexible and extensible remote-control system. If we were to add more functionalities, like changing channels or accessing a menu, it would be a matter of creating additional command classes and integrating them into the remote without altering the existing codebase significantly. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: Restaurant Order System

In a restaurant, a waiter takes orders from customers. Each order can be seen as a command. The kitchen (or chef) is the receiver that will execute these commands. The waiter doesn’t need to know how a dish is prepared; they must pass the order (command) to the kitchen. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
using System.Collections.Generic;

namespace CommandDesignPattern
{
    //Command Interface
    public interface IOrderCommand
    {
        void Execute();
    }

    //Receiver - Kitchen
    public class Kitchen
    {
        public void PreparePasta()
        {
            Console.WriteLine("Preparing Pasta...");
        }

        public void PrepareBurger()
        {
            Console.WriteLine("Preparing Burger...");
        }
    }

    //Concrete Commands
    public class PastaOrderCommand : IOrderCommand
    {
        private Kitchen _kitchen;

        public PastaOrderCommand(Kitchen kitchen)
        {
            _kitchen = kitchen;
        }

        public void Execute()
        {
            _kitchen.PreparePasta();
        }
    }

    public class BurgerOrderCommand : IOrderCommand
    {
        private Kitchen _kitchen;

        public BurgerOrderCommand(Kitchen kitchen)
        {
            _kitchen = kitchen;
        }

        public void Execute()
        {
            _kitchen.PrepareBurger();
        }
    }

    //Invoker - Waiter
    public class Waiter
    {
        private List<IOrderCommand> _orders = new List<IOrderCommand>();

        public void TakeOrder(IOrderCommand orderCommand)
        {
            _orders.Add(orderCommand);
        }

        public void PlaceOrders()
        {
            foreach (var order in _orders)
            {
                order.Execute();
            }
            _orders.Clear();
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            Kitchen kitchen = new Kitchen();

            IOrderCommand pastaOrder = new PastaOrderCommand(kitchen);
            IOrderCommand burgerOrder = new BurgerOrderCommand(kitchen);

            Waiter waiter = new Waiter();

            waiter.TakeOrder(pastaOrder);
            waiter.TakeOrder(burgerOrder);

            // Later, the waiter sends all orders to the kitchen
            waiter.PlaceOrders();

            Console.ReadKey();
        }
    }
}

In this example, the Command pattern allows the system to add more dishes or modify existing ones easily. The waiter (Invoker) remains decoupled from the preparation details, and the kitchen (Receiver) is only concerned with how to prepare the dishes. This kind of abstraction and separation of concerns makes the restaurant system flexible and maintainable. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: Smart Home System

In a smart home, a user can use voice commands to control devices such as lights, fans, and thermostats. Each voice command corresponds to an operation a specific device needs to execute. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
namespace CommandDesignPattern
{
    //Command Interface
    public interface ICommand
    {
        void Execute();
    }

    //Receivers
    //Receiver - Light
    public class Light
    {
        public void TurnOn()
        {
            Console.WriteLine("Light turned ON");
        }

        public void TurnOff()
        {
            Console.WriteLine("Light turned OFF");
        }
    }

    //Receiver - Fan
    public class Fan
    {
        public void Start()
        {
            Console.WriteLine("Fan started");
        }

        public void Stop()
        {
            Console.WriteLine("Fan stopped");
        }
    }

    //Concrete Commands
    public class LightOnCommand : ICommand
    {
        private Light _light;

        public LightOnCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.TurnOn();
        }
    }

    public class LightOffCommand : ICommand
    {
        private Light _light;

        public LightOffCommand(Light light)
        {
            _light = light;
        }

        public void Execute()
        {
            _light.TurnOff();
        }
    }

    public class FanStartCommand : ICommand
    {
        private Fan _fan;

        public FanStartCommand(Fan fan)
        {
            _fan = fan;
        }

        public void Execute()
        {
            _fan.Start();
        }
    }

    public class FanStopCommand : ICommand
    {
        private Fan _fan;

        public FanStopCommand(Fan fan)
        {
            _fan = fan;
        }

        public void Execute()
        {
            _fan.Stop();
        }
    }

    //Invoker - Voice Assistant
    public class VoiceAssistant
    {
        private ICommand _command;

        public void SetCommand(ICommand command)
        {
            _command = command;
        }

        public void HearVoiceCommand()
        {
            _command.Execute();
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            Light livingRoomLight = new Light();
            Fan bedroomFan = new Fan();

            ICommand turnLightOn = new LightOnCommand(livingRoomLight);
            ICommand turnLightOff = new LightOffCommand(livingRoomLight);
            ICommand startFan = new FanStartCommand(bedroomFan);
            ICommand stopFan = new FanStopCommand(bedroomFan);

            VoiceAssistant assistant = new VoiceAssistant();

            // User gives a voice command to turn on the light
            assistant.SetCommand(turnLightOn);
            assistant.HearVoiceCommand();

            // User gives a voice command to start the fan
            assistant.SetCommand(startFan);
            assistant.HearVoiceCommand();

            // User gives a voice command to turn off the light
            assistant.SetCommand(turnLightOff);
            assistant.HearVoiceCommand();

            Console.ReadKey();
        }
    }
}

In this scenario, the Command pattern allows the system to easily add more devices or modify commands without affecting the existing structure. The Voice Assistant remains abstracted from the specific operations and invokes them. This abstraction provides scalability, making it simpler to integrate more complex commands or new devices in the future. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: Simple Graphics Editor

In this graphics editor, users can draw circles and rectangles. Each drawing action is a command. The editor should also be able to undo and redo these drawing actions. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Linq;

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

    //Receiver - Graphics Editor Canvas
    public class Canvas
    {
        public void DrawCircle()
        {
            Console.WriteLine("Circle drawn");
        }

        public void RemoveCircle()
        {
            Console.WriteLine("Circle removed");
        }

        public void DrawRectangle()
        {
            Console.WriteLine("Rectangle drawn");
        }

        public void RemoveRectangle()
        {
            Console.WriteLine("Rectangle removed");
        }
    }

    //Concrete Commands
    public class DrawCircleCommand : ICommand
    {
        private Canvas _canvas;

        public DrawCircleCommand(Canvas canvas)
        {
            _canvas = canvas;
        }

        public void Execute()
        {
            _canvas.DrawCircle();
        }

        public void Undo()
        {
            _canvas.RemoveCircle();
        }
    }

    public class DrawRectangleCommand : ICommand
    {
        private Canvas _canvas;

        public DrawRectangleCommand(Canvas canvas)
        {
            _canvas = canvas;
        }

        public void Execute()
        {
            _canvas.DrawRectangle();
        }

        public void Undo()
        {
            _canvas.RemoveRectangle();
        }
    }

    //Invoker - Graphics Editor
    public class GraphicsEditor
    {
        private Stack<ICommand> _commandHistory = new Stack<ICommand>();

        public void ExecuteCommand(ICommand command)
        {
            command.Execute();
            _commandHistory.Push(command);
        }

        public void UndoLastCommand()
        {
            if (_commandHistory.Any())
            {
                var lastCommand = _commandHistory.Pop();
                lastCommand.Undo();
            }
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            Canvas canvas = new Canvas();
            GraphicsEditor editor = new GraphicsEditor();

            ICommand drawCircle = new DrawCircleCommand(canvas);
            ICommand drawRectangle = new DrawRectangleCommand(canvas);

            editor.ExecuteCommand(drawCircle);
            editor.ExecuteCommand(drawRectangle);

            // Undo last action (Remove rectangle)
            editor.UndoLastCommand();

            // Undo previous action (Remove circle)
            editor.UndoLastCommand();

            Console.ReadKey();
        }
    }
}

In this example, the Command pattern offers a structured way to manage drawing and undoing actions in the graphics editor. The pattern allows for easy extensions, for example, adding more shapes or functionalities without disturbing the existing system. This modular approach simplifies maintenance and improves code readability. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: Banking System

Let’s consider a banking system where customers can make deposits, withdrawals, and transfer funds. A customer can perform various actions on their bank account, like depositing, withdrawing, and transferring money to another account. Each of these actions can be treated as a command. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
namespace CommandDesignPattern
{
    //Command Interface
    public interface IBankCommand
    {
        void Execute();
    }

    //Receiver - Bank Account
    public class BankAccount
    {
        public decimal Balance { get; private set; }

        public void Deposit(decimal amount)
        {
            Balance += amount;
            Console.WriteLine($"Deposited ${amount}. New balance: ${Balance}");
        }

        public void Withdraw(decimal amount)
        {
            if (Balance >= amount)
            {
                Balance -= amount;
                Console.WriteLine($"Withdrew ${amount}. New balance: ${Balance}");
            }
            else
            {
                Console.WriteLine("Insufficient funds.");
            }
        }

        public void Transfer(BankAccount toAccount, decimal amount)
        {
            if (Balance >= amount)
            {
                Balance -= amount;
                toAccount.Deposit(amount);
                Console.WriteLine($"Transferred ${amount} to another account. New balance: ${Balance}");
            }
            else
            {
                Console.WriteLine("Insufficient funds for transfer.");
            }
        }
    }

    //Concrete Commands
    public class DepositCommand : IBankCommand
    {
        private BankAccount _account;
        private decimal _amount;

        public DepositCommand(BankAccount account, decimal amount)
        {
            _account = account;
            _amount = amount;
        }

        public void Execute()
        {
            _account.Deposit(_amount);
        }
    }

    public class WithdrawCommand : IBankCommand
    {
        private BankAccount _account;
        private decimal _amount;

        public WithdrawCommand(BankAccount account, decimal amount)
        {
            _account = account;
            _amount = amount;
        }

        public void Execute()
        {
            _account.Withdraw(_amount);
        }
    }

    public class TransferCommand : IBankCommand
    {
        private BankAccount _fromAccount;
        private BankAccount _toAccount;
        private decimal _amount;

        public TransferCommand(BankAccount fromAccount, BankAccount toAccount, decimal amount)
        {
            _fromAccount = fromAccount;
            _toAccount = toAccount;
            _amount = amount;
        }

        public void Execute()
        {
            _fromAccount.Transfer(_toAccount, _amount);
        }
    }

    //Invoker - Bank App
    public class BankApp
    {
        public void PerformOperation(IBankCommand command)
        {
            command.Execute();
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            BankAccount johnsAccount = new BankAccount();
            BankAccount janesAccount = new BankAccount();

            BankApp bankApp = new BankApp();

            bankApp.PerformOperation(new DepositCommand(johnsAccount, 500));
            bankApp.PerformOperation(new WithdrawCommand(johnsAccount, 200));
            bankApp.PerformOperation(new TransferCommand(johnsAccount, janesAccount, 150));

            Console.ReadKey();
        }
    }
}

In this example, the Command pattern allows different banking operations to be decoupled from the bank application logic. This ensures that adding new banking operations or changing existing ones would be easy without making significant changes to the core application or the bank account classes. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: Text Editor

Let’s consider a text editor where users can write, delete, copy, and paste text. In the text editor, various actions can be executed on the text. These actions can include writing some text, deleting a specific range of text, copying, and pasting. Each of these actions can be encapsulated as a command. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Text;

namespace CommandDesignPattern
{
    //Command Interface
    public interface ITextCommand
    {
        void Execute();
        void Undo();
    }

    //Receiver - TextDocument
    public class TextDocument
    {
        public StringBuilder Content { get; } = new StringBuilder();

        public void Write(string text)
        {
            Content.Append(text);
        }

        public void Delete(int startIndex, int length)
        {
            Content.Remove(startIndex, length);
        }

        // Other methods for copy and paste can be added if needed
    }

    //Concrete Commands
    public class WriteCommand : ITextCommand
    {
        private TextDocument _document;
        private string _text;

        public WriteCommand(TextDocument document, string text)
        {
            _document = document;
            _text = text;
        }

        public void Execute()
        {
            _document.Write(_text);
        }

        public void Undo()
        {
            _document.Delete(_document.Content.Length - _text.Length, _text.Length);
        }
    }

    public class DeleteCommand : ITextCommand
    {
        private TextDocument _document;
        private string _deletedText;
        private int _startIndex;

        public DeleteCommand(TextDocument document, int startIndex, int length)
        {
            _document = document;
            _startIndex = startIndex;
            _deletedText = _document.Content.ToString().Substring(startIndex, length);
        }

        public void Execute()
        {
            _document.Delete(_startIndex, _deletedText.Length);
        }

        public void Undo()
        {
            _document.Content.Insert(_startIndex, _deletedText);
        }
    }

    //Invoker - TextEditor
    public class TextEditor
    {
        private Stack<ITextCommand> _commandHistory = new Stack<ITextCommand>();

        public void ExecuteCommand(ITextCommand command)
        {
            command.Execute();
            _commandHistory.Push(command);
        }

        public void UndoLastCommand()
        {
            if (_commandHistory.Count > 0)
            {
                var lastCommand = _commandHistory.Pop();
                lastCommand.Undo();
            }
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            TextDocument document = new TextDocument();
            TextEditor editor = new TextEditor();

            editor.ExecuteCommand(new WriteCommand(document, "Hello, world!"));
            Console.WriteLine(document.Content); // Outputs: Hello, world!

            editor.ExecuteCommand(new DeleteCommand(document, 7, 5));
            Console.WriteLine(document.Content); // Outputs: Hello, !

            editor.UndoLastCommand();
            Console.WriteLine(document.Content); // Outputs: Hello, world!

            Console.ReadKey();
        }
    }
}

In this example, the Command pattern allows the text editor to encapsulate each operation as an object, making implementing features like undo and redo easy. If more operations (e.g., copy, paste) are needed in the future, new command classes can be added without altering the existing structure. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: Music Player Application

In a music player application, users can perform several actions, such as playing a song, pausing the playback, and skipping to the next track. Each of these actions can be encapsulated as a command. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
namespace CommandDesignPattern
{
    //Command Interface
    public interface IMusicCommand
    {
        void Execute();
    }

    //Receiver - MusicPlayer
    public class MusicPlayer
    {
        public void Play()
        {
            Console.WriteLine("Playing the song.");
        }

        public void Pause()
        {
            Console.WriteLine("Pausing the song.");
        }

        public void Skip()
        {
            Console.WriteLine("Skipping to the next song.");
        }
    }

    //Concrete Commands
    public class PlayCommand : IMusicCommand
    {
        private MusicPlayer _player;

        public PlayCommand(MusicPlayer player)
        {
            _player = player;
        }

        public void Execute()
        {
            _player.Play();
        }
    }

    public class PauseCommand : IMusicCommand
    {
        private MusicPlayer _player;

        public PauseCommand(MusicPlayer player)
        {
            _player = player;
        }

        public void Execute()
        {
            _player.Pause();
        }
    }

    public class SkipCommand : IMusicCommand
    {
        private MusicPlayer _player;

        public SkipCommand(MusicPlayer player)
        {
            _player = player;
        }

        public void Execute()
        {
            _player.Skip();
        }
    }

    //Invoker - MusicRemote
    public class MusicRemote
    {
        private IMusicCommand _command;

        public void SetCommand(IMusicCommand command)
        {
            _command = command;
        }

        public void PressButton()
        {
            _command.Execute();
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            // Receiver
            MusicPlayer player = new MusicPlayer();

            // Invoker
            MusicRemote remote = new MusicRemote();

            // Play song
            remote.SetCommand(new PlayCommand(player));
            remote.PressButton();

            // Pause playback
            remote.SetCommand(new PauseCommand(player));
            remote.PressButton();

            // Skip to next song
            remote.SetCommand(new SkipCommand(player));
            remote.PressButton();

            Console.ReadKey();
        }
    }
}

In this music player scenario, the Command pattern enables the decoupling of the invoker (MusicRemote) from the receiver (MusicPlayer). This makes adding new functionalities (like rewinding or adjusting volume) straightforwardly by introducing new command classes without altering the existing system structure. When you run the above code, you will get the following output.

Real-Time Example of Command Design Pattern in C#: E-Commerce Shopping Cart System

In an e-commerce shopping cart, users can add, remove, or update the quantity of products. Each of these operations can be encapsulated as a command. Let us see how we can implement the above example using Command Design Pattern in C#:

using System;
namespace CommandDesignPattern
{
    //Command Interface
    public interface ICartCommand
    {
        void Execute();
        void Undo();
    }

    //Receiver - ShoppingCart
    public class ShoppingCart
    {
        public void AddProduct(string productName)
        {
            Console.WriteLine($"Added {productName} to the cart.");
        }

        public void RemoveProduct(string productName)
        {
            Console.WriteLine($"Removed {productName} from the cart.");
        }

        public void UpdateQuantity(string productName, int quantity)
        {
            Console.WriteLine($"Updated {productName}'s quantity to {quantity}.");
        }
    }

    //Concrete Commands
    public class AddProductCommand : ICartCommand
    {
        private ShoppingCart _cart;
        private string _productName;

        public AddProductCommand(ShoppingCart cart, string productName)
        {
            _cart = cart;
            _productName = productName;
        }

        public void Execute()
        {
            _cart.AddProduct(_productName);
        }

        public void Undo()
        {
            _cart.RemoveProduct(_productName);
        }
    }

    public class RemoveProductCommand : ICartCommand
    {
        private ShoppingCart _cart;
        private string _productName;

        public RemoveProductCommand(ShoppingCart cart, string productName)
        {
            _cart = cart;
            _productName = productName;
        }

        public void Execute()
        {
            _cart.RemoveProduct(_productName);
        }

        public void Undo()
        {
            _cart.AddProduct(_productName);
        }
    }

    public class UpdateQuantityCommand : ICartCommand
    {
        private ShoppingCart _cart;
        private string _productName;
        private int _quantity;
        private int _previousQuantity;

        public UpdateQuantityCommand(ShoppingCart cart, string productName, int quantity, int previousQuantity)
        {
            _cart = cart;
            _productName = productName;
            _quantity = quantity;
            _previousQuantity = previousQuantity;
        }

        public void Execute()
        {
            _cart.UpdateQuantity(_productName, _quantity);
        }

        public void Undo()
        {
            _cart.UpdateQuantity(_productName, _previousQuantity);
        }
    }

    //Invoker - UserInterface
    public class UserInterface
    {
        private ICartCommand _command;

        public void SetCommand(ICartCommand command)
        {
            _command = command;
        }

        public void ExecuteAction()
        {
            _command.Execute();
        }

        public void UndoAction()
        {
            _command.Undo();
        }
    }
    
    // Testing the Command Design Pattern
    // Client Code
    public class Program
    {
        public static void Main(string[] args)
        {
            // Receiver
            ShoppingCart cart = new ShoppingCart();

            // Invoker
            UserInterface ui = new UserInterface();

            // User adds a product
            ui.SetCommand(new AddProductCommand(cart, "Laptop"));
            ui.ExecuteAction();

            // User removes a product
            ui.SetCommand(new RemoveProductCommand(cart, "Laptop"));
            ui.ExecuteAction();

            // User undoes the remove action
            ui.UndoAction();

            Console.ReadKey();
        }
    }
}

In this e-commerce scenario, the Command pattern offers flexibility by allowing each shopping cart operation to be encapsulated in its own command class. This means that if more operations need to be added in the future (e.g., applying coupons or viewing the cart), new command classes can be introduced without affecting the existing structure. When you run the above code, you will get the following output.

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

We need to parameterize objects according to the action performed.
we need to create and execute requests at different times.
Sending requests to different receivers can be handled in different ways.
We need to support rollback, logging, or transaction functionality.
We need to implement callback functionality.
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#:

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.
Flexibility: Adding new commands without altering existing code is easy, thus promoting the Open-Closed Principle.
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.
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.
Queuing and Delay: Since commands are objects, they can be queued up and executed at specific times, allowing for scheduling and deferred execution.
Logging and Auditing: The pattern makes it easier to log or audit commands, which can be invaluable in applications that need tracking operations.
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#:

Overhead: Introducing command classes for every operation can increase the complexity and number of classes, which might be overkill for simple applications.
Learning Curve: It can introduce a steeper learning curve for developers unfamiliar with the pattern.
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.
Potential for Bloat: If not carefully managed, especially in large applications, the number of specific command classes can explode, leading to maintenance challenges.
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.
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 Visitor Design Pattern in C# with Examples. Here, in this article, I try to explain Real-Time Examples of Command Design Patterns in C#. I hope you enjoy this Real-Time Example of the Command Design Pattern using the C# article.

Dot Net Tutorials

About the Author: Pranaya Rout

Pranaya Rout has published more than 3,000 articles in his 11-year career. Pranaya Rout has very good experience with Microsoft Technologies, Including C#, VB, ASP.NET MVC, ASP.NET Web API, EF, EF Core, ADO.NET, LINQ, SQL Server, MYSQL, Oracle, ASP.NET Core, Cloud Computing, Microservices, Design Patterns and still learning new technologies.