Como: Enganchar um Comando em um Controle sem Suporte de Comando

O seguinte exemplo mostra como enganchar um RoutedCommand a um Control que não tem suporte embutido para o comando. Para um exemplo completo que atrela comandos a múltiplas fontes, veja o exemplo Criar um exemplo de RoutedCommand Personalizar.

Exemplo

Windows Presentation Foundation (WPF) fornece uma biblioteca de comandos comuns que programadores de aplicação encontram regularmente. As classes que compõem a biblioteca de comando são: ApplicationCommands, ComponentCommands, , NavigationCommands, MediaCommands, e EditingCommands.

Os objetos estáticos RoutedCommand que compõem essas classes não fornecem lógica de comando. A lógica do comando está associada com o comando com um CommandBinding. Muitos controles em WPF possuem suporte nativo para alguns dos comandos na biblioteca de comandos. TextBox, por exemplo, suporte muitos dos comandos de edição de aplicação tais como Paste, Copy, Cut, Redo e Undo. O desenvolvedor da aplicação não tem que fazer nada especial para fazer esses comandos funcionarem com esses controles. Se o TextBox é o alvo do comando quando o comando é executado, manipulará o comando utilizando o CommandBinding que é embutido no controle.

O seguinte mostra como usar um Button como a fonte de comando para o comando Open. Um CommandBinding é criado que associa o CanExecuteRoutedEventHandler especificado e o CanExecuteRoutedEventHandler ao RoutedCommand.

Primeiro, a fonte do comando é criada. Um Button é usado como a fonte de comando.

<Button Command="ApplicationCommands.Open" Name="MyButton"
        Height="50" Width="200">
  Open (KeyBindings: Ctrl+R, Ctrl+0)
</Button>

// Button used to invoke the command
Button CommandButton = new Button();
CommandButton.Command = ApplicationCommands.Open;
CommandButton.Content = "Open (KeyBindings: Ctrl-R, Ctrl-0)";
MainStackPanel.Children.Add(CommandButton);

Depois, o ExecutedRoutedEventHandler e o CanExecuteRoutedEventHandler são criados. O ExecutedRoutedEventHandler simplesmente abre um MessageBox para significar que o comando foi executado. O CanExecuteRoutedEventHandler define a propriedade CanExecute para true. Normalmente, o manipulador de execução realizaria verificações mais robustas para ver se o comando poderia ser executado no alvo atual de comando.

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

Finalmente, um CommandBinding é criado na raiz da Window da aplicação que associa os manipuladores de eventos roteados ao comando Open.

<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);

Consulte também

Tarefas

Como: Hook Up a Command to a Control with Command Support

Conceitos

Visão geral de Comando