.net - programacion - Buscando un ejemplo de patrón de comando para la interfaz de usuario

manual de programacion android pdf

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 de menú y 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 manejado por el patrón de diseño de Comando con el beneficio adicional de habilitar / deshabilitar automáticamente o marcar / desmarcar los elementos de la UI.

He estado buscando en la red un buen ejemplo de proyecto, pero realmente no he encontrado uno. ¿Alguien tiene un buen ejemplo que se puede compartir?

Answer 1

Primero asegurémonos de saber qué es el patrón Command:

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

Aquí hay un ejemplo para ti. Hay muchas maneras en que puede hacerlo, pero voy a tomar un enfoque de base de interfaz para que el código sea más comprobable para usted. No estoy seguro de qué idioma prefiere, pero estoy escribiendo esto en C #.

Primero, crea una interfaz que describa un comando.

public interface ICommand
{
    void Execute();
}

Segundo, crea 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, tenemos que configurar nuestro objeto invocador o remitente.

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

En cuarto lugar, crea el objeto del cliente que usará el objeto invocador / emisor.

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

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

Answer 2

Pruebe los editores .NET de código abierto como SharpDevelop o Notepad ++ .

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

Answer 3

Estás en el camino correcto. Básicamente, tendrá un modelo que representa el documento. Usará este modelo en CutCommand. Deseará cambiar el constructor de CutCommand para que acepte la información que desea cortar. Luego, cada vez que haga clic en el botón Cortar, invocará un nuevo CutCommand y pasará los argumentos en el constructor. Luego use esos argumentos en la clase cuando se llama al método Execute.

Answer 4

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

Las QAcciones 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 ayudarte con un enlace de ejemplo, pero puedo proporcionar un ejemplo por mi cuenta.

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 comando invocador:

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