Compartir a través de

Cómo: Crear un comando RoutedCommand

  • Artículo

En este ejemplo se muestra cómo crear un RoutedCommand personalizado y cómo implementar el comando personalizado creando un ExecutedRoutedEventHandler y un CanExecuteRoutedEventHandler y adjuntándolos a un CommandBinding. Para obtener más información sobre los comandos, consulte Información general sobre comandos.

Ejemplo

El primer paso para crear un RoutedCommand es definir el comando y crear una instancia de él.

public static RoutedCommand CustomRoutedCommand = new RoutedCommand();

Public Shared CustomRoutedCommand As New RoutedCommand()

Para usar el comando en una aplicación, se deben crear controladores de eventos que definen lo que hace el comando

private void ExecutedCustomCommand(object sender,
    ExecutedRoutedEventArgs e)
{
    MessageBox.Show("Custom Command Executed");
}

Private Sub ExecutedCustomCommand(ByVal sender As Object, ByVal e As ExecutedRoutedEventArgs)
    MessageBox.Show("Custom Command Executed")
End Sub

// 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;
    }
}

' CanExecuteRoutedEventHandler that only returns true if
' the source is a control.
Private Sub CanExecuteCustomCommand(ByVal sender As Object, ByVal e As CanExecuteRoutedEventArgs)
    Dim target As Control = TryCast(e.Source, Control)

    If target IsNot Nothing Then
        e.CanExecute = True
    Else
        e.CanExecute = False
    End If
End Sub

A continuación, se crea un CommandBinding que asocia el comando a los controladores de eventos. CommandBinding se crea en un objeto específico. Este objeto define el ámbito de CommandBinding en el árbol de elementos

<Window x:Class="SDKSamples.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://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);

Dim customCommandBinding As New CommandBinding(CustomRoutedCommand, AddressOf ExecutedCustomCommand, AddressOf CanExecuteCustomCommand)

' attach CommandBinding to root window
Me.CommandBindings.Add(customCommandBinding)

El último paso consiste en invocar el comando. Una forma de invocar un comando es asociarlo con un ICommandSource, como un 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;

' create the ui
Dim CustomCommandStackPanel As New StackPanel()
Dim CustomCommandButton As New Button()
CustomCommandStackPanel.Children.Add(CustomCommandButton)

CustomCommandButton.Command = CustomRoutedCommand

Cuando se hace clic en el botón, se llama al método Execute en el RoutedCommand personalizado. RoutedCommand genera los eventos enrutados PreviewExecuted y Executed. Estos eventos atraviesan el árbol de elementos buscando un CommandBinding para este comando determinado. Si se encuentra un CommandBinding, se llama al ExecutedRoutedEventHandler asociado a CommandBinding.

Vea también