Pattern Command

Fa parte della sezione Programmazione orientata agli oggetti del percorso Dart di Coddy. Lezione 94 di 110.

Il pattern Command incapsula una richiesta come oggetto, consentendoti di parametrizzare i client con richieste diverse, mettere in coda le operazioni o supportare la funzionalità di annullamento. Invece di chiamare direttamente un metodo, racchiudi l’azione in un oggetto comando che può essere memorizzato, passato ad altri o eseguito in seguito.

Il pattern prevede tre componenti chiave: un’interfaccia Command con un metodo execute, Comandi concreti che implementano azioni specifiche e un Ricevitore che esegue il lavoro vero e proprio. Un Invocatore facoltativo attiva i comandi senza sapere cosa fanno:

abstract class Command {
  void execute();
}

class Light {
  void turnOn() => print('Light is ON');
  void turnOff() => print('Light is OFF');
}

class TurnOnCommand implements Command {
  final Light light;
  TurnOnCommand(this.light);

  @override
  void execute() => light.turnOn();
}

class TurnOffCommand implements Command {
  final Light light;
  TurnOffCommand(this.light);

  @override
  void execute() => light.turnOff();
}

class RemoteControl {
  Command? _command;

  void setCommand(Command command) {
    _command = command;
  }

  void pressButton() {
    _command?.execute();
  }
}

void main() {
  var light = Light();
  var remote = RemoteControl();

  remote.setCommand(TurnOnCommand(light));
  remote.pressButton();  // Light is ON

  remote.setCommand(TurnOffCommand(light));
  remote.pressButton();  // Light is OFF
}

RemoteControl non sa nulla delle luci: esegue semplicemente il comando che gli viene assegnato. Questo disaccoppiamento rende facile aggiungere nuovi comandi senza modificare l'invoker. Il pattern Command è ideale per implementare sistemi di annullamento/ripristino, code di attività o registrazione di macro, quando è necessario trattare le azioni come oggetti di prima classe.

Sfida

Facile

Costruiamo un sistema di comandi per un editor di testo usando il pattern Command! Creerai un sistema che incapsula le operazioni sul testo come oggetti comando, consentendo a un editor di eseguire diverse azioni senza conoscere i dettagli di ciascuna operazione. Questo è un classico caso d’uso del pattern Command: immaginalo come un sistema di annullamento/ripristino in cui ogni azione viene memorizzata come oggetto.

Organizzerai il codice in due file:

commands.dart: crea qui il tuo sistema di comandi. Inizia con una classe astratta Command che dichiara un metodo execute(). Poi crea una classe TextDocument (il ricevitore) che contiene un campo String content (inizialmente vuoto) e dispone di tre metodi:
- append(String text) - aggiunge testo alla fine del contenuto
- clear() - imposta il contenuto su una stringa vuota
- show() - stampa Document: [content]
Ora implementa tre comandi concreti che operano con un TextDocument:
- AppendCommand - riceve un documento e del testo nel costruttore e aggiunge il testo quando viene eseguito
- ClearCommand - riceve un documento nel costruttore e lo svuota quando viene eseguito
- ShowCommand - riceve un documento nel costruttore e ne mostra il contenuto quando viene eseguito
Infine, crea una classe TextEditor (l’invocatore) che memorizza un elenco di comandi. Dovrebbe avere un metodo addCommand(Command command) per accodare i comandi e un metodo runAll() che esegue tutti i comandi accodati nell’ordine.
main.dart: importa il tuo file dei comandi e mostra il pattern Command. Crea un TextDocument e un TextEditor. Accoda i seguenti comandi nell’ordine: aggiungi Hello, aggiungi World, mostra il documento, aggiungi !, mostra di nuovo, svuota il documento e mostralo un’ultima volta. Poi esegui tutti i comandi accodati.

Nota come TextEditor non sappia nulla dell’aggiunta, dello svuotamento o della visualizzazione: si limita a eseguire i comandi che gli vengono assegnati. Questo disaccoppiamento è l’essenza del pattern Command!

Output previsto:

Document: Hello World
Document: Hello World!
Document:

Provalo tu

import 'commands.dart';

void main() {
  // TODO: Crea un'istanza di TextDocument

  // TODO: Crea un'istanza di TextEditor

  // TODO: Metti in coda i seguenti comandi nell'ordine indicato:
  // 1. Aggiungi "Hello"
  // 2. Aggiungi " World"
  // 3. Mostra il documento
  // 4. Aggiungi "!"
  // 5. Mostra di nuovo il documento
  // 6. Cancella il contenuto del documento
  // 7. Mostra il documento un'ultima volta

  // TODO: Esegui tutti i comandi in coda
}