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 patron implique trois composants clés : une interface Command avec une méthode execute, des Concrete Commands qui implémentent des actions spécifiques, et un Receiver qui effectue le travail réel. Un Invoker optionnel 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();  // Light is ON

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

Le RemoteControl ne sait rien des lumières - il exécute simplement la commande qui lui est donnée. Ce découplage facilite l'ajout de nouvelles commandes sans modifier l'invocateur. Le patron 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 où 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 motif de conception Command ! Vous allez créer un système qui encapsule les opérations de texte sous forme d'objets de commande, permettant à un éditeur d'exécuter différentes actions sans connaître les détails de chaque opération. C'est un cas d'utilisation classique du motif Command - pensez-y comme à un système d'annulation/rétablissement (undo/redo) où chaque action est stockée sous forme d'objet.

Vous organiserez 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(). Ensuite, créez 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]
Maintenant, implémentez trois commandes concrètes qui fonctionnent avec un TextDocument :
- AppendCommand - prend un document et du texte dans son constructeur, et ajoute le texte lors de l'exécution
- ClearCommand - prend un document dans son constructeur, et l'efface lors de l'exécution
- ShowCommand - prend un document dans son constructeur, et affiche son contenu lors de l'exécution
Enfin, créez une classe TextEditor (l'appelant) qui stocke une liste de commandes. Elle doit avoir une méthode addCommand(Command command) pour mettre les commandes en file d'attente, et une méthode runAll() qui exécute toutes les commandes en attente dans l'ordre.
main.dart : Importez votre fichier de commandes et faites une démonstration du motif 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, et afficher une dernière fois. Ensuite, lancez toutes les commandes en attente.

Remarquez comment le TextEditor ne sait rien de l'ajout, de l'effacement ou de l'affichage - il se contente d'exécuter les commandes qu'on lui donne. Ce découplage est l'essence même du motif 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
}