Command

The Command pattern is a behavioral design pattern used in software development to encapsulate a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations.

Key Components

1. Command: This is an interface or abstract class that declares a method for executing a command.

2. ConcreteCommand: This class implements the Command interface and defines the binding between the receiver and an action.

3. Receiver: This is the object that knows how to perform the operations associated with carrying out a request.

4. Invoker: This class asks the command to carry out the request.

5. Client: This class creates a ConcreteCommand object and sets its receiver.

+-------------------+       +------------------+
|   Client          |       |  Invoker         |
|-------------------|       |------------------|
| -command: Command |<----- | -command: Command|
| +setCommand()     |       | +setCommand()    |
| +executeCommand() |       | +executeCommand()|
+-------------------+       +------------------+
        ^                            ^
        |                            |
        |                            |
+----------------+          +-----------------+
|   Command      |          |  ConcreteCommand|
|----------------|          |-----------------|
| +execute()     |          | +execute()      |
+----------------+          +-----------------+
        ^
        |
        |
+----------------+
|   Receiver     |
|----------------|
| +action()      |
+----------------+

How It Works

1. Client: The client creates a command object and sets its receiver.

2. Invoker: The invoker stores the command object and later asks it to execute the request.

3. Command: The command object invokes methods on the receiver to fulfill the request.

4. Receiver: The receiver performs the actual work needed to carry out the request.

Example Scenario

Imagine you have a remote control (Invoker) for a TV (Receiver). The remote control can send various commands like turning the TV on or off. Each button on the remote control represents a different command (ConcreteCommand). The remote control doesn’t know how to turn the TV on or off; it just sends the command to the TV, which knows how to perform these actions.

Benefits

• Decoupling: The Command pattern decouples the object that invokes the operation from the one that knows how to perform it.

• Flexibility: You can easily add new commands without changing existing code.

• Undo/Redo: Commands can be stored in a history list, allowing for undo and redo operations.

Common Use Cases for the Command Design Pattern

The Command design pattern is versatile and can be used in various scenarios. Here are some common use cases:

1. Undo/Redo Operations: Commands can be stored in a history list, allowing for undo and redo functionality in applications like text editors or graphic design software.

2. Transaction Management: Commands can encapsulate all the information needed to perform a transaction, making it easier to manage and rollback transactions in systems like databases.

3. Macro Recording: Commands can be recorded and executed later, enabling macro recording and playback in applications like IDEs or game development tools.

4. Queueing Requests: Commands can be queued and executed in sequence, useful in job scheduling systems or task management applications.

5. Logging Changes: Commands can be logged for auditing purposes, allowing systems to track changes and actions performed by users.

6. GUI Button Actions: Commands can be used to encapsulate actions triggered by GUI elements like buttons, making it easier to manage and extend the functionality of user interfaces.

7. Network Requests: Commands can encapsulate network requests, allowing for retry mechanisms and better error handling in distributed systems.

8. Game Development: Commands can represent actions in a game, such as moving a character or performing an attack, making it easier to implement features like replay or AI scripting.

--- Java Example ---

 public interface Command {
     void execute();
 }


 //Concrete Commands
 public class LightOnCommand implements Command {
     private Light light;

     public LightOnCommand(Light light) {
         this.light = light;
     }

     @Override
     public void execute() {
         light.turnOn();
     }
 }

 public class LightOffCommand implements Command {
     private Light light;

     public LightOffCommand(Light light) {
         this.light = light;
     }

     @Override
     public void execute() {
         light.turnOff();
     }
 }

 //Receiver
 public class Light {
     public void turnOn() {
         System.out.println("The light is on");
     }

     public void turnOff() {
         System.out.println("The light is off");
     }
 }

 //Invoker
 public class RemoteControl {
     private Command command;

     public void setCommand(Command command) {
         this.command = command;
     }

     public void pressButton() {
         command.execute();
     }
 }

 //Client
 public class Main {
     public static void main(String[] args) {
         Light livingRoomLight = new Light();
         Command lightOn = new LightOnCommand(livingRoomLight);
         Command lightOff = new LightOffCommand(livingRoomLight);

         RemoteControl remote = new RemoteControl();

         remote.setCommand(lightOn);
         remote.pressButton();

         remote.setCommand(lightOff);
         remote.pressButton();
     }
 }

--- Python Example ---

 from abc import ABC, abstractmethod

 class Command(ABC):
     @abstractmethod
     def execute(self) -> None:
         pass

 #Concrete Commands
 class LightOnCommand(Command):
     def __init__(self, light: Light) -> None:
         self.light = light

     def execute(self) -> None:
         self.light.turn_on()

 class LightOffCommand(Command):
     def __init__(self, light: Light) -> None:
         self.light = light

     def execute(self) -> None:
         self.light.turn_off()

 #Receiver
 class Light:
     def turn_on(self) -> None:
         print("The light is on")

     def turn_off(self) -> None:
         print("The light is off")

 #Invoker
 class RemoteControl:
     def __init__(self) -> None:
         self.command: Command | None = None

     def set_command(self, command: Command) -> None:
         self.command = command

     def press_button(self) -> None:
         if self.command:
             self.command.execute()

 #Client
 if __name__ == "__main__":
     living_room_light = Light()
     light_on = LightOnCommand(living_room_light)
     light_off = LightOffCommand(living_room_light)

     remote = RemoteControl()

     remote.set_command(light_on)
     remote.press_button()

     remote.set_command(light_off)
     remote.press_button()