C#

// creazione oggetti UI
StackPanel mainStackPanel = new StackPanel(); 
TextBox pasteTextBox = new TextBox(); 
Menu stackPanelMenu = new Menu(); 
MenuItem pasteMenuItem = new MenuItem(); 
// Aggiunta oggetti al pannello e al menu
stackPanelMenu.Items.Add(pasteMenuItem); 
mainStackPanel.Children.Add(stackPanelMenu); 
mainStackPanel.Children.Add(pasteTextBox); 
// Inizializza il comando al valore Incolla
pasteMenuItem.Command = ApplicationCommands.Paste;

I Quattro Concetti Essenziali nel Sistema dei Comandi di WPF

Il modello di comando pilotato di WPF può essere suddiviso in quattro concetti essenziali: il comando, la sorgente del comando, il destinatario del comando [target: obiettivo n.d.t.] e il collegamento del comando [command binding n.d.t.]. Il comando è l'azione che deve essere eseguita. La sorgente del comando è l'oggetto che invoca il comando. Il destinatario del comando è l'oggetto sul quale il comando viene eseguito. Infine, il collegamento del comando è l'oggetto che mappa la logica di comando sul comando.

Nell'esempio sopra riportato, Incolla è il comando, MenuItem è la sorgente del comando, TextBox è il destinatario del comando e il collegamento del comando è fornito dal controllo della TextBox. Esso non ha valore poiché non sempre il ComandBinding è fornito dal controllo. Abbastanza spesso il CommandBinding deve essere generato dallo sviluppatore dell'applicazione e potrebbe essere collegato ad un antenato [ancestor n.d.t.] del destinatario di comando. [Antenato inteso come classe padre, nonno, bisnonno nella catena di ereditarietà di OOP n.d.r.]

Comandi

In WPF i comandi sono generati implementando l'interfaccia di ICommand. L'ICommand espone due metodi e un evento: Execute, CanExecute e CanExecuteChanged. Execute esegue l'azione del comando, CanExecute stabilisce se il comando può essere eseguito sul corrente destinatario di comando e CanExecuteChanged indica che la capacità di esecuzione del comando potrebbe essere cambiata. L'implementazione di WPF dell' ICommand è la classe RoutedCommand ed è il punto focale di questa panoramica.

Le principali sorgenti di input in WPF sono il mouse, la tastiera, l'ink [Ink provider di un Tablet PC o un Palmare con touch screen n.d.r.] e i comandi pilotati. Tutti questi tipi di input utilizzano un RoutedEvent per notificare agli oggetti che siè verificato un evento di input. Un RoutedCommand non è diverso. I metodi di Execute e di CanExecute di un RoutedCommand non contengono la logica di applicazione del comando, ma piuttosto essi invocano eventi pilotati i quali discendono [tunnel n.d.t.] e risalgono [bubble n.d.t.] attraverso l'albero degli elementi fino a quando incontrano un oggetto che implementa un CommandBinding. Il CommandBinding contiene i gestori di questi eventi e sono questi ultimi che eseguono il comando. Per maggiori informazioni sugli eventi pilotati in WPF, vedi Panoramica degli Eventi Pilotati   .

Il metodo Execute di un RoutedCommand invoca gli eventi di PreviewExecuted e di Excuted sul destinatario del comando. Il metodo CanExecute di un RoutedCommand invoca gli eventi di CanExecute e di PreviewCanExecute sul destinatario del comando. Questi eventi discendono [tunnel n.d.t.] e risalgono [bubble n.d.t.] attraverso l'albero degli elementi fino a quando incontrano un oggetto che possiede un CommandBinding per quel particolare comando.
WPF fornisce un insieme dei più frequenti comandi pilotati diffusi in numerose classi: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands e EditingCommands. In queste classi sono implementati esclusivamente gli oggetti del RoutedCommand, non la logica di funzionamento del comando, la quale deve essere implementata a cura dell'oggetto sul quale il comando viene eseguito.

Sorgenti di Comando (Command Sources)

Una sorgente di comando è l'oggetto che invoca il comando. Esempi di sorgenti di comando sono: MenuItem, Button e KeyGesture [Tasto funzione o shortcut n.d.r.].

Le sorgenti di comando in WPF generalmente implementano l'interfaccia di ICommandSource.

ICommandSource espone tre proprietà: Command, CommandTarget e CommandParameter. Command è il comando che viene eseguito quando la sorgente di comando è invocata. CommandTarget è l'oggetto sul quale si esegue il comando. Esso non ha valore poiché in WPF la property di CommandTarget su ICommandSource è applicabile solamente quando la ICommand è un RoutedCommand. Se il CommandTarget è impostato su una ICommandSource ed il corrispondente comando non è un RoutedCommand, il destinatario del comando viene ignorato. Se il CommandTarget non è impostato, l'elemento che ha il focus di tastiera [keyboard focus n.d.t.] sarà il destinatario del comando. Il CommandParameter è un tipo di dati definiti dall'utente utilizzati per passare informazioni ai gestori che implementano il comando.
Le classi di WPF che implementano la ICommandSource sono: ButtonBase, MenuItem, Hyperlink e InputBinding. ButtonBase, MenuItem e Hyperlink invocano un comando quando vengono cliccati, InputBinding evoca un comando quando l' InputGesture con il quale è associato(associated:unito,collegato) viene eseguito.
L'esempio seguente indica come utilizzare, in un ContextMenu, un MenuItem come sorgente di comando per il comando Properties.

XAML

<StackPanel> 
	   <StackPanel.ContextMenu> 
	      <ContextMenu> 
	         <MenuItem Command="ApplicationCommands.Properties" />
	      ContextMenu> 
	   StackPanel.ContextMenu> 
	StackPanel>

StackPanel cmdSourcePanel = new StackPanel(); 
	ContextMenu cmdSourceContextMenu = new ContextMenu(); 
	MenuItem cmdSourceMenuItem = new MenuItem(); 
	// Add ContextMenu to the StackPanel. 
	cmdSourcePanel.ContextMenu = cmdSourceContextMenu; 
	cmdSourcePanel.ContextMenu.Items.Add(cmdSourceMenuItem); 
	// Associate Command with MenuItem. 
	cmdSourceMenuItem.Command = ApplicationCommands.Properties;

<Window.InputBindings>
	   <KeyBinding Key="B" Modifiers="Control" 
	      Command="ApplicationCommands.Open" /> 
	Window.InputBindings>

KeyGesture OpenKeyGesture = new KeyGesture( 
	    Key.B, ModifierKeys.Control); 
	KeyBinding OpenCmdKeybinding = new KeyBinding( 
	    ApplicationCommands.Open, OpenKeyGesture); 
	this.InputBindings.Add(OpenCmdKeybinding);

KeyGesture OpenCmdKeyGesture = new KeyGesture( 
	    Key.B, ModifierKeys.Control); 
	ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture);

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

void OpenCmdExecuted(object target, 
	   ExecutedRoutedEventArgs e) 
	{
	    MessageBox.Show("The command has been invoked."); 
	}

Sub OpenCmdExecuted(ByVal sender As Object, _
	   ByVal e As ExecutedRoutedEventArgs) _
	   MessageBox.Show("The command has been invoked.") 
	End Sub

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

Sub OpenCmdCanExecute(ByVal sender As Object, _
	   ByVal e As CanExecuteRoutedEventArgs) 
	    e.CanExecute = True 
	End Sub

	<StackPanel> 
	   <Menu> 
	      <MenuItem Command="ApplicationCommands.Paste" 
	         CommandTarget="{Binding ElementName=mainTextBox}" />
	   Menu> 
	<TextBox Name="mainTextBox"/>

	// Creating the UI objects StackPanel 
	mainStackPanel = new StackPanel(); 
	TextBox pasteTextBox = new TextBox(); 
	Menu stackPanelMenu = new Menu(); 
	MenuItem pasteMenuItem = new MenuItem(); 
	// Adding objects to the panel and the menu 
	stackPanelMenu.Items.Add(pasteMenuItem); 
	mainStackPanel.Children.Add(stackPanelMenu); 
	mainStackPanel.Children.Add(pasteTextBox); 
	// Setting the command to the Paste command 
	pasteMenuItem.Command = ApplicationCommands.Paste;