Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Visão geral dos comandos

Os comandos são um mecanismo de entrada do Windows Presentation Foundation (WPF), que fornece a entrada e manipulação em um nível mais semântico do que a entrada do dispositivo. São exemplos de comandos as operações Copiar,Recortar e Colar encontradas em muitos aplicativos.

Esta visão geral define quais comandos estão no WPF, quais classes fazem parte do modelo de comando e como usar e criar comandos em seus aplicativos.

Este tópico contém as seguintes seções:

Comandos tem várias finalidades. O primeiro objetivo é separar a semântica e o objeto que chama um comando da lógica que executa este comando. Isso permite que muitas fontes diferentes invoquem a mesma lógica de comando e permite que a lógica de comando seja personalizada para destinos diferentes. Por exemplo, as operações de edição Copiar,Recortar e Colar que se encontram em muitos aplicativos, podem ser chamadas por meio de diferentes ações de usuário se forem implementadas por meio de comandos. Um aplicativo pode permitir que um usuário recorte texto ou objetos selecionados clicando um botão, escolhendo um item em um menu ou usando uma combinação de teclas, como por exemplo, CTRL + X. Usando comandos, você pode ligar cada tipo de ação do usuário para a mesma lógica.

Outro objetivo de comandos é indicar se uma ação está disponível. Para continuar o exemplo de cortar um objeto ou texto, a ação apenas faz sentido quando algo está selecionado. Se um usuário tenta recortar um objeto ou texto sem algum item selecionado, nada deve acontecer. Para indicar isso ao usuário, muitos aplicativos desabilitam itens de menu e botões para que o usuário saiba se é possível executar uma ação. Um comando pode indicar se uma ação é possível ao implementar o método CanExecute. Um botão pode assinar o evento CanExecuteChanged e ser desabilitado se CanExecute retornar false ou habilitado se CanExecute retornartrue.

A semântica de um comando pode ser consistente entre classes e aplicativos, mas a lógica da ação é específica para aquele objeto em que se executou a ação. A combinação de teclas CTRL + X invoca o comando Recortar em classes de texto, imagens e navegadores da Web, mas a lógica real para executar a operação Recortar é definida pelo aplicativo que executa o recorte. Um RoutedCommand permite que os clientes implementem a lógica. Um objeto de texto pode recortar o texto selecionado para a área de transferência, enquanto um objeto de imagem pode cortar a imagem selecionada. Quando um aplicativo trata o evento Executed, ele tem acesso ao destino do comando e pode tomar a ação adequada dependendo do tipo de destino.

A maneira mais simples de se usar um comando WPF é usar uma das classes predefinidas RoutedCommand da biblioteca de classes de comando; usar um controle que tenha suporte nativo para manipular o comando; e usar um controle que tenha suporte nativo para invocar um comando. O comando Paste é um dos comandos predefinidos na classe ApplicationCommands. O controle TextBox tem lógica embutida para manipular o comando Paste. E a classe MenuItem possui suporte nativo para executar comandos.

O exemplo a seguir mostra como configurar um MenuItem de modo que quando ele for clicado ele chamará o comando Paste em um TextBox, supondo que o TextBox tenha o foco de teclado.


<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>



			' Creating the UI objects
			Dim mainStackPanel As New StackPanel()
			Dim pasteTextBox As New TextBox()
			Dim stackPanelMenu As New Menu()
			Dim pasteMenuItem As New MenuItem()

			' Adding objects to the panel and the menu
			stackPanelMenu.Items.Add(pasteMenuItem)
			mainStackPanel.Children.Add(stackPanelMenu)
			mainStackPanel.Children.Add(pasteTextBox)

			' Setting the command to the Paste command
			pasteMenuItem.Command = ApplicationCommands.Paste



// Creating the UI objects
StackPanel mainStackPanel = new StackPanel();
TextBox pasteTextBox = new TextBox();
Menu stackPanelMenu = new Menu();
MenuItem pasteMenuItem = new MenuItem();

// Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem);
mainStackPanel.Children.Add(stackPanelMenu);
mainStackPanel.Children.Add(pasteTextBox);

// Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste;

// Setting the command target to the TextBox
pasteMenuItem.CommandTarget = pasteTextBox;


O modelo de comando roteado em WPF pode ser dividido em quatro conceitos principais: o comando, a fonte do comando, o destino de comando e a vinculação de comando:

  • O comando é a ação a ser executada.

  • A fonte de comando é o objeto que chama o comando.

  • O destino de comando é o objeto em que o comando está sendo executado.

  • A vinculação de comando é o objeto que mapeia a lógica de comando para o comando.

No exemplo anterior, o comando Paste é o comando, MenuItem é a fonte de comando, TextBox é o destino de comando, e a vinculação de comando é fornecida pelo controle TextBox. É importante observar que não é sempre o caso que a CommandBinding é fornecido pelo controle que é a classe de destino de comando. Bastante comumente o CommandBinding deve ser criado pelo desenvolvedor de aplicativos, ou o CommandBinding pode ser anexado a um predecessor do destino de comando.

ms752308.collapse_all(pt-br,VS.110).gifComandos

Comandos em WPF são criados por meio da implementação da interface ICommand. ICommand expõe dois métodos,Execute, e CanExecute e um evento, CanExecuteChanged. Execute executa as ações que estão associadas com o comando. CanExecute determina se o comando pode ser executado no destino atual do comando. CanExecuteChanged é ativado se o gerenciador de comando que centraliza as operações de comando detecta uma alteração na fonte do comando que pode invalidar um comando que foi ativado mas ainda não foi executado pela vinculação de comando. A implementação WPF de ICommand é a classe RoutedCommand e é foco desta visão geral.

As principais fontes da entrada no WPF são o mouse, o teclado, tinta e comandos roteados. As entradas mais orientadas a dispositivos usam um RoutedEvent para notificar objetos em uma página que ocorreu um evento de entrada do aplicativo. Um RoutedCommand não é diferente. Os métodos Execute e CanExecute de um RoutedCommand não contém a lógica do aplicativo para o comando, mas em vez disso, eles geram eventos roteados que são tunelados e borbulhados através da árvore de elemento até que eles encontrem um objeto com um CommandBinding. O CommandBinding contém os manipuladores para esses eventos e são os manipuladores que executam o comando. Para obter mais informações sobre roteamento de Evento WPF, consulte de Visão geral sobre eventos roteados.

O método Execute em um RoutedCommand gera os eventos PreviewExecutedExecuted no destino de comando. O método CanExecute em um RoutedCommand gera os eventos CanExecute e os PreviewCanExecute no destino de comando. Esses eventos são tunelados e borbulhados através da árvore de elementos até encontrar um objeto que tem um CommandBinding para esse comando em particular.

WPF fornece um conjunto de comandos roteados comuns distribuídos por várias classes: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands, e EditingCommands. Essas classes consistem somente de objetos RoutedCommand e não a lógica de implementação do comando. A lógica de implementação é de responsabilidade do objeto no qual o comando está sendo executado.

ms752308.collapse_all(pt-br,VS.110).gifFontes de comando

Uma fonte de comando é o objeto que chama o comando. Exemplos de fontes de comando são MenuItem, Button e KeyGesture.

Fontes de comando no WPF geralmente implementam a interface ICommandSource.

ICommandSource expõe três propriedades: Command, CommandTarget, e CommandParameter:

As classes WPF que implementam ICommandSource são ButtonBase, MenuItem, Hyperlink e InputBinding. ButtonBase, MenuItem e Hyperlink invocam um comando quando eles são clicados, e um InputBinding invoca um comando quando o InputGesture associado a ele é executado.

O seguinte exemplo mostra como usar um MenuItem em um ContextMenu como a fonte de comando para o comando Properties.


<StackPanel>
  <StackPanel.ContextMenu>
    <ContextMenu>
      <MenuItem Command="ApplicationCommands.Properties" />
    </ContextMenu>
  </StackPanel.ContextMenu>
</StackPanel>



			Dim cmdSourcePanel As New StackPanel()
			Dim cmdSourceContextMenu As New ContextMenu()
			Dim cmdSourceMenuItem As New MenuItem()

			' Add ContextMenu to the StackPanel.
			cmdSourcePanel.ContextMenu = cmdSourceContextMenu
			cmdSourcePanel.ContextMenu.Items.Add(cmdSourceMenuItem)

			' Associate Command with MenuItem.
			cmdSourceMenuItem.Command = ApplicationCommands.Properties



StackPanel cmdSourcePanel = new StackPanel();
ContextMenu cmdSourceContextMenu = new ContextMenu();
MenuItem cmdSourceMenuItem = new MenuItem();

// Add ContextMenu to the StackPanel.
cmdSourcePanel.ContextMenu = cmdSourceContextMenu;
cmdSourcePanel.ContextMenu.Items.Add(cmdSourceMenuItem);

// Associate Command with MenuItem.
cmdSourceMenuItem.Command = ApplicationCommands.Properties;


Normalmente, uma fonte de comando escutará o evento CanExecuteChanged. Esse evento informa a fonte de comando que pode ter alterado a capacidade do comando de ser executado no destino de comando atual. A fonte de comando pode consultar o status atual do RoutedCommand usando o método CanExecute. A fonte de comando pode então se desativar se o comando não pode ser executado. Um exemplo disso é um MenuItem ficando cinza quando não é possível executar um comando.

Um InputGesture pode ser usado como uma fonte de comando. Dois tipos de gestos de entrada no WPF são KeyGesture e MouseGesture. Você pode considerar um KeyGesture como um atalho de teclado, sistema autônomo, por exemplo, CTRL + C. Um KeyGesture é composto por um Key e um conjunto de ModifierKeys. Um MouseGesture é composto de um MouseAction e um conjunto opcional de ModifierKeys.

Para um InputGesture agir como uma fonte de comando, ele deve ser associado a um comando. Há algumas maneiras para fazer isso. Uma maneira é usar um InputBinding.

O exemplo a seguir mostra como criar um KeyBinding entre um KeyGesture e um RoutedCommand.


<Window.InputBindings>
  <KeyBinding Key="B"
              Modifiers="Control" 
              Command="ApplicationCommands.Open" />
</Window.InputBindings>



			Dim OpenKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

			Dim OpenCmdKeybinding As New KeyBinding(ApplicationCommands.Open, OpenKeyGesture)

			Me.InputBindings.Add(OpenCmdKeybinding)



KeyGesture OpenKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

KeyBinding OpenCmdKeybinding = new KeyBinding(
    ApplicationCommands.Open,
    OpenKeyGesture);

this.InputBindings.Add(OpenCmdKeybinding);


Outra maneira para associar um InputGesture a um RoutedCommand é adicionar a InputGesture ao InputGestureCollection no RoutedCommand.

O exemplo a seguir mostra como adicionar um KeyGesture a InputGestureCollection de um RoutedCommand.


KeyGesture OpenCmdKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture);


ms752308.collapse_all(pt-br,VS.110).gifCommandBinding

Um CommandBinding associa um comando com os manipuladores de eventos que implementam o comando.

A classe CommandBinding contém uma propriedade Command e os eventos PreviewExecuted, Executed, PreviewCanExecute e CanExecute.

Command é o comando que o CommandBinding está sendo associado. Os manipuladores de eventos que estão conectados aos eventos PreviewExecuted e Executed implementam a lógica de comando. Os manipuladores de evento anexados aos eventos PreviewCanExecute e CanExecute determinam se o comando pode executar no destino de comando atual.

O exemplo a seguir mostra como criar um CommandBinding na Window raiz de um aplicativo. O CommandBinding associa o comando Open com os manipuladores de Executed e CanExecute.


<Window.CommandBindings>
  <CommandBinding Command="ApplicationCommands.Open"
                  Executed="OpenCmdExecuted"
                  CanExecute="OpenCmdCanExecute"/>
</Window.CommandBindings>



			' Creating CommandBinding and attaching an Executed and CanExecute handler
			Dim OpenCmdBinding As New CommandBinding(ApplicationCommands.Open, AddressOf OpenCmdExecuted, AddressOf OpenCmdCanExecute)

			Me.CommandBindings.Add(OpenCmdBinding)



// Creating CommandBinding and attaching an Executed and CanExecute handler
CommandBinding OpenCmdBinding = new CommandBinding(
    ApplicationCommands.Open,
    OpenCmdExecuted,
    OpenCmdCanExecute);

this.CommandBindings.Add(OpenCmdBinding);


Depois, o ExecutedRoutedEventHandler e o CanExecuteRoutedEventHandler são criados. O ExecutedRoutedEventHandler abre um MessageBox que exibe uma sequência de caracteres informando que o comando foi executado. O CanExecuteRoutedEventHandler define a propriedade CanExecute para true.


Private Sub OpenCmdExecuted(ByVal sender As Object, ByVal e As ExecutedRoutedEventArgs)
    Dim command, targetobj As String
    command = CType(e.Command, RoutedCommand).Name
    targetobj = CType(sender, FrameworkElement).Name
    MessageBox.Show("The " + command + " command has been invoked on target object " + targetobj)
End Sub



void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
{
    String command, targetobj;
    command = ((RoutedCommand)e.Command).Name;
    targetobj = ((FrameworkElement)target).Name;
    MessageBox.Show("The " + command +  " command has been invoked on target object " + targetobj);
}



Private Sub OpenCmdCanExecute(ByVal sender As Object, ByVal e As CanExecuteRoutedEventArgs)
    e.CanExecute = True
End Sub



void OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;
}


Um CommandBinding está conectado a um objeto específico, como o controle Window raiz de um aplicativo ou outro controle. O objeto a que CommandBinding está anexado define o escopo da ligação. Por exemplo, um CommandBinding anexado a um predecessor do destino de comando pode ser alcançado pelo evento Executed, mas um CommandBinding anexado a um descendente do comando de destino não pode ser alcançado. Esta é uma consequência direta da maneira como um RoutedEvent é tunelado e borbulhado a partir do objeto que gera o evento.

Em algumas situações o CommandBinding está conectado ao destino de comando em si, como na classe TextBox e nos comandos Cut, Copy e Paste. Bem frequentemente, no entanto, é mais conveniente anexar o CommandBinding a um predecessor do destino de comando, como a Window principal ou o objeto Application, especialmente se o mesmo CommandBinding puder ser usado para vários destinos de comando. Estas são decisões de projeto que você desejará considerar quando você estiver criando a infra-estrutura de comandos.

ms752308.collapse_all(pt-br,VS.110).gifDestino de Comando

O destino de comando é o elemento no qual o comando é executado. Com relação aos RoutedCommand, o destino de comando é o elemento no qual o roteamento de Executed e CanExecute inicia. Conforme observado anteriormente, em WPF a propriedade CommandTarget no ICommandSource só é aplicável quando o ICommand é um RoutedCommand. Se o CommandTarget é definido em um ICommandSource e o comando correspondente não é um RoutedCommand, o destino de comando é ignorado.

A fonte de comando pode explicitamente definir o destino de comando. Se o destino de comando não estiver definido, o elemento com o foco do teclado será o destino de comando. Uma das vantagens de usar o elemento com o foco do teclado como o destino de comando é que ele permite ao desenvolvedor do aplicativo usar a mesma fonte de comando para invocar um comando em vários destinos sem ter que manter o controle de destino de comando. Por exemplo, se um MenuItem chama o comando Colar em um aplicativo que tenha um controle TextBox e um controle PasswordBox, o destino pode ser o TextBox ou o PasswordBox dependendo de qual controle tem o foco do teclado.

O exemplo a seguir mostra como definir explicitamente o destino de comando na marcação e no código.


<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste"
              CommandTarget="{Binding ElementName=mainTextBox}" />
  </Menu>
  <TextBox Name="mainTextBox"/>
</StackPanel>



			' Creating the UI objects
			Dim mainStackPanel As New StackPanel()
			Dim pasteTextBox As New TextBox()
			Dim stackPanelMenu As New Menu()
			Dim pasteMenuItem As New MenuItem()

			' Adding objects to the panel and the menu
			stackPanelMenu.Items.Add(pasteMenuItem)
			mainStackPanel.Children.Add(stackPanelMenu)
			mainStackPanel.Children.Add(pasteTextBox)

			' Setting the command to the Paste command
			pasteMenuItem.Command = ApplicationCommands.Paste



// Creating the UI objects
StackPanel mainStackPanel = new StackPanel();
TextBox pasteTextBox = new TextBox();
Menu stackPanelMenu = new Menu();
MenuItem pasteMenuItem = new MenuItem();

// Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem);
mainStackPanel.Children.Add(stackPanelMenu);
mainStackPanel.Children.Add(pasteTextBox);

// Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste;

// Setting the command target to the TextBox
pasteMenuItem.CommandTarget = pasteTextBox;


ms752308.collapse_all(pt-br,VS.110).gifO CommandManager

O CommandManager serve um número de funções relacionadas a comando. Ele fornece um conjunto de métodos estáticos para adicionar e remover manipuladores de eventos PreviewExecuted, Executed, PreviewCanExecute e CanExecute para e de um elemento específico. Ele fornece um meio para registrar objetos CommandBinding e InputBinding em uma classe específica. O CommandManager também fornece um meio, por meio do evento RequerySuggested, para notificar um comando quando ele deve gerar o evento CanExecuteChanged.

O método InvalidateRequerySuggested força o CommandManager a gerar o evento RequerySuggested. Isso é útil em condições que devem desativar/ativar um comando mas não o são condições em que o CommandManager está ciente disto.

O WPF fornece um conjunto de comandos predefinidos. A biblioteca de comandso consiste das classes a seguir: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommands e ComponentCommands. Essas classes fornecem comandos como Cut, BrowseBack e BrowseForward, Play, Stop e Pause.

Muitos desses comandos incluem um conjunto de ligações de entrada padrão. Por exemplo, se você especificar que o seu aplicativo lida com o comando Copiar, você obtém automaticamente a vincualção de teclado "CTRL + C" Você também obtém vinculações para outros dispositivos de entrada, como por exemplo gestos da caneta TabletPC e informações de fala.

Quando você faz referência a comandos nas várias bibliotecas de comando usando XAML, geralmente você pode omitir a nome da classe da classe da biblioteca que expõe a propriedade estática do comando. Geralmente, os nomes de comando são não ambíguos como sequências de caracteres, e os tipos pai existem para fornecer um agrupamento lógico de comandos, e não necessariamente para eliminar ambiguidades. Por exemplo, você pode especificar Command="Cut" em vez de Command="ApplicationCommands.Cut" mais detalhado. Este é um mecanismo de conveniência embutido no processador WPF XAML para comandos (mais precisamente, ele é um comportamento de conversão de tipos de ICommand, que o WPF XAML processador faz referência em tempo de carregamento).

Se os comandos na biblioteca de classes de comando não atenderem às suas necessidades, então você pode criar seus próprios comandos. Há duas maneiras para criar um comando personalizado. A primeira é iniciar do zero e implementar a interface ICommand. A outra maneira e a abordagem mais comum, é criar um RoutedCommand ou um RoutedUICommand.

Para obter um exemplo de criação de um RoutedCommand personalizado, consulte o Criar Personalizada exemplo RoutedCommand .

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2015 Microsoft