Compartilhar via


Como: Criar um RoutedCommand

Este exemplo mostra como criar um RoutedCommand personalizado e como implementar o comando personalizado, criando um ExecutedRoutedEventHandler e um CanExecuteRoutedEventHandler e anexando-o a um CommandBinding. Para obter mais informações sobre comandos, consulte Visão geral de Comando.

Exemplo

A primeira etapa na criação de um RoutedCommand é definir o comando e criar uma instância dele.

public static RoutedCommand CustomRoutedCommand = new RoutedCommand();

Para poder usar o comando em um aplicativo, deve-se criar os tratadores de eventos que definem o que ele faz.

private void ExecutedCustomCommand(object sender,
    ExecutedRoutedEventArgs e)
{
    MessageBox.Show("Custom Command Executed");
}
// CanExecuteRoutedEventHandler that only returns true if
// the source is a control.
private void CanExecuteCustomCommand(object sender, 
    CanExecuteRoutedEventArgs e)
{
    Control target = e.Source as Control;

    if(target != null)
    {
        e.CanExecute = true;
    }
    else
    {
        e.CanExecute = false;
    }
}

Em seguida, cria-se um CommandBinding que associa o comando com os tratadores de eventos. O CommandBinding é criado sobre um objeto específico. Este objeto define o escopo do CommandBinding na árvore de elementos.

<Window x:Class="SDKSamples.Window1"
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:custom="clr-namespace:SDKSamples"
    Height="600" Width="800"
    >
  <Window.CommandBindings>
    <CommandBinding Command="{x:Static custom:Window1.CustomRoutedCommand}"
                    Executed="ExecutedCustomCommand"
                    CanExecute="CanExecuteCustomCommand" />
  </Window.CommandBindings>
CommandBinding customCommandBinding = new CommandBinding(
    CustomRoutedCommand, ExecutedCustomCommand, CanExecuteCustomCommand);

// attach CommandBinding to root window
this.CommandBindings.Add(customCommandBinding);

A etapa final é invocar o comando. Uma maneira de invocar um comando é associá-lo a uma ICommandSource (p.ex., Button).

<StackPanel>
  <Button Command="{x:Static custom:Window1.CustomRoutedCommand}"
          Content="CustomRoutedCommand"/>
</StackPanel>
// create the ui
StackPanel CustomCommandStackPanel = new StackPanel();
Button CustomCommandButton = new Button();
CustomCommandStackPanel.Children.Add(CustomCommandButton);

CustomCommandButton.Command = CustomRoutedCommand;

Quando o botão for clicado, o método Execute sobre o RoutedCommand personalizado é chamado. O RoutedCommand gera os eventos roteados PreviewExecuted e Executed. Esses eventos atravessam a árvore de elementos procurando um CommandBinding para este comando em particular. Se um CommandBinding for encontrado, o ExecutedRoutedEventHandler associado ao CommandBinding é chamado.

Consulte também

Conceitos

Visão geral de Comando

Referência

RoutedCommand