Olá Pessoal! Hoje falaremos de mais uma parte importante dentro da arquitetura WPF: os comandos roteados.

Os comandos roteados são recursos que o WPF introduz para que você possa conectar controles de interface de usuário à manipuladores (métodos), que irão executar alguma ação ao serem invocados sem que haja um alto acoplamento e sem a necessidade de uma dependência rígida de um para com o outro.

Você pode conectar controles como botões, menus ou qualquer outro controle de interface de usuário a comandos roteados. Os comandos roteados possuem três características comuns que estão descritas abaixo:

1. Elementos chamadores do comando são desassociados do manipulador do comando. Você não precisa ter uma referência direta entre ambos, como no caso de eventos roteados. Aí está a causa do baixo acoplamento já que eles não possuem dependência entre si, garantindo assim o baixo acoplamento.
2. Comandos roteados irão habilitar ou desabilitar controles da tela, de acordo com o manipulador de comando. É o manipulador deste quem vai indicar se o comando pode ser executado ou não.
3. Comandos roteados vão poder associar atalhos do teclado à manipuladores de comando, ou até mesmo outras entradas do usuário.

Para utilizar comandos roteados, você precisa apenas definir a propriedade Command do controle chamador. Observe o exemplo abaixo:

<Button Command="ApplicationCommands.Save">Save</Button>

Viu como é simples? A propriedade Command é suportada por controles como Button, Menu, RadioButton entre outros. Você pode ainda definir um elemento manipulador, utilizando o CommandBinding:

<Window ...>
  <Window.CommandBindings>
    <CommandBinding Command="ApplicationCommands.Save"    
      CanExecute="OnCanExecute" Executed="OnExecute"/>
  </Window.CommandBindings>
  ...
</Window>

Note que o CommandBinding possui dois membros CanExecute e Executed. CanExecute é a uma propriedade boleana, que indica se o comando pode ou não ser executado, ou seja, se o mesmo está ou não habilitado. Já o método Executed é onde você executa o comando propriamente dito.

Comandos em ação

Observe o código XAML abaixo:

Rodando uma aplicação com o código acima, você irá  ver que qualquer texto digitado em uma das caixas pode ser recortado ao clicar no botão. Isto se deve ao comando definido na propriedade Command, e na mesma ainda é definido um comando padrão do WPF, o Cut.

Note que o botão apenas faz referência ao Command. Ele não tem nenhum conhecimento da implamentação do mesmo e isto é até uma maneira de manter um baixo acoplamento.

Se a implementação do comando Cut mudar, isto não irá afetar quem faz referência ao comando, desde que continue a realizar a ação de cortar. Observe que enquanto você não selecionar algum texto, o botão estará desablitado. O comando só pode ser executado se houver um texto selecionado, entrando em ação assim a propriedade CanExecute.

Roteamento

Os comandos também são roteados porque são utilizados eventos roteados para enviar mensagens entre os manipuladores de comando e chamadores de comando dentro da árvore visual.

Apenas um manipulador de comandos é ativo. Isto acontece porque é possível ter uma relação de vários chamadores para vários manipuladores. Nesta etapa entram os eventos roteados, porque os mesmos são utilizados para encontrar o manipulador, identificar se o comando pode ser executado e executar o mesmo.

Definição de comando

Comandos roteados são definidos pela implementação da interface ICommand, que tem a seguinte definição:

public interface ICommand {
    event EventHandler CanExecuteChanged;
    bool CanExecute(object parameter);
    void Execute(object parameter);
  }

De quem implementa esta interface, espera-se que utilize a propriedade CanExecute para determinar se algum código de invocação do comando está ou não habilitado para fazê-lo.

É através do evento CanExecuteChanged que o chamador do comando poderá determinar quando invocar o método que será executado. Já o método Executed é chamado quando o comando é invocado e o mesmo é despachado ao manipulador do comando através do evento roteado, que percorre a árvore visual para encontrá-lo.

Os controles que tem suporte a propriedade Command. Isso acontece porque os controles implementam a interface ICommandSource. A interface ICommandSource tem a definição abaixo:

public interface ICommandSource {
  ICommand Command { get; }
  object CommandParameter { get; }
  InputElement CommandTarget { get; }
}

Após conferir a definição da interface ICommand, a propriedade Command associa o chamador ao comando que ele irá invocar.

Esse é mais um passo para aprender sobre o WPF e comando roteados para inúmeros fins. Espero ter ajudado nesta etapa e que vocês possam se aprofundar na arquitetura do WPF para tirar proveito desta excelente tecnologia.

Um forte abraço e até a próxima!