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 de paramétrer des clients avec différentes requêtes, de mettre des opérations en file d'attente ou de prendre en charge la fonctionnalité d'annulation. Au lieu d'appeler directement une méthode, vous enveloppez l'action dans un objet de commande qui peut être stocké, transmis ou exécuté plus tard.

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();  // La lumière est ALLUMÉE

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

Le RemoteControl ne sait rien des lumières - il exécute simplement la commande qui lui est donnée. Ce découplage permet d'ajouter facilement de nouvelles commandes sans modifier l'appelant (invoker). Le modèle Command est idéal pour implémenter des systèmes d'annulation/rétablissement (undo/redo), 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 dans 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'invocateur) 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 démontrez le 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 exécute simplement 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:

Aide-mémoire

Le pattern Command encapsule une requête sous forme d'objet, vous permettant de paramétrer des clients avec différentes requêtes, de mettre des opérations en file d'attente ou de prendre en charge la fonctionnalité d'annulation (undo).

Le pattern implique trois composants clés :

Interface Command avec une méthode execute
Commandes concrètes (Concrete Commands) qui implémentent des actions spécifiques
Récepteur (Receiver) qui effectue le travail réel
Invocateur (Invoker) (optionnel) qui déclenche des commandes sans savoir ce qu'elles font

Structure de base :

abstract class Command {
  void execute();
}

class Receiver {
  void action() => print('Action performed');
}

class ConcreteCommand implements Command {
  final Receiver receiver;
  ConcreteCommand(this.receiver);

  @override
  void execute() => receiver.action();
}

class Invoker {
  Command? _command;

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

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

Exemple avec un système de contrôle d'éclairage :

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 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
}

L'invocateur ne sait rien du récepteur - il exécute simplement la commande qui lui est donnée. Ce découplage permet d'ajouter facilement de nouvelles commandes sans modifier l'invocateur.

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
}