Buscando un ejemplo de patrón de comando para UI [cerrado]

Question

Estoy trabajando en una aplicación WinForm .Net con la interfaz de usuario básica que incluye botones de la barra de herramientas, elementos del menú y pulsaciones de teclas que inician el mismo código subyacente.En este momento, los controladores de eventos para cada uno de estos llaman a un método común para realizar la función.

Por lo que he leído, este tipo de acción podría ser manejada por el Patrón de diseño de comando con el beneficio adicional de habilitar/deshabilitar o marcar/desmarcar automáticamente los elementos de la interfaz de usuario.

He estado buscando en la red un buen proyecto de ejemplo, pero realmente no he encontrado ninguno.¿Alguien tiene un buen ejemplo que pueda compartirse?

Answer 1

Primero asegurémonos de saber cuál es el patrón de comando:

El patrón de comando encapsula una solicitud como un objeto y le da una interfaz pública conocida.El patrón de comando garantiza que cada objeto reciba sus propios comandos y proporcione un desacoplamiento entre el remitente y el receptor.Un remitente es un objeto que invoca una operación, y un receptor es un objeto que recibe la solicitud y actúa sobre ella.

Aquí tienes un ejemplo.Hay muchas maneras de hacer esto, pero voy a adoptar un enfoque basado en la interfaz para que el código sea más comprobable para usted.No estoy seguro de qué idioma prefieres, pero estoy escribiendo esto en C#.

Primero, cree una interfaz que describa un comando.

public interface ICommand
{
    void Execute();
}

En segundo lugar, cree objetos de comando que implementarán la interfaz de comando.

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

En tercer lugar, necesitamos configurar nuestro objeto invocador o remitente.

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

Cuarto, cree el objeto de cliente que utilizará el objeto invocador/remitente.

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

Espero que puedas tomar este ejemplo y ponerlo en práctica para la aplicación en la que estás trabajando.Si desea más aclaraciones, hágamelo saber.

Answer 2

Estás en el camino correcto.Básicamente tendrás un modelo que representa el documento.Utilizará este modelo en CutCommand.Querrá cambiar el constructor de CutCommand para aceptar la información que desea cortar.Luego, cada vez que, digamos, se hace clic en el botón Cortar, se invoca un nuevo CutCommand y se pasan los argumentos en el constructor.Luego use esos argumentos en la clase cuando se llame al método Execute.

Answer 3

Pruebe editores .NET de código abierto como SharpDesarrollar o Bloc de notas++.

Hay (naturalmente) cierta discusión sobre el patrón de comando en http://c2.com/cgi/wiki?CommandPattern eso podría ser útil.

Answer 4

Qt usa el patrón de comando para los elementos de la barra de menú/barra de herramientas.

Las QActions se crean por separado de QMenuItem y QToolbar, y las acciones se pueden asignar a QMenuItem y QToolbar con los métodos setAction() y addAction() respectivamente.

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

No puedo ayudarle con un enlace de ejemplo, pero puedo proporcionarle un ejemplo yo mismo.

1) Definir la interfaz ICommand:

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

2) Realice sus implementaciones de ICommand para comandos concretos, pero también defina una clase base abstracta para ellos:

public abstract class WinFormCommand : ICommand {

}

3) Crear invocador de comando:

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) Ahora puede implementar ICommandsBuilder, IButtonDirector y agregar otras interfaces como ICheckBoxDirector a WinFormsCommandInvoker.