Condividi tramite

Procedura: associare un comando a un controllo senza supporto del comando

  • Articolo

Nell'esempio seguente viene illustrato come associare una classe RoutedCommand a una classe Control che non dispone del supporto incorporato per il comando. Per un esempio completo in cui i comandi sono associati a più origini, vedere l'esempio Create a Custom RoutedCommand Sample (Creare un esempio di oggetto RoutedCommand personalizzato).

Esempio

Windows Presentation Foundation (WPF) fornisce una libreria di comandi comuni che i programmatori di applicazioni riscontrano regolarmente. Le classi che costituiscono la libreria del comando sono: ApplicationCommands, ComponentCommands, NavigationCommands, MediaCommands e EditingCommands.

Gli oggetti RoutedCommand statici che costituiscono queste classi non forniscono la logica per il comando. La logica per il comando è associata al comando con un CommandBinding. Molti controlli in WPF includono il supporto incorporato per alcuni dei comandi nella libreria dei comandi. TextBox, ad esempio, supporta molti dei comandi di modifica dell'applicazione, ad esempio Paste, Copy, Cut, Redo e Undo. Lo sviluppatore dell'applicazione non deve eseguire operazioni particolari per garantire il funzionamento di questi comandi con tali controlli. Se la destinazione del comando eseguito è TextBox, il comando verrà gestito utilizzando il CommandBinding incorporato nel controllo.

Nell'esempio seguente viene illustrato come utilizzare un Button come origine del comando Open. Viene creata una classe CommandBinding che associa il metodo CanExecuteRoutedEventHandler specificato e il metodo CanExecuteRoutedEventHandler con la classe RoutedCommand.

Innanzitutto, viene creata l'origine del comando. Una classe Button viene utilizzata come origine del 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);

' Button used to invoke the command
Dim CommandButton As New Button()
CommandButton.Command = ApplicationCommands.Open
CommandButton.Content = "Open (KeyBindings: Ctrl-R, Ctrl-0)"
MainStackPanel.Children.Add(CommandButton)

Successivamente, vengono creati i metodi ExecutedRoutedEventHandler e CanExecuteRoutedEventHandler. Il metodo ExecutedRoutedEventHandler apre semplicemente una classe MessageBox per indicare che il comando è stato eseguito. Il metodo CanExecuteRoutedEventHandler imposta la proprietà CanExecute su true. In genere, il gestore CanExecute eseguirebbe controlli più approfonditi per vedere se è possibile eseguire il comando sulla destinazione del comando corrente.


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



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

Infine, viene creata una classe CommandBinding nella classe Window principale dell'applicazione che associa i gestori di eventi indirizzati al 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);

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

Me.CommandBindings.Add(OpenCmdBinding)

Vedi anche