TOC

This article has been localized into Italian by the community.

Comandi:

Implementare comandi WPF personalizzati

Nel precedente capitolo, abbiamo dato un'occhiata ad alcune modalità di utilizzo di comandi già definiti in WPF, ma ovviamente puoi implementare il propri comandi personalizzati. E' abbastanza semplice, e una volta che l'hai fatto, puoi usarli esattamente come quelli predefiniti.

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.

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!