Patrón Command

Parte de la sección Programación Orientada a Objetos del Journey de C# de Coddy. Lección 56 de 70.

El patrón Command es un patrón de comportamiento que convierte una solicitud en un objeto independiente que contiene toda la información sobre la solicitud. Esta transformación te permite pasar solicitudes como argumentos de métodos, ponerlas en cola, registrarlas o admitir operaciones que se pueden deshacer.

El patrón separa el objeto que invoca una operación del objeto que sabe cómo realizarla. Consta de cuatro componentes clave: una interfaz de comando, comandos concretos, un receptor (el objeto que realiza el trabajo real) y un invocador (el objeto que activa los comandos).

public interface ICommand
{
    void Execute();
}

public class Light  // Receptor
{
    public void TurnOn() => Console.WriteLine("Light is ON");
    public void TurnOff() => Console.WriteLine("Light is OFF");
}

public class TurnOnCommand : ICommand
{
    private Light _light;
    
    public TurnOnCommand(Light light) => _light = light;
    
    public void Execute() => _light.TurnOn();
}

public class TurnOffCommand : ICommand
{
    private Light _light;
    
    public TurnOffCommand(Light light) => _light = light;
    
    public void Execute() => _light.TurnOff();
}

El invocador almacena y ejecuta comandos sin saber qué hacen:

public class RemoteControl  // Invocador
{
    private ICommand _command;
    
    public void SetCommand(ICommand command) => _command = command;
    
    public void PressButton() => _command.Execute();
}

// Uso
var light = new Light();
var remote = new RemoteControl();

remote.SetCommand(new TurnOnCommand(light));
remote.PressButton();  // La luz está ENCENDIDA

remote.SetCommand(new TurnOffCommand(light));
remote.PressButton();  // La luz está APAGADA

El patrón Command es especialmente potente para implementar la funcionalidad de deshacer, la grabación de macros o la puesta en cola de operaciones para ejecutarlas más adelante. Cada comando encapsula todo lo necesario para realizar una acción, lo que hace que tu sistema sea más flexible y extensible.

Desafío

Fácil

Construyamos un sistema de comandos para un editor de texto utilizando el patrón Command. Crearás un sistema en el que las operaciones de edición, como insertar y eliminar texto, estén encapsuladas como objetos de comando, lo que permitirá al editor ejecutarlas mediante una interfaz unificada.

Organizarás tu código en tres archivos:

Command.cs: Define una interfaz ICommand en el espacio de nombres TextEditor con un único método Execute(). Después, crea dos clases de comando concretas:
- InsertCommand: recibe un Document y una cadena text en su constructor. Al ejecutarse, agrega el texto al documento e imprime Inserted: {text}
- DeleteCommand: recibe un Document y un int count en su constructor. Al ejecutarse, elimina los últimos count caracteres del documento e imprime Deleted: {count} characters
Document.cs: Crea una clase Document en el mismo espacio de nombres. Este es tu receptor: el objeto que realmente realiza las operaciones de texto. Debe tener:
- Un campo privado de tipo string para almacenar el contenido (inicializado como una cadena vacía)
- Un método Append(string text) que agrega texto al contenido
- Un método RemoveLast(int count) que elimina los últimos count caracteres (si count supera la longitud del contenido, borra todo el contenido)
- Un método GetContent() que devuelve el contenido actual
Program.cs: Crea una clase Editor que actúe como invocador. Debe tener un método SetCommand(ICommand command) y un método ExecuteCommand() que ejecute el comando actual. En tu código principal, demuestra el patrón Command procesando una serie de operaciones de edición.

Recibirás las siguientes entradas:

Número de comandos que se ejecutarán
Para cada comando: el tipo de comando (insert o delete) seguido del texto que se insertará o del número de caracteres que se eliminarán

Después de ejecutar todos los comandos, imprime el contenido final del documento en una línea nueva con el formato Content: {content}.

Por ejemplo, si las entradas son:

4
insert
Hello
insert
 World
delete
3
insert
!

La salida debería ser:

Inserted: Hello
Inserted:  World
Deleted: 3 characters
Inserted: !
Content: Hello Wo!

Observa cómo Editor (el invocador) no sabe nada sobre la manipulación de texto: simplemente ejecuta cualquier comando que recibe. Los comandos encapsulan tanto la acción como el receptor, lo que facilita agregar nuevas operaciones como ReplaceCommand sin cambiar el editor.

Pruébalo tú mismo

using System;
using TextEditor;

// TODO: Crea la clase Editor (el invoker)
public class Editor
{
    // TODO: Añade un campo privado para almacenar el comando actual
    private ICommand _command;

    // TODO: Implementa el método SetCommand
    public void SetCommand(ICommand command)
    {
        // TODO: Almacena el comando
    }

    // TODO: Implementa el método ExecuteCommand
    public void ExecuteCommand()
    {
        // TODO: Ejecuta el comando actual
    }
}

class Program
{
    public static void Main(string[] args)
    {
        // Lee el número de comandos
        int n = Convert.ToInt32(Console.ReadLine());

        // Crea el documento (receiver)
        Document document = new Document();

        // Crea el editor (invoker)
        Editor editor = new Editor();

        // TODO: Procesa cada comando
        for (int i = 0; i < n; i++)
        {
            string commandType = Console.ReadLine();

            // TODO: Basado en commandType, crea el comando apropiado
            // - Si es "insert": lee el texto y crea InsertCommand
            // - Si es "delete": lee la cantidad y crea DeleteCommand
            // Luego establece el comando en el editor y ejecútalo
        }

        // TODO: Imprime el contenido final con el formato "Content: {content}"
    }
}