Cercando per esempio di Comando motivo per UI [chiuso]

Question

Sto lavorando su una WinForm .Net applicazione con l'interfaccia utente di base che include pulsanti della barra degli strumenti, voci di menu e i tasti che tutti avviare lo stesso codice di base.Adesso i gestori di eventi per ciascuna di queste chiamare un metodo comune per eseguire la funzione.

Da quello che ho letto, questo tipo di azione potrebbe essere gestito dal Comando di un modello di progettazione con l'ulteriore vantaggio di automaticamente l'abilitazione/disabilitazione o selezionando/deselezionando gli elementi dell'interfaccia utente.

Sto cercando un buon esempio di progetto, ma davvero non ho trovato uno.Qualcuno ha un buon esempio che può essere condivisa?

Answer 1

Accertiamoci che noi sappiamo che cosa il Comando modello è:

Command pattern incapsula una richiesta come un oggetto e dà un noto interfaccia pubblica.Command Pattern assicura che ogni oggetto riceve il suo propri comandi e fornisce un disaccoppiamento tra il mittente e il destinatario.Un mittente è un oggetto che richiama un di funzionamento, e un ricevitore è un oggetto che riceve la richiesta e agisce su si.

Ecco un esempio per voi.Ci sono molti modi si può fare questo, ma ho intenzione di prendere un'interfaccia di base di un approccio per rendere il codice più testabile per voi.Io non sono sicuro di quello che la lingua che si preferisce, ma sto scrivendo questo in C#.

Primo, creare un'interfaccia che descrive un Comando.

public interface ICommand
{
    void Execute();
}

In secondo luogo, creare oggetti di comando che implementa l'interfaccia di comando.

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

In terzo luogo, dobbiamo impostare il nostro invoker mittente e oggetto.

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

Quarto, creare l'oggetto client che utilizzano l'invoker/oggetto mittente.

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

Spero che tu possa prendere questo esempio e di metterlo in uso per l'applicazione che si sta lavorando.Se vuoi ulteriori chiarimenti, fammelo sapere.

Answer 2

Proprio sulla strada giusta.Fondamentalmente si dispone di un modello che rappresenta il documento.Utilizzare questo modello in CutCommand.Si desidera modificare il CutCommand costruttore di accettare le informazioni che si desidera tagliare.Quindi ogni volta, dire che il Taglio viene fatto clic sul Pulsante, è possibile richiamare un nuovo CutCommand e passando gli argomenti del costruttore.Quindi utilizzare tali argomenti in classe quando viene richiamato il metodo Execute.

Answer 3

Prova open source .NET editor come SharpDevelop o Notepad++.

Non c'è (naturalmente) qualche discussione del Comando Pattern http://c2.com/cgi/wiki?CommandPattern che potrebbe essere utile.

Answer 4

Qt utilizza Command Pattern per la Barra dei menu/Barra degli strumenti.

QActions sono creati separatamente da QMenuItem e QToolbar, e le Azioni che possono essere assegnati a QMenuItem e QToolbar con setAction() e addAction() metodo, rispettivamente.

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

Non ti posso aiutare con un link, ma in grado di fornire esempio da me.

1) Definire interfaccia ICommand:

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

2) Fare il vostro ICommand implementazioni concrete, di comandi, ma anche di definire la classe di base astratta per loro:

public abstract class WinFormCommand : ICommand {

}

3) Creare il comando invoker:

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) Ora è possibile implementare il ICommandsBuilder, IButtonDirector e aggiungere altre interfacce come ICheckBoxDirector per WinFormsCommandInvoker.