Condividi tramite

Come creare un RoutedCommand

In questo esempio viene illustrato come creare un RoutedCommand personalizzato e come implementare il comando personalizzato creando un ExecutedRoutedEventHandler e un CanExecuteRoutedEventHandler e collegandoli a un CommandBinding. Per altre informazioni sui comandi, vedere la Panoramica dei Comandi .

Esempio

Il primo passaggio per la creazione di un RoutedCommand consiste nel definire il comando e crearne un'istanza.

public static RoutedCommand CustomRoutedCommand = new RoutedCommand();

Public Shared CustomRoutedCommand As New RoutedCommand()

Per usare il comando in un'applicazione, devono essere creati i gestori eventi che definiscono cosa fa il 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

Viene quindi creato un CommandBinding che associa il comando ai gestori eventi. Il CommandBinding viene creato in un oggetto specifico. Questo oggetto definisce l'ambito del CommandBinding nell'albero degli elementi

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

Il passo finale è invocare il comando. Un modo per richiamare un comando consiste nell'associarlo a un ICommandSource, ad esempio 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

Quando si clicca sul pulsante, viene chiamato il metodo Execute sul RoutedCommand personalizzato. Il RoutedCommand genera gli eventi indirizzati PreviewExecuted e Executed. Questi eventi attraversano l'albero degli elementi cercando un CommandBinding per questo particolare comando. Se viene trovato un CommandBinding, viene chiamato il ExecutedRoutedEventHandler associato a CommandBinding.

Vedere anche