Command Design Pattern is one of the behavioral design patterns used to encapsulate a request as an object, thus enabling to parameterize clients with different requests, queue or log requests, and support undoable operations. This article will discuss the Command Design Pattern in C# with an example. Prerequisites Basic knowledge of OOPS concepts. Any programming language knowledge. The article demonstrates command design patterns using the C# programming language. So, to begin with, C# Introduction to C# C# has been around for quite some period, and it continues to develop, obtaining more enhanced features. medium.com Learning Objectives How to code using an adapter command pattern Getting Started Introduction to Command Design Pattern The Command Design Pattern decouples the object that invokes the operation from the one that knows how to perform it. The pattern provides a way to associate requests with things, where each request is represented as an object with its properties and methods. The critical elements in the Command Pattern are: The Command Interface: Defines the standard interface for all commands. The Concrete Command: Implements the Command Interface and implements the execute method. The Invoker Holds a reference to the command and invokes the command when required. The Receiver: Knows how to perform the operations associated with the command. Example of Command Design Pattern in C# Let us consider an example of a simple calculator that can perform arithmetic operations like addition, subtraction, multiplication, and division. We can use the Command Design Pattern to implement these operations as commands. First, we will create a Command interface that will define the common interface for all commands. This interface will have an execute method that the concrete commands will implement. public interface ICommand
{
    void Execute();
} Next, we will create concrete command classes for each operation, which will implement the ICommand interface and provide the implementation for the execute method. public class AdditionCommand : ICommand
{
    private readonly Calculator _calculator;
    private readonly int _operand;
    public AdditionCommand(Calculator calculator, int operand)
        {
            _calculator = calculator;
            _operand = operand;
        }
        public void Execute()
        {
            _calculator.Add(_operand);
        }
    }
    public class SubtractionCommand : ICommand
    {
        private readonly Calculator _calculator;
        private readonly int _operand;
        public SubtractionCommand(Calculator calculator, int operand)
        {
            _calculator = calculator;
            _operand = operand;
        }
        public void Execute()
        {
            _calculator.Subtract(_operand);
        }
    }
    public class MultiplicationCommand : ICommand
    {
        private readonly Calculator _calculator;
        private readonly int _operand;
        public MultiplicationCommand(Calculator calculator, int operand)
        {
            _calculator = calculator;
            _operand = operand;
        }
        public void Execute()
        {
            _calculator.Multiply(_operand);
        }
    }
    public class DivisionCommand : ICommand
    {
        private readonly Calculator _calculator;
        private readonly int _operand;
        public DivisionCommand(Calculator calculator, int operand)
        {
            _calculator = calculator;
            _operand = operand;
        }
        public void Execute()
        {
            _calculator.Divide(_operand);
        }
    }
} The Calculator class will act as the receiver and know how to perform the arithmetic operations. public class Calculator
{
    private int _result;
    public void Add(int operand)
    {
        _result += operand;
    }
    public void Subtract(int operand)
    {
        _result -= operand;
    }
    public void Multiply(int operand)
    {
        _result *= operand;
    }
    public void Divide(int operand)
    {
        if (operand != 0)
        {
            _result /= operand;
        }
    }
    public int GetResult()
    {
        return _result;
    }
} Finally, we will create an Invoker class, which will hold a reference to the command and invoke the command when required. public class CalculatorInvoker
{
    private ICommand _command;
    public void SetCommand(ICommand command)
    {
        _command = command;
    }
    public void ExecuteCommand()
    {
        _command.Execute();
    }
} Now, let us see how these classes can perform arithmetic operations. static void Main(string[] args) { 
  Calculator calculator = new Calculator(); 
  CalculatorInvoker invoker = new CalculatorInvoker();

  // Create commands for arithmetic operations
  AdditionCommand additionCommand = new AdditionCommand(calculator, 5);
  SubtractionCommand subtractionCommand = new SubtractionCommand(calculator, 3);
  MultiplicationCommand multiplicationCommand = new MultiplicationCommand(calculator, 2);
  DivisionCommand divisionCommand = new DivisionCommand(calculator, 4);

  // Execute commands using invoker
  invoker.SetCommand(additionCommand);
  invoker.ExecuteCommand();
  invoker.SetCommand(subtractionCommand);
  invoker.ExecuteCommand();
  invoker.SetCommand(multiplicationCommand);
  invoker.ExecuteCommand();
  invoker.SetCommand(divisionCommand);
  invoker.ExecuteCommand();
  // Get result from calculator
  int result = calculator.GetResult();
  Console.WriteLine("Result: " + result); // Output: Result: 1
} In the above example, we created four concrete command objects for the arithmetic operations and used the Invoker to execute these commands. The Invoker does not know about the definite commands; it only knows about the Command interface. The concrete controls encapsulate the receiver object (Calculator) and the arguments required for the operations. Conclusion Overall, the Command Design Pattern provides a flexible and extensible way to encapsulate requests as objects and decouple the object that invokes the operation from the one that knows how to perform it. In summary, the Command Design Pattern is a helpful way to decouple the object that invokes the operation from the one that knows how to perform it. It provides a way to associate requests with things, where each request is represented as an object with its properties and methods. In C#, we can use interfaces and classes to implement this pattern. Follow me on , , , , , C# Publication LinkedIn Instagram Twitter Dev.to BuyMeACoffee Also published here

How to Run a Microsoft .NET Docker Image in C#

An Easy Guide to Learn EF Core Migrations

Linktree

Buy Me a Coffee

Newsletter

Too Long; Didn't Read

Make resilience your competitive advantage

How to Transform Your C# Code With the Command Design Pattern

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

10-Day .Net Aspire Challenge: Day 1 - An Introduction to .Net Aspire

104 Stories To Learn About Go

105 Stories To Learn About Functional Programming

100+ Free Pluralsight Courses to learn Python, Java, and Spring Boot

10 Websites to Learn JavaScript for Beginners

10-Day .Net Aspire Challenge: Day 1 - An Introduction to .Net Aspire

104 Stories To Learn About Go

105 Stories To Learn About Functional Programming

100+ Free Pluralsight Courses to learn Python, Java, and Spring Boot

10 Websites to Learn JavaScript for Beginners

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps