Implementare comandi WPF personalizzati

Nel capitolo precedente, abbiamo dato un'occhiata all'utilizzo di comandi messi a disposizione di default da WPF. Ovviamente puoi creare dei comandi personalizzati. Farlo è abbastanza semplice, e una volta implementati, puoi usarli esattamente come quelli di default.

Il modo più semplice per iniziare a implementare i tuoi comandi è di avere una classe static che li contenga. Ogni comando viene quindi aggiunto a questa classe come campi statici, permettendoti di usarli nella tua applicazione. Dal momento che WPF, per qualche strana ragione, non implementa un comando Exit / Quit, ho deciso di implementarne uno per il nostro esempio di comandi personalizzati. Apparirà come questo:

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

Nel markup, ho definito un'interfaccia molto semplice con un menu e un pulsante, entrambi utilizzando il nostro nuovo comando di uscita personalizzato. Questo comando è definito nel Code-behind, nella nostra classe CustomCommands e quindi referenziato nella collezione CommandBindings della finestra, dove assegniamo gli eventi che dovrebbe Eseguire / Controllare se è consentito eseguirlo.

Tutto questo è proprio come gli esempi nel capitolo precedente, tranne il fatto che stiamo facendo riferimento al comando dal nostro codice (usando lo spazio dei nomi "self" definito all'inizio) anziché un comando incorporato.

Nel Code-behind, rispondiamo ai due eventi per il nostro comando: un evento consente solo al comando di essere sempre eseguito, poiché è solitamente vero per un comando exit/quit e l'altro chiama il metodo Shutdown che interromperà la nostra applicazione. Tutto molto semplice.

Come già spiegato, implementiamo il nostro comando Exit come campo su una classe statica CustomCommands. Esistono diversi modi per definire ed assegnare  proprietà ai comandi, ma ho scelto l'approccio più compatto (sarebbe ancora più compatto se collocato sulla stessa linea, ma ho aggiunto interruzioni di riga per migliorare la leggibilità) se assegnassi tutto attraverso il costruttore. I parametri sono il testo / etichetta del comando, il nome del comando, il tipo proprietario e poi un InputGestureCollection, che mi permette di definire un collegamento predefinito per il comando (Alt + F4).

Sommario

L'implementazione di comandi WPF personalizzati è quasi tanto semplice quanto i comandi incorporati e consente di utilizzare i comandi per ogni scopo nel applicazione. Ciò rende molto facile riutilizzare le azioni in diversi punti, come mostrato nell'esempio di questo capitolo.