Visão geral dos comandosCommanding Overview

Os comandos são um mecanismo de entrada do Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) que oferecem manipulação de entrada em um nível mais semântico do que a entrada do dispositivo.Commanding is an input mechanism in Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) which provides input handling at a more semantic level than device input. Os exemplos de comandos são as operações Copiar, Recortar e Colar, encontradas em muitos aplicativos.Examples of commands are the Copy, Cut, and Paste operations found on many applications.

Esta visão geral define quais comandos estão no WPFWPF, quais classes fazem parte do modelo de comandos e como utilizar e criar comandos nos seus aplicativos.This overview defines what commands are in WPFWPF, which classes are part of the commanding model, and how to use and create commands in your applications.

Esse tópico contém as seguintes seções:This topic contains the following sections:

O que são comandos?What Are Commands?

Os comandos têm várias finalidades.Commands have several purposes. A primeira finalidade é separar a semântica e o objeto que invoca um comando da lógica que o executa.The first purpose is to separate the semantics and the object that invokes a command from the logic that executes the command. Isso permite que fontes múltiplas e distintas invoquem a mesma lógica de comando, além de permitir que a lógica de comando seja personalizada para destinos diferentes.This allows for multiple and disparate sources to invoke the same command logic, and it allows the command logic to be customized for different targets. Por exemplo, as operações de edição Copiar, Recortar e Colar, que são encontradas em muitos aplicativos, podem ser invocadas por meio de ações do usuário diferentes se forem implementadas por meio do uso de comandos.For example, the editing operations Copy, Cut, and Paste, which are found in many applications, can be invoked by using different user actions if they are implemented by using commands. Um aplicativo pode permitir que um usuário recorte texto ou objetos selecionados ao clicar em um botão, escolher um item em um menu ou usar uma combinação de teclas, como CTRL+X.An application might allow a user to cut selected objects or text by either clicking a button, choosing an item in a menu, or using a key combination, such as CTRL+X. Usando comandos, é possível associar cada tipo de ação do usuário à mesma lógica.By using commands, you can bind each type of user action to the same logic.

Outra finalidade dos comandos é indicar se uma ação está disponível.Another purpose of commands is to indicate whether an action is available. Para continuar o exemplo de recortar um objeto ou texto, a ação só faz sentido quando algo está selecionado.To continue the example of cutting an object or text, the action only makes sense when something is selected. Se um usuário tentar recortar um objeto ou texto sem ter selecionado alguma coisa, nada acontece.If a user tries to cut an object or text without having anything selected, nothing would happen. Para indicar isso para o usuário, muitos aplicativos desabilitam botões e itens de menu para indicar se é possível executar uma ação.To indicate this to the user, many applications disable buttons and menu items so that the user knows whether it is possible to perform an action. Um comando pode indicar se uma ação é possível implementar a CanExecute método.A command can indicate whether an action is possible by implementing the CanExecute method. Um botão pode assinar o CanExecuteChanged eventos e ser desabilitado se CanExecute retorna false ou ser ativado se CanExecute retorna true.A button can subscribe to the CanExecuteChanged event and be disabled if CanExecute returns false or be enabled if CanExecute returns true.

A semântica de um comando pode ser consistente entre aplicativos e classes; porém, a lógica da ação é específica para o objeto específico da ação.The semantics of a command can be consistent across applications and classes, but the logic of the action is specific to the particular object acted upon. A combinação de teclas CTRL+X invoca o comando Recortar em classes de texto, classes de imagens e navegadores da Web, enquanto a lógica real para executar a operação Recortar é definida pelo aplicativo que faz o recorte.The key combination CTRL+X invokes the Cut command in text classes, image classes, and Web browsers, but the actual logic for performing the Cut operation is defined by the application that performs the cut. Um RoutedCommand permite que os clientes implementar a lógica.A RoutedCommand enables clients to implement the logic. Um objeto de texto poderá recortar o texto selecionado na área de transferência, enquanto um objeto de imagem poderá recortar a imagem selecionada.A text object may cut the selected text into the clipboard, while an image object may cut the selected image. Quando um aplicativo manipula o Executed evento, ele tem acesso para o destino do comando e pode levar a ação apropriada dependendo do tipo de destino.When an application handles the Executed event, it has access to the target of the command and can take appropriate action depending on the target's type.

Exemplo de comando simples no WPFSimple Command Example in WPF

A maneira mais simples para usar um comando WPFWPF é usar um modelo predefinido RoutedCommand de uma das classes de biblioteca de comando; use um controle que tem o suporte nativo para tratar o comando; e usar um controle que tem o suporte nativo para invocar um comando.The simplest way to use a command in WPFWPF is to use a predefined RoutedCommand from one of the command library classes; use a control that has native support for handling the command; and use a control that has native support for invoking a command. O Paste comando é um dos comandos predefinidos na ApplicationCommands classe.The Paste command is one of the predefined commands in the ApplicationCommands class. O TextBox controle criado na lógica para manipular o Paste comando.The TextBox control has built in logic for handling the Paste command. E o MenuItem classe tem suporte nativo para chamar comandos.And the MenuItem class has native support for invoking commands.

O exemplo a seguir mostra como configurar um MenuItem para que, quando ele for clicado ele chamará o Paste comando em uma TextBox, supondo que o TextBox tem o foco do teclado.The following example shows how to set up a MenuItem so that when it is clicked it will invoke the Paste command on a TextBox, assuming the TextBox has keyboard focus.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>
// 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;
' 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

Quatro conceitos principais em comandos do WPFFour Main Concepts in WPF Commanding

O modelo de comando roteado no WPFWPF pode ser dividido em quatro conceitos principais: o comando, a fonte do comando, o destino do comando e a associação do comando:The routed command model in WPFWPF can be broken up into four main concepts: the command, the command source, the command target, and the command binding:

  • O comando é a ação que será executada.The command is the action to be executed.

  • A fonte do comando é o objeto que invoca o comando.The command source is the object which invokes the command.

  • O destino do comando é o objeto no qual o comando está sendo executado.The command target is the object that the command is being executed on.

  • A associação do comando é o objeto que mapeia a lógica de comando até o comando.The command binding is the object which maps the command logic to the command.

No exemplo anterior, o Paste comando é o comando, o MenuItem é a origem de comando, o TextBox é o destino de comando, e a associação de comando é fornecida pelo TextBox controle.In the previous example, the Paste command is the command, the MenuItem is the command source, the TextBox is the command target, and the command binding is supplied by the TextBox control. Vale a pena observar que não é sempre o caso que a CommandBinding é fornecido pelo controle que é a classe de destino do comando.It is worth noting that it is not always the case that the CommandBinding is supplied by the control that is the command target class. Com muita frequência, o CommandBinding devem ser criadas pelo desenvolvedor de aplicativos, ou o CommandBinding pode ser anexado a um predecessor do destino de comando.Quite often the CommandBinding must be created by the application developer, or the CommandBinding might be attached to an ancestor of the command target.

ComandosCommands

Comandos em WPFWPF são criados Implementando a ICommand interface.Commands in WPFWPF are created by implementing the ICommand interface. ICommand apresenta dois métodos, Execute, e CanExecutee um evento CanExecuteChanged.ICommand exposes two methods, Execute, and CanExecute, and an event, CanExecuteChanged. Execute executa as ações que estão associadas com o comando.Execute performs the actions that are associated with the command. CanExecute Determina se o comando pode executar no destino de comando atual.CanExecute determines whether the command can execute on the current command target. CanExecuteChanged é gerado se o Gerenciador de comando que centraliza as operações de comando detecta uma alteração na fonte de comando que pode invalidar um comando que foi gerado, mas ainda não foi executado pela associação de comando.CanExecuteChanged is raised if the command manager that centralizes the commanding operations detects a change in the command source that might invalidate a command that has been raised but not yet executed by the command binding. O WPFWPF implementação de ICommand é o RoutedCommand de classe e é o foco desta visão geral.The WPFWPF implementation of ICommand is the RoutedCommand class and is the focus of this overview.

As principais fontes de entrada no WPFWPF são o mouse, o teclado, tinta e comandos roteados.The main sources of input in WPFWPF are the mouse, the keyboard, ink, and routed commands. As entradas mais orientadas a dispositivos usam um RoutedEvent para notificar objetos em uma página de aplicativo que ocorreu um evento de entrada.The more device-oriented inputs use a RoutedEvent to notify objects in an application page that an input event has occurred. Um RoutedCommand não é diferente.A RoutedCommand is no different. O Execute e CanExecute métodos de um RoutedCommand não contêm a lógica do aplicativo para o comando, mas em vez disso, eles geram eventos roteados que túnel e de bolhas por meio da árvore de elementos até que eles encontrem um objeto com um CommandBinding.The Execute and CanExecute methods of a RoutedCommand do not contain the application logic for the command, but rather they raise routed events that tunnel and bubble through the element tree until they encounter an object with a CommandBinding. O CommandBinding contém os manipuladores para esses eventos e são os manipuladores que executam o comando.The CommandBinding contains the handlers for these events and it is the handlers that perform the command. Para obter mais informações sobre o roteamento de eventos no WPFWPF, consulte Visão geral de eventos roteados.For more information on event routing in WPFWPF, see Routed Events Overview.

O Execute método em um RoutedCommand gera o PreviewExecuted e Executed eventos no destino de comando.The Execute method on a RoutedCommand raises the PreviewExecuted and the Executed events on the command target. O CanExecute método em um RoutedCommand gera o CanExecute e PreviewCanExecute eventos no destino de comando.The CanExecute method on a RoutedCommand raises the CanExecute and PreviewCanExecute events on the command target. Esses túnel de eventos e de bolhas por meio da árvore de elementos até que eles encontrem um objeto que tem um CommandBinding para esse comando específico.These events tunnel and bubble through the element tree until they encounter an object which has a CommandBinding for that particular command.

WPFWPF Fornece um conjunto de comandos roteados comuns espalhado entre várias classes: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands, e EditingCommands. supplies a set of common routed commands spread across several classes: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands, and EditingCommands. Essas classes consistem apenas o RoutedCommand objetos e não a lógica de implementação do comando.These classes consist only of the RoutedCommand objects and not the implementation logic of the command. A lógica de implementação é de responsabilidade do objeto no qual o comando está sendo executado.The implementation logic is the responsibility of the object on which the command is being executed on.

Fontes de comandoCommand Sources

Uma fonte do comando é o objeto que invoca o comando.A command source is the object which invokes the command. Exemplos de fontes de comando são MenuItem, Button, e KeyGesture.Examples of command sources are MenuItem, Button, and KeyGesture.

Fontes de comando no WPFWPF geralmente implementa o ICommandSource interface.Command sources in WPFWPF generally implement the ICommandSource interface.

ICommandSource expõe três propriedades: Command, CommandTarget, e CommandParameter:ICommandSource exposes three properties: Command, CommandTarget, and CommandParameter:

O WPFWPF as classes que implementam ICommandSource são ButtonBase, MenuItem, Hyperlink, e InputBinding.The WPFWPF classes that implement ICommandSource are ButtonBase, MenuItem, Hyperlink, and InputBinding. ButtonBase, MenuItem, e Hyperlink invocar um comando quando eles são clicados e uma InputBinding invoca um comando quando o InputGesture associado é realizado.ButtonBase, MenuItem, and Hyperlink invoke a command when they are clicked, and an InputBinding invokes a command when the InputGesture associated with it is performed.

O exemplo a seguir mostra como usar um MenuItem em uma ContextMenu como uma fonte de comando para o Properties comando.The following example shows how to use a MenuItem in a ContextMenu as a command source for the Properties command.

<StackPanel>
  <StackPanel.ContextMenu>
    <ContextMenu>
      <MenuItem Command="ApplicationCommands.Properties" />
    </ContextMenu>
  </StackPanel.ContextMenu>
</StackPanel>
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;
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

Normalmente, uma fonte de comando escutará o CanExecuteChanged evento.Typically, a command source will listen to the CanExecuteChanged event. Esse evento informa à fonte de comando que a capacidade do comando de executar o destino do comando atual pode ter sido alterada.This event informs the command source that the ability of the command to execute on the current command target may have changed. A fonte de comando pode consultar o status atual do RoutedCommand usando o CanExecute método.The command source can query the current status of the RoutedCommand by using the CanExecute method. Em seguida, ela poderá ser desabilitada se não for possível executar o comando.The command source can then disable itself if the command cannot execute. Um exemplo disso é um MenuItem se retirando quando não é possível executar um comando.An example of this is a MenuItem graying itself out when a command cannot execute.

Um InputGesture pode ser usado como uma fonte de comando.An InputGesture can be used as a command source. Dois tipos de gestos de entrada no WPFWPF são o KeyGesture e MouseGesture.Two types of input gestures in WPFWPF are the KeyGesture and MouseGesture. Você pode pensar um KeyGesture como um atalho de teclado, como CTRL + C.You can think of a KeyGesture as a keyboard shortcut, such as CTRL+C. Um KeyGesture é composta de uma Key e um conjunto de ModifierKeys.A KeyGesture is comprised of a Key and a set of ModifierKeys. Um MouseGesture é composta de uma MouseAction e um conjunto opcional de ModifierKeys.A MouseGesture is comprised of a MouseAction and an optional set of ModifierKeys.

Para que um InputGesture para agir como uma fonte de comando, ele deve ser associado um comando.In order for an InputGesture to act as a command source, it must be associated with a command. Existem algumas maneiras de fazer isso.There are a few ways to accomplish this. Uma maneira é usar um InputBinding.One way is to use an InputBinding.

O exemplo a seguir mostra como criar um KeyBinding entre um KeyGesture e um RoutedCommand.The following example shows how to create a KeyBinding between a KeyGesture and a RoutedCommand.

<Window.InputBindings>
  <KeyBinding Key="B"
              Modifiers="Control" 
              Command="ApplicationCommands.Open" />
</Window.InputBindings>
KeyGesture OpenKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

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

this.InputBindings.Add(OpenCmdKeybinding);
Dim OpenKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

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

Me.InputBindings.Add(OpenCmdKeybinding)

Outra maneira de associar um InputGesture para um RoutedCommand é adicionar a InputGesture para o InputGestureCollection no RoutedCommand.Another way to associate an InputGesture to a RoutedCommand is to add the InputGesture to the InputGestureCollection on the RoutedCommand.

O exemplo a seguir mostra como adicionar um KeyGesture para o InputGestureCollection de um RoutedCommand.The following example shows how to add a KeyGesture to the InputGestureCollection of a RoutedCommand.

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

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture);
Dim OpenCmdKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture)

CommandBindingCommandBinding

Um CommandBinding associa um comando com os manipuladores de eventos que implementam o comando.A CommandBinding associates a command with the event handlers that implement the command.

O CommandBinding classe contém um Command propriedade e PreviewExecuted, Executed, PreviewCanExecute, e CanExecute eventos.The CommandBinding class contains a Command property, and PreviewExecuted, Executed, PreviewCanExecute, and CanExecute events.

Command o comando que o CommandBinding está sendo associado.Command is the command that the CommandBinding is being associated with. Os manipuladores de eventos que são anexados para o PreviewExecuted e Executed eventos implementam a lógica de comando.The event handlers which are attached to the PreviewExecuted and Executed events implement the command logic. Os manipuladores de eventos anexados para o PreviewCanExecute e CanExecute eventos determinam se o comando pode executar o destino do comando atual.The event handlers attached to the PreviewCanExecute and CanExecute events determine if the command can execute on the current command target.

O exemplo a seguir mostra como criar um CommandBinding na raiz Window de um aplicativo.The following example shows how to create a CommandBinding on the root Window of an application. O CommandBinding associa o Open com Executed e CanExecute manipuladores.The CommandBinding associates the Open command with Executed and CanExecute handlers.

<Window.CommandBindings>
  <CommandBinding Command="ApplicationCommands.Open"
                  Executed="OpenCmdExecuted"
                  CanExecute="OpenCmdCanExecute"/>
</Window.CommandBindings>
// Creating CommandBinding and attaching an Executed and CanExecute handler
CommandBinding OpenCmdBinding = new CommandBinding(
    ApplicationCommands.Open,
    OpenCmdExecuted,
    OpenCmdCanExecute);

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

Me.CommandBindings.Add(OpenCmdBinding)

Em seguida, o ExecutedRoutedEventHandler e um CanExecuteRoutedEventHandler são criados.Next, the ExecutedRoutedEventHandler and a CanExecuteRoutedEventHandler are created. O ExecutedRoutedEventHandler abre uma MessageBox que exibe uma cadeia de caracteres indicando que o comando foi executado.The ExecutedRoutedEventHandler opens a MessageBox that displays a string saying the command has been executed. O CanExecuteRoutedEventHandler define o CanExecute propriedade true.The CanExecuteRoutedEventHandler sets the CanExecute property to true.

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 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 OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;
}
Private Sub OpenCmdCanExecute(ByVal sender As Object, ByVal e As CanExecuteRoutedEventArgs)
    e.CanExecute = True
End Sub

Um CommandBinding está anexado a um objeto específico, como a raiz Window do aplicativo ou um controle.A CommandBinding is attached to a specific object, such as the root Window of the application or a control. O objeto que o CommandBinding é anexado define o escopo da associação.The object that the CommandBinding is attached to defines the scope of the binding. Por exemplo, um CommandBinding anexado a um predecessor do comando destino pode ser alcançado pelo Executed evento, mas um CommandBinding anexado a um descendente do comando de destino não pode ser alcançado.For example, a CommandBinding attached to an ancestor of the command target can be reached by the Executed event, but a CommandBinding attached to a descendant of the command target cannot be reached. Esta é uma consequência direta da maneira como um RoutedEvent túneis e bolhas do objeto que gera o evento.This is a direct consequence of the way a RoutedEvent tunnels and bubbles from the object that raises the event.

Em algumas situações a CommandBinding está conectada ao destino de comando, como o TextBox classe e o Cut, Copy, e Paste comandos.In some situations the CommandBinding is attached to the command target itself, such as with the TextBox class and the Cut, Copy, and Paste commands. Com muita frequência, no entanto, é mais conveniente anexar o CommandBinding a um predecessor do destino de comando, como o principal Window ou o objeto de aplicativo, especialmente se o mesmo CommandBinding pode ser usado para vários destinos de comando.Quite often though, it is more convenient to attach the CommandBinding to an ancestor of the command target, such as the main Window or the Application object, especially if the same CommandBinding can be used for multiple command targets. São decisões de design que você deverá considerar no momento de criar sua infraestrutura de comando.These are design decisions you will want to consider when you are creating your commanding infrastructure.

Destino do comandoCommand Target

O destino do comando é o elemento no qual o comando é executado.The command target is the element on which the command is executed. Com relação a um RoutedCommand, o destino do comando é o elemento no qual o roteamento do Executed e CanExecute inicia.With regards to a RoutedCommand, the command target is the element at which routing of the Executed and CanExecute starts. Conforme observado anteriormente, em WPFWPF o CommandTarget propriedade ICommandSource só é aplicável quando o ICommand é um RoutedCommand.As noted previously, in WPFWPF the CommandTarget property on ICommandSource is only applicable when the ICommand is a RoutedCommand. Se o CommandTarget é definido em um ICommandSource e o comando correspondente não é um RoutedCommand, o destino do comando será ignorado.If the CommandTarget is set on an ICommandSource and the corresponding command is not a RoutedCommand, the command target is ignored.

A fonte do comando pode definir explicitamente o destino do comando.The command source can explicitly set the command target. Se o destino do comando não for definido, o elemento com o foco do teclado será usado como destino do comando.If the command target is not defined, the element with keyboard focus will be used as the command target. Uma das vantagens de usar o elemento com o foco do teclado como destino do comando é que ele permite que o desenvolvedor do aplicativo use a mesma fonte de comando para invocar um comando em vários destinos, sem a necessidade de controlar o destino do comando.One of the benefits of using the element with keyboard focus as the command target is that it allows the application developer to use the same command source to invoke a command on multiple targets without having to keep track of the command target. Por exemplo, se um MenuItem invoca o colar comando em um aplicativo que tenha um TextBox controle e um PasswordBox controle, o destino pode ser o TextBox ou PasswordBox dependendo de qual controle tem foco do teclado.For example, if a MenuItem invokes the Paste command in an application that has a TextBox control and a PasswordBox control, the target can be either the TextBox or PasswordBox depending on which control has keyboard focus.

O exemplo a seguir mostra como definir explicitamente o destino do comando na marcação e no code-behind.The following example shows how to explicitly set the command target in markup and in code behind.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste"
              CommandTarget="{Binding ElementName=mainTextBox}" />
  </Menu>
  <TextBox Name="mainTextBox"/>
</StackPanel>
// 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;
' 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

O CommandManagerThe CommandManager

O CommandManager serve um número de comando funções relacionadas.The CommandManager serves a number of command related functions. Ele fornece um conjunto de métodos estáticos para adicionar e remover PreviewExecuted, Executed, PreviewCanExecute, e CanExecute manipuladores de eventos para e de um elemento específico.It provides a set of static methods for adding and removing PreviewExecuted, Executed, PreviewCanExecute, and CanExecute event handlers to and from a specific element. Ele fornece um meio para registrar CommandBinding e InputBinding objetos em uma classe específica.It provides a means to register CommandBinding and InputBinding objects onto a specific class. O CommandManager também fornece um meio, por meio de RequerySuggested eventos, para notificar um comando quando ele deve gerar o CanExecuteChanged evento.The CommandManager also provides a means, through the RequerySuggested event, to notify a command when it should raise the CanExecuteChanged event.

O InvalidateRequerySuggested método força a CommandManager para gerar o RequerySuggested evento.The InvalidateRequerySuggested method forces the CommandManager to raise the RequerySuggested event. Isso é útil em condições que devem desabilitar/habilitar um comando mas não são as condições que o CommandManager reconhece.This is useful for conditions that should disable/enable a command but are not conditions that the CommandManager is aware of.

Biblioteca de comandosCommand Library

O WPFWPF oferece um conjunto de comandos predefinidos.WPFWPF provides a set of predefined commands. A biblioteca de comandos consiste das seguintes classes: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommandse o ComponentCommands.The command library consists of the following classes: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommands, and the ComponentCommands. Essas classes fornecem comandos como Cut, BrowseBack e BrowseForward, Play, Stop, e Pause.These classes provide commands such as Cut, BrowseBack and BrowseForward, Play, Stop, and Pause.

Muitos desses comandos incluem um conjunto de associações de entrada padrão.Many of these commands include a set of default input bindings. Se você especificar, por exemplo, que seu aplicativo manipula o comando de cópia, receberá automaticamente a associação de teclado “CTRL+C”. Também receberá associações para outros dispositivos de entrada, tais como informações de fala e gestos de caneta do TabletTablet PC.For example, if you specify that your application handles the copy command, you automatically get the keyboard binding "CTRL+C" You also get bindings for other input devices, such as TabletTablet PC pen gestures and speech information.

Quando você faz referência a comandos nas várias bibliotecas de comandos usando XAMLXAML, geralmente é possível omitir o nome de classe da classe da biblioteca que expõe a propriedade de comando estático.When you reference commands in the various command libraries using XAMLXAML, you can usually omit the class name of the library class that exposes the static command property. De modo geral, os nomes dos comandos são cadeias de caracteres não ambíguas; os tipos de propriedade existem para fornecer um agrupamento lógico de comandos, mas não são necessários para eliminar a ambiguidade.Generally, the command names are unambiguous as strings, and the owning types exist to provide a logical grouping of commands but are not necessary for disambiguation. Por exemplo, é possível especificar o Command="Cut" em vez do Command="ApplicationCommands.Cut", mais detalhado.For instance, you can specify Command="Cut" rather than the more verbose Command="ApplicationCommands.Cut". Esse é um mecanismo de conveniência interna para o WPFWPF XAMLXAML processador de comandos (mais precisamente, ele é um comportamento do conversor de tipo de ICommand, que o WPFWPF XAMLXAML referências de processador em tempo de carregamento).This is a convenience mechanism that is built in to the WPFWPF XAMLXAML processor for commands (more precisely, it is a type converter behavior of ICommand, which the WPFWPF XAMLXAML processor references at load time).

Criando comandos personalizadosCreating Custom Commands

Se os comandos nas classes de biblioteca de comandos não satisfizerem suas necessidades, você poderá criar seus próprios comandos.If the commands in the command library classes do not meet your needs, then you can create your own commands. Há duas maneiras de criar um comando personalizado.There are two ways to create a custom command. A primeira é para iniciar desde o início até e implementar o ICommand interface.The first is to start from the ground up and implement the ICommand interface. De outra forma e a abordagem mais comum, é criar um RoutedCommand ou RoutedUICommand.The other way, and the more common approach, is to create a RoutedCommand or a RoutedUICommand.

Para obter um exemplo de criar um personalizado RoutedCommand, consulte Create a Custom RoutedCommand Sample.For an example of creating a custom RoutedCommand, see Create a Custom RoutedCommand Sample.

Consulte tambémSee Also

RoutedCommand
CommandBinding
InputBinding
CommandManager
Visão geral da entradaInput Overview
Visão geral de eventos roteadosRouted Events Overview
Implementar ICommandSourceImplement ICommandSource
Como adicionar um comando a um MenuItemHow to: Add a Command to a MenuItem
Criar uma amostra personalizada do RoutedCommandCreate a Custom RoutedCommand Sample