Recherche d'un exemple de modèle de commande pour l'interface utilisateur [fermé]

Question

Je travaille sur une application WinForm .Net avec l'interface utilisateur de base qui comprend des boutons de barre d'outils, des éléments de menu et des frappes qui lancent tous le même code sous-jacent.À l'heure actuelle, les gestionnaires d'événements pour chacun d'entre eux appellent une méthode commune pour exécuter la fonction.

D'après ce que j'ai lu, ce type d'action pourrait être géré par le Modèle de conception de commande avec l'avantage supplémentaire d'activer/désactiver ou de cocher/décocher automatiquement les éléments de l'interface utilisateur.

J'ai cherché sur le net un bon exemple de projet, mais je n'en ai vraiment pas trouvé.Quelqu'un a-t-il un bon exemple à partager ?

Answer 1

Assurons-nous d'abord de savoir quel est le modèle de commande :

Le modèle de commande résume une demande en tant qu'objet et lui donne une interface publique connue.Le modèle de commande garantit que chaque objet reçoit ses propres commandes et fournit un découplage entre l'expéditeur et le récepteur.Un expéditeur est un objet qui invoque une opération, et un récepteur est un objet qui reçoit la demande et agit dessus.

Voici un exemple pour vous.Il existe de nombreuses façons de procéder, mais je vais adopter une approche basée sur l'interface pour rendre le code plus testable pour vous.Je ne sais pas quel langage vous préférez, mais j'écris ceci en C#.

Tout d’abord, créez une interface qui décrit une commande.

public interface ICommand
{
    void Execute();
}

Deuxièmement, créez des objets de commande qui implémenteront l’interface de commande.

public class CutCommand : ICommand
{
    public void Execute()
    {
        // Put code you like to execute when the CutCommand.Execute method is called.
    }
}

Troisièmement, nous devons configurer notre objet invocateur ou expéditeur.

public class TextOperations
{
    public void Invoke(ICommand command)
    {
        command.Execute();
    }
}

Quatrièmement, créez l’objet client qui utilisera l’objet invocateur/expéditeur.

public class Client
{
    static void Main()
    {
        TextOperations textOperations = new TextOperations();
        textOperation.Invoke(new CutCommand());
    }
}

J'espère que vous pourrez prendre cet exemple et l'utiliser pour l'application sur laquelle vous travaillez.Si vous souhaitez plus de précisions, faites-le-moi savoir.

Answer 2

Vous étes sur le bon chemin.En gros, vous aurez un modèle qui représente le document.Vous utiliserez ce modèle dans CutCommand.Vous souhaiterez modifier le constructeur de CutCommand pour accepter les informations que vous souhaitez couper.Ensuite, à chaque fois que vous cliquez sur le bouton Cut, vous invoquez une nouvelle CutCommand et transmettez les arguments dans le constructeur.Utilisez ensuite ces arguments dans la classe lorsque la méthode Execute est appelée.

Answer 3

Essayez les éditeurs open source .NET comme SharpDévelopper ou Bloc-notes++.

Il y a (naturellement) une discussion sur le modèle de commande sur http://c2.com/cgi/wiki?CommandPattern cela pourrait être utile.

Answer 4

Qt utilise le modèle de commande pour les éléments de la barre de menus/barre d'outils.

Les QActions sont créées séparément à partir de QMenuItem et QToolbar, et les actions peuvent être affectées à QMenuItem et QToolbar avec les méthodes setAction() et addAction() respectivement.

http://web.archive.org/web/20100801023349/http://cartan.cas.suffolk.edu/oopdocbook/html/menus.html

http://web.archive.org/web/20100729211835/http://cartan.cas.suffolk.edu/oopdocbook/html/actions.html

Answer 5

Je ne peux pas vous aider avec un exemple de lien, mais je peux vous fournir un exemple par moi-même.

1) Définir l'interface ICommand :

public interface ICommand {
   void Do();
   void Undo();
}

2) Faites vos implémentations ICommand pour des commandes concrètes, mais définissez également une classe de base abstraite pour celles-ci :

public abstract class WinFormCommand : ICommand {

}

3) Créer un invocateur de commande :

public interface ICommandInvoker {
  void Invoke(ICommand command);
  void ReDo();
  void UnDo();
}

public interface ICommandDirector {
  void Enable(ICommand);
  void Disable(ICommand);
}

public class WinFormsCommandInvoker : ICommandInvoker, ICommandDirector {

    private readonly Dictionary<ICommand, bool> _commands;
    private readonly Queue<ICommand> _commandsQueue;       
    private readonly IButtonDirector _buttonDirector;

    // you can define additional queue for support of ReDo operation

    public WinFormsCommandInvoker(ICommandsBuilder builder, IButtonDirector buttonDirector) {
      _commands = builder.Build();
      _buttonDirector = buttonDirector;
      _commandsQueue = new Queue<ICommand>();
    } 

    public void Invoke(ICommand command) {
        command.Do();
        __commandsQueue.Enqueue(command);
    }

    public void ReDo() {
      //you can implement this using additional queue
    }

    public void UnDo() {
      var command = __commandsQueue.Dequeue();
      command.Undo();
    }

    public void Enable(ICommand command) {
      _commands.[command] = true;
      _buttonDirector.Enable(command);
    }

    public void Disable(ICommand command) {
      _commands.[command] = false;
      _buttonDirector.Disable(command); 
    }
}

4) Vous pouvez maintenant implémenter votre ICommandsBuilder, IButtonDirector et ajouter d'autres interfaces telles que ICheckBoxDirector à WinFormsCommandInvoker.