Comment : raccorder une commande à un contrôle sans prise en charge de commande

L'exemple suivant montre comment raccorder une RoutedCommand à un Control qui n'offre pas de prise en charge intégrée de la commande. Pour obtenir un exemple complet qui raccorde des commandes à plusieurs sources, consultez Créer un RoutedCommand personnalisé, exemple.

Exemple

Windows Presentation Foundation (WPF) propose une bibliothèque de commandes courantes que les programmeurs rencontrent régulièrement. Les classes qui constituent la bibliothèque de commandes sont les suivantes : ApplicationCommands, ComponentCommands, NavigationCommands, MediaCommands et EditingCommands.

Les objets RoutedCommand statiques qui composent ces classes ne fournissent pas de logique de commande. La logique de commande est associée à la commande à l'aide d'une CommandBinding. Dans WPF, de nombreux contrôles offrent une prise en charge intégrée pour certaines commandes de la bibliothèque de commandes. Par exemple, TextBox prend en charge de nombreuses commandes de modification de l'application, telles que Paste, Copy, Cut, Redo et Undo. Le développeur d'applications ne doit rien faire de spécial pour que ces commandes fonctionnent avec ces contrôles. Si le contrôle TextBox est la cible de la commande lors de l'exécution de celle-ci, il gérera la commande à l'aide de la CommandBinding qui lui est intégrée.

L'exemple suivant indique comment utiliser un Button comme source de la commande Open. Une CommandBinding est créée. Elle associe le CanExecuteRoutedEventHandler spécifié et le CanExecuteRoutedEventHandler à la RoutedCommand.

D'abord, la source de la commande est créée. Un Button est utilisé comme source de la commande.

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

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

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

Ensuite, le ExecutedRoutedEventHandler et le CanExecuteRoutedEventHandler sont créés. Le ExecutedRoutedEventHandler ouvre simplement une MessageBox pour indiquer que la commande s'est exécutée. Le CanExecuteRoutedEventHandler affecte à la propriété CanExecute la valeur true. Normalement, le gestionnaire de l'événement CanExecute effectue des contrôles plus fiables pour voir si la commande peut s'exécuter sur la cible de commande actuelle.

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

Enfin, une CommandBinding est créée sur la Window racine de l'application qui associe les gestionnaires d'événements routés à la commande Open.

<Window.CommandBindings>
  <CommandBinding Command="ApplicationCommands.Open"
                  Executed="OpenCmdExecuted"
                  CanExecute="OpenCmdCanExecute"/>
</Window.CommandBindings>

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

            Me.CommandBindings.Add(OpenCmdBinding)

// Creating CommandBinding and attaching an Executed and CanExecute handler
CommandBinding OpenCmdBinding = new CommandBinding(
    ApplicationCommands.Open,
    OpenCmdExecuted,
    OpenCmdCanExecute);

this.CommandBindings.Add(OpenCmdBinding);

Voir aussi

Tâches

Comment : raccorder une commande à un contrôle avec prise en charge de commande

Concepts

Vue d'ensemble des commandes