TOC

This article has been localized into French by the community.

Commandes:

Implémentation d'une commande personnalisée WPF

Dans l'article précédent, nous avons vu plusieurs utilisations des commandes prédéfinies dans WPF, mais vous pouvez bien sur implémenter vos propres commandes C'est plutôt simple et quand vous l'aurez fait, vous pourrez utilisez vos propres commandes comme celles prédéfinies dans WPF.

Le plus simple pour démarrer l'implémentation de vos propres commandes est de créer une classe static qui les contiendra. Chaque commande sera ajoutée à cette classe comme champs qui seront utilisables dans votre application. Comme WPF, pour d'étranges raisons, n'implémente pas les commandes "Exit/Quit", j'ai décidé, pour l'exemple, de les implémenter. Voici ce que cela donne :

<Window x:Class="WpfTutorialSamples.Commands.CustomCommandSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:self="clr-namespace:WpfTutorialSamples.Commands"
        Title="CustomCommandSample" Height="150" Width="200">
    <Window.CommandBindings>
        <CommandBinding Command="self:CustomCommands.Exit" CanExecute="ExitCommand_CanExecute" Executed="ExitCommand_Executed" />
    </Window.CommandBindings>
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>
        <Menu>
            <MenuItem Header="File">
                <MenuItem Command="self:CustomCommands.Exit" />
            </MenuItem>
        </Menu>
        <StackPanel Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center">
            <Button Command="self:CustomCommands.Exit">Exit</Button>
        </StackPanel>
    </Grid>
</Window>
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

namespace WpfTutorialSamples.Commands
{
	public partial class CustomCommandSample : Window
	{
		public CustomCommandSample()
		{
			InitializeComponent();
		}

		private void ExitCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
		{
			e.CanExecute = true;
		}

		private void ExitCommand_Executed(object sender, ExecutedRoutedEventArgs e)
		{
			Application.Current.Shutdown();
		}
	}

	public static class CustomCommands
	{
		public static readonly RoutedUICommand Exit = new RoutedUICommand
			(
				"Exit",
				"Exit",
				typeof(CustomCommands),
				new InputGestureCollection()
				{
					new KeyGesture(Key.F4, ModifierKeys.Alt)
				}
			);

		//Define more commands here, just like the one above
	}
}

Dans le source j'ai définie une simple interface contenant un menu et un bouton qui utilisent notre commande personnalisée "Exit". Cette commande est définie dans le "Code-behind" de notre class CustomCommands et est ajouté au "commandBinding" de la fenêtre ou l'on assigne les événements devant être utilisés pour exécuter / vérifier si l'exécution est autorisé

Tout ceci est semblable aux exemples de l'article précédent excepté pour le référencement de la de notre propre code de commande (en utilisant le namespace "self" dans les paramètres de la fenêtre) au lieu des commande prédéfinie.

Dans le Code-behind, on s’abonne aux deux événements de notre commande : la première méthode (ExitCommand_CanExecute) pour toujours autoriser l'exécution, car c'est généralement le cas pour une commande Exit/Quit, et la deuxième (ExitCommand_Executed) qui appel la méthode Shutdownpour terminer l'application. Tout simplement.

Comme expliqué, nous avons implémenté notre commande Exit a l'aide d'un champ de la class static CustomCommands. Il existe plusieurs manières de définir et d'assigner les propriétés des commandes, mais j'ai choisi l'approche la plus compacte avec l'assignation à travers le constructeur (Plus court aurait été d'écrire le tout sur une seule ligne, mais pour une question de lisibilité j'ai ajouté des retours à la ligne). Les paramètres sont le texte/Label de la commande, son nom (name), le type de commande et une InputGestureCollection permettant de définir le raccourci clavier de la commande (Alt+F4).

Résumé :

Implémenter des commandes WPF personnalisé est presque aussi simple que de mettre en œuvre les commandes natives, et vous permets d'utiliser les commandes en toute circonstance dans votre application. La réutilisation d'actions en plusieurs emplacements est rendu très simple avec l'exemple décrit dans cet article.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!