Patron Commande

Fait partie de la section Programmation Orientée Objet du Journey Dart de Coddy. Leçon 94 sur 110.

Le patron Commande encapsule une requête sous forme d'objet, vous permettant ainsi de paramétrer des clients avec différentes requêtes, de mettre des opérations en file d'attente ou de prendre en charge l'annulation. Au lieu d'appeler directement une méthode, vous enveloppez l'action dans un objet commande qui peut être stocké, transmis ou exécuté ultérieurement.

Le modèle implique trois composants clés : une interface Command dotée d’une méthode execute, des commandes concrètes qui implémentent des actions spécifiques, et un récepteur qui effectue le travail réel. Un invocateur facultatif déclenche les commandes sans savoir ce qu’elles font :

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();  // La lumière est allumée

  remote.setCommand(TurnOffCommand(light));
  remote.pressButton();  // La lumière est éteinte
}

La RemoteControl ne sait rien des lumières : elle exécute simplement la commande qui lui est donnée. Ce découplage facilite l’ajout de nouvelles commandes sans modifier l’invocateur. Le pattern Command est idéal pour implémenter des systèmes d’annulation/rétablissement, des files d’attente de tâches ou l’enregistrement de macros lorsque vous devez traiter les actions comme des objets de première classe.

Défi

Facile

Construisons un système de commandes pour un éditeur de texte en utilisant le patron Command ! Vous allez créer un système qui encapsule les opérations textuelles sous forme d’objets commande, permettant à un éditeur d’exécuter différentes actions sans connaître les détails de chaque opération. Il s’agit d’un cas d’utilisation classique du patron Command : imaginez un système d’annulation/rétablissement dans lequel chaque action est stockée en tant qu’objet.

Vous allez organiser votre code en deux fichiers :

commands.dart : créez votre système de commandes ici. Commencez par une classe abstraite Command qui déclare une méthode execute(). Créez ensuite une classe TextDocument (le récepteur) qui contient un champ String content (initialement vide) et possède trois méthodes :
- append(String text) - ajoute du texte à la fin du contenu
- clear() - définit le contenu comme une chaîne vide
- show() - affiche Document: [content]
Implémentez maintenant trois commandes concrètes qui fonctionnent avec un TextDocument :
- AppendCommand - reçoit un document et du texte dans son constructeur, puis ajoute le texte lors de son exécution
- ClearCommand - reçoit un document dans son constructeur, puis l’efface lors de son exécution
- ShowCommand - reçoit un document dans son constructeur, puis affiche son contenu lors de son exécution
Enfin, créez une classe TextEditor (l’invocateur) qui stocke une liste de commandes. Elle doit posséder une méthode addCommand(Command command) pour mettre les commandes en file d’attente, ainsi qu’une méthode runAll() qui exécute toutes les commandes en attente dans l’ordre.
main.dart : importez votre fichier de commandes et montrez le fonctionnement du patron Command. Créez un TextDocument et un TextEditor. Mettez en file d’attente les commandes suivantes dans l’ordre : ajouter Hello, ajouter World, afficher le document, ajouter !, afficher à nouveau, effacer le document, puis l’afficher une dernière fois. Exécutez ensuite toutes les commandes en attente.

Remarquez que TextEditor ne sait rien de l’ajout, de l’effacement ou de l’affichage : il exécute simplement les commandes qui lui sont fournies. Ce découplage constitue l’essence du patron Command !

Sortie attendue :

Document: Hello World
Document: Hello World!
Document:

Essayez vous-même

import 'commands.dart';

void main() {
  // TODO: Créer une instance de TextDocument

  // TODO: Créer une instance de TextEditor

  // TODO: Mettre en file d'attente les commandes suivantes dans l'ordre :
  // 1. Ajouter "Hello"
  // 2. Ajouter " World"
  // 3. Afficher le document
  // 4. Ajouter "!"
  // 5. Afficher à nouveau le document
  // 6. Effacer le document
  // 7. Afficher le document une dernière fois

  // TODO: Exécuter toutes les commandes en file d'attente
}