Software Dev/13 - Command.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Command\n",
    "\n",
    "## General idea\n",
    "The Command pattern is a behavioral design pattern that encapsulates a request as an object, thereby allowing you to parameterize clients with different requests, queue or log requests, and support undoable operations. It decouples the sender of a request from the object that performs the action, enabling you to define and manage a wide variety of commands and their execution.\n",
    "\n",
    "## Benefits\n",
    "The Command pattern provides several benefits:\n",
    "\n",
    "- Decoupling: The Command pattern decouples the sender of a request from the object that performs the action. The sender only knows about the Command interface, not the specific implementation. This promotes loose coupling between objects and allows for greater flexibility and extensibility in the system's design.\n",
    "\n",
    "- Reusability: Commands encapsulate a specific action or request, making them reusable in different contexts. You can easily create new commands by implementing the Command interface and providing a different behavior. This promotes code reuse and modularity.\n",
    "\n",
    "- Undo/Redo and History: The Command pattern supports undoable operations by encapsulating the necessary state and behavior within a command object. It allows you to easily track and manage the history of commands, enabling undo and redo functionality.\n",
    "\n",
    "- Logging and Audit Trail: The Command pattern provides a natural way to log and track executed commands. You can maintain a log of executed commands for auditing purposes, debugging, or generating reports.\n",
    "\n",
    "- Queuing and Asynchronous Execution: Commands can be easily queued and executed asynchronously. This allows you to build complex systems where requests can be managed and processed in a controlled manner.\n",
    "\n",
    "- High-level Policy Definition: The Command pattern allows you to define high-level policies and workflows by composing multiple commands. You can create complex sequences of commands, encapsulating business processes and operations.\n",
    "\n",
    "> The Command pattern is commonly used in various scenarios, including GUI applications, transactional systems, job scheduling, and multi-level undo/redo functionality. It provides a flexible and extensible way to encapsulate requests as objects, enabling you to decouple the sender and receiver and manage commands effectively.\n",
    "\n",
    "## How it works\n",
    "- The `Command` interface defines a common interface for all concrete command classes. It typically declares an `Execute` method that encapsulates the action to be performed.\n",
    "\n",
    "- Concrete Command classes implement the `Command` interface and provide their specific implementation of the `Execute` method. Each concrete command class represents a specific action or request.\n",
    "\n",
    "- The `Invoker` class is responsible for executing the commands. It maintains a reference to a command object and can invoke the `Execute` method when needed.\n",
    "\n",
    "- The `Receiver` class is the object that performs the actual action or request specified by the command. It contains the business logic and carries out the necessary operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "dotnet_interactive": {
     "language": "csharp"
    },
    "polyglot_notebook": {
     "kernelName": "csharp"
    },
    "vscode": {
     "languageId": "polyglot-notebook"
    }
   },
   "outputs": [],
   "source": [
    "// Example of implementation of command pattern in C#\n",
    "\n",
    "// Command interface\n",
    "public interface ICommand\n",
    "{\n",
    "    void Execute();\n",
    "}\n",
    "\n",
    "// Concrete Command A\n",
    "public class ConcreteCommandA : ICommand\n",
    "{\n",
    "    private Receiver receiver;\n",
    "\n",
    "    public ConcreteCommandA(Receiver receiver)\n",
    "    {\n",
    "        this.receiver = receiver;\n",
    "    }\n",
    "\n",
    "    public void Execute()\n",
    "    {\n",
    "        receiver.ActionA();\n",
    "    }\n",
    "}\n",
    "\n",
    "// Concrete Command B\n",
    "public class ConcreteCommandB : ICommand\n",
    "{\n",
    "    private Receiver receiver;\n",
    "\n",
    "    public ConcreteCommandB(Receiver receiver)\n",
    "    {\n",
    "        this.receiver = receiver;\n",
    "    }\n",
    "\n",
    "    public void Execute()\n",
    "    {\n",
    "        receiver.ActionB();\n",
    "    }\n",
    "}\n",
    "\n",
    "// Receiver\n",
    "public class Receiver\n",
    "{\n",
    "    public void ActionA()\n",
    "    {\n",
    "        Console.WriteLine(\"Receiver: Performing Action A\");\n",
    "    }\n",
    "\n",
    "    public void ActionB()\n",
    "    {\n",
    "        Console.WriteLine(\"Receiver: Performing Action B\");\n",
    "    }\n",
    "}\n",
    "\n",
    "// Invoker\n",
    "public class Invoker\n",
    "{\n",
    "    private ICommand command;\n",
    "\n",
    "    public void SetCommand(ICommand command)\n",
    "    {\n",
    "        this.command = command;\n",
    "    }\n",
    "\n",
    "    public void ExecuteCommand()\n",
    "    {\n",
    "        command.Execute();\n",
    "    }\n",
    "}\n",
    "\n",
    "// Client\n",
    "public class Client\n",
    "{\n",
    "    public void Code()\n",
    "    {\n",
    "        // Create receiver\n",
    "        Receiver receiver = new Receiver();\n",
    "\n",
    "        // Create commands\n",
    "        ICommand commandA = new ConcreteCommandA(receiver);\n",
    "        ICommand commandB = new ConcreteCommandB(receiver);\n",
    "\n",
    "        // Create invoker\n",
    "        Invoker invoker = new Invoker();\n",
    "\n",
    "        // Set and execute command A\n",
    "        invoker.SetCommand(commandA);\n",
    "        invoker.ExecuteCommand();\n",
    "\n",
    "        // Set and execute command B\n",
    "        invoker.SetCommand(commandB);\n",
    "        invoker.ExecuteCommand();\n",
    "    }\n",
    "}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## In this example:\n",
    "\n",
    "- The `ICommand` interface declares the `Execute` method that represents a command. The `ConcreteCommandA` and `ConcreteCommandB` classes implement this interface and provide their specific implementations of the `Execute` method.\n",
    "\n",
    "- The `Receiver` class contains the actual business logic and defines the actions to be performed. It provides methods such as `ActionA` and `ActionB` that represent the operations executed by the commands.\n",
    "\n",
    "- The `Invoker` class is responsible for invoking the commands. It maintains a reference to a command object and provides methods to set and execute the command.\n",
    "\n",
    "- The `Client` class demonstrates how the Command pattern is used. It creates instances of concrete commands (`ConcreteCommandA` and `ConcreteCommandB`), creates a receiver object, creates an invoker object, sets the command, and executes it.\n",
    "\n",
    "> By utilizing the Command pattern, you can encapsulate requests or actions into separate command objects. The invoker object can then execute these commands without having knowledge of the specific operations performed by the receiver. This decoupling allows for flexibility and extensibility, enabling easy addition of new commands and variations of behavior. It also supports features like undo/redo, logging, and asynchronous execution by maintaining a history of executed commands."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}