Padrão Command

Padrão Command

  junho 09, 2016    Ana Paula Novello

---

Introdução

Este padrão possibilita que partes do programa sejam encapsuladas em pequenas classes de comandos que serão executadas através de um invocador de comandos.

Técnicas de encapsulamento (É o ato de proteger algo) ajudam você a criar um sistema fechado contra erros e ao mesmo tempo aberto para expansão. Haverá uma integração maior entre as partes do programa, pois o encapsulamento juntamente com o Padrão Command permite que estas partes se comuniquem sem saber o que realmente cada uma faz.

Estrutura

O cliente que cria um comando não é o mesmo cliente que executa-lo. Esta separação fornece flexibilidade na programação e sucessão dos comandos. Materializando comandos como objetos significa que eles podem ser passados, encenado, compartilhado, carregado em uma tabela e, em caso contrário, instrumentado ou manipulados como qualquer outro objeto.

O objetos de comando pode ser pensado como "fichas" que são criados por um cliente que sabe o que precisa ser feito, e passou para outro cliente que tem os recursos para fazê-lo.

Exemplo

O padrão Command permite que as solicitações a serem encapsulados como objetos, permitindo assim que os clientes para ser parametrizado com diferentes solicitações. O "Pedido" em um restaurante é um exemplo de um padrão de comando. O garçom/garçonete leva uma ordem ou comando a partir de um cliente e encapsula essa ordem, escrevendo-o no “Pedido”. A ordem é então colocado em fila para uma execução. Note-se que a fila de "Pedidos" utilizados por cada garçom não é dependente do menu, e, portanto, eles podem suportar comandos para cozinhar muitos “Pedidos” diferentes.

Check list
1. Definir uma interface de comando com uma assinatura método como execute ().
2. Criar uma ou mais classes derivadas que encapsulam um subconjunto dos seguintes: um “receptor" objeto, o método para invocar, os argumentos para passar.
3. Instanciar um objeto de comando para cada pedido de execução diferida.
4. Passe o objeto de comando do criador (aka remetente) para o invocador (aka receptor).
5. O solicitante decide quando execute ().

Vamos fazer um pequeno exemplo de um aplicativo que irá ler XML e CSV

TDocumentCommand = class(TObject)
private
  FDocument : TDocument;
protected
  procedure DoExecute; virtual; abstract;
  procedure DoRollback; virtual;
 
  // Used Self Encapsulate Field refactoring here. Now descendant commands
  // can access the document, even if they are declared in other units
  property Document : TDocument read FDocument write FDocument;
public
  constructor Create(ADocument : TDocument);
 
  procedure Execute;
  procedure Rollback; // Reverse effect of Execute
end;

The implementation is: 
constructor TDocumentCommand.Create(ADocument : TDocument);
begin
  inherited Create;
  FDocument := ADocument;
end;

procedure TDocumentCommand.DoRollback;
begin
end;

procedure TDocumentCommand.Execute;
begin
  if Assigned(FDocument) then begin
    DoExecute;
  end;
end;

procedure TDocumentCommand.Rollback;
begin
  if Assigned(FDocument) then begin
    DoRollback;
  end;
end;

Vamos examinar o que está acontecendo aqui. Temos dois métodos públicos, um para executar um comando, e outro para revertê-lo. Note-se que estes dois métodos de verificação para ver se o documento está disponível antes de chamar outra, protegido, método. Este é um exemplo muito simples de que a configuração padrão. Nós não queremos que os programadores que estão a implementar novos comandos precisam ter que se lembrar de fazer isso, então vamos fazer por eles aqui, e eles precisam para substituir os métodos DoExecute e DoRollback vez.

A implementação do método DoRollback está vazia porque um comando pode não ser capaz de ser desfeita (que está indo só para apoiar esta na impressão procurar e substituir), então nós não queremos forçar subclasses para implementá-lo, tornando o método abstrato. No entanto, nós queremos o comando a ser executado, então o método DoExecute é abstrato para forçá-lo a ser substituído.

O construtor obtém o documento transmitido com um parâmetro, e que irá ser utilizada como o receptor no nosso exemplo. Por exemplo, o comando Abrir é implementado da seguinte forma:

procedure TOpenCommand.DoExecute;
  var
    FileName : string;
begin
  if PromptForFileName(FileName,'XML files (*.xml)|*.xml|CSV files (*.csv)|*.csv') then begin
    FDocument.OpenFile(FileName);
  end;
end;

Aqui chamamos a função PromptForFileName Delphi, e se o usuário não cancelar a operação, chamamos o método OpenFile do documento para carregar o texto. Para outros comandos, ele fica um pouco mais complexo, e começamos a ver as vantagens de separar a lógica de comando para fora do objeto que o invoca.

Outras vantagens é fácil para adicionar novos comandos, porque as classes existentes não precisam mudar. Isto o torna um menor modificação risco para o seu código.