Používání WPF Příkazů

V předchozím článku, jsme probrali co příkazy (commands) jsou a jak fungují. V této kapitole, se podíváme na to, jak je použít, přiřazením na UI elementy a vytvoření command Bindingu, který vše propojí dohromady.

Začneme s jednoduchým příkladem.

<Window x:Class="WpfTutorialSamples.Commands.UsingCommandsSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="UsingCommandsSample" Height="100" Width="200">
    <Window.CommandBindings>
        <CommandBinding Command="ApplicationCommands.New" Executed="NewCommand_Executed" CanExecute="NewCommand_CanExecute" />
    </Window.CommandBindings>

    <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
        <Button Command="ApplicationCommands.New">New</Button>
    </StackPanel>
</Window>

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

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

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

		private void NewCommand_Executed(object sender, ExecutedRoutedEventArgs e)
		{
			MessageBox.Show("The New command was invoked");
		}
	}
}

Definujeme vazbu příkazu na okno přidáním do jeho kolekce CommandBindings. Specifikujeme příkaz, který chceme použít (příkaz New z ApplicationCommands), stejně jako dva obslužné programy událostí. Vizuální rozhraní se skládá z jediného tlačítka, ke kterému příkaz přiřadíme pomocí vlastnosti Command.

V Code-behind ošetřujeme obě události. Obslužný program CanExecute, který WPF zavolá, když je aplikace nečinná, aby zjistil, zda je konkrétní příkaz momentálně dostupný. Je to velmi jednoduché, protože chceme, aby tento konkrétní příkaz byl pořád dostupný. Toho dosáhneme nastavením argumentů vlastnosti události CanExecute na true.

Obslužný program Executed jednoduše zobrazí zprávu v dialogovém okně, když je příkaz vyvolán. Pokud vzorek spustíte a stisknete tlačítko, uvidíte tuto zprávu. Věc, které si všimněte, je, že tento příkaz má definovanou výchozí klávesovou zkratku, kterou dostanete jako přidaný bonus. Místo klikání na tlačítko můžete zkusit stisknout Ctrl+N na klávesnici - výsledek je stejný.

Použití metody CanExecute

V prvním příkladu jsme implementovali událost CanExecute, která jednoduše vrátila true, aby bylo tlačítko dostupné pořád. Samozřejmě to ale neplatí pro všechna tlačítka - v mnoha případech chcete, aby bylo tlačítko povoleno nebo zakázáno v závislosti na určitém stavu vaší aplikace.

Velmi běžným příkladem toho je přepínání tlačítek pro použití schránky Windows, kde chcete, aby byla tlačítka pro Vyjmout a Kopírovat povolena pouze tehdy, když je vybrán text, a tlačítko pro Vložit povoleno pouze tehdy, když je v schránce přítomen text. To je přesně to, čeho v tomto příkladu dosáhneme:

<Window x:Class="WpfTutorialSamples.Commands.CommandCanExecuteSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="CommandCanExecuteSample" Height="200" Width="250">
    <Window.CommandBindings>
        <CommandBinding Command="ApplicationCommands.Cut" CanExecute="CutCommand_CanExecute" Executed="CutCommand_Executed" />
        <CommandBinding Command="ApplicationCommands.Paste" CanExecute="PasteCommand_CanExecute" Executed="PasteCommand_Executed" />
    </Window.CommandBindings>
    <DockPanel>
        <WrapPanel DockPanel.Dock="Top" Margin="3">
            <Button Command="ApplicationCommands.Cut" Width="60">_Cut</Button>
            <Button Command="ApplicationCommands.Paste" Width="60" Margin="3,0">_Paste</Button>
        </WrapPanel>
        <TextBox AcceptsReturn="True" Name="txtEditor" />
    </DockPanel>
</Window>

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

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

		private void CutCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
		{
			e.CanExecute = (txtEditor != null) && (txtEditor.SelectionLength > 0);
		}

		private void CutCommand_Executed(object sender, ExecutedRoutedEventArgs e)
		{
			txtEditor.Cut();
		}

		private void PasteCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
		{
			e.CanExecute = Clipboard.ContainsText();
		}

		private void PasteCommand_Executed(object sender, ExecutedRoutedEventArgs e)
		{
			txtEditor.Paste();
		}
	}
}

Máme tedy toto velmi jednoduché rozhraní s několika tlačítky a ovládacím prvkem TextBox. První tlačítko provede vyjmutí do schránky a druhé vložení z ní.

V Code-behind máme pro každé tlačítko dvě události: Jednu, která provádí samotnou akci, jejíž název končí na _Executed, a poté události CanExecute. V každé z nich uvidíte, že aplikuje určitou logiku pro rozhodnutí, zda může být akce provedena, a poté ji přiřadím k návratové hodnotě CanExecute na EventArgs.

Skvělé na tom je, že nemusíte tyto metody volat, aby se vaše tlačítka aktualizovala - WPF to dělá automaticky, když má aplikace okamžik nečinnosti, čímž zajišťuje, že vaše rozhraní zůstane pořád aktualizované.

Výchozí chování příkazu a CommandTarget (cíl příkazu)

Jak jsme viděli v předchozím příkladu, zpracování sady příkazů může vést k poměrně rozsáhlému kódu, s mnoha deklaracemi metod a velmi standardní logikou. To je pravděpodobně důvod, proč se tým WPF rozhodl zpracovat některé z nich za vás. Ve skutečnosti jsme se mohli v předchozím příkladu vyhnout veškerému kódu v Code-behind, protože WPF TextBox může automaticky zpracovávat běžné příkazy jako Vyjmout, Kopírovat, Vložit, Vrátit zpět a Opakovat.

WPF to dělá tak, že za vás zpracovává události Executed (Vykonáno) a CanExecute (LzeVykonat), když má ovládací prvek pro zadávání textu, jako je TextBox fokus. Máte možnost tyto události přepsat, což je v podstatě to, co jsme udělali v předchozím příkladu, ale pokud chcete jen základní chování, můžete nechat WPF propojit příkazy a ovládací prvek TextBox a udělat práci za vás. Jen se podívejte, jak je tento příklad mnohem jednodušší:

<Window x:Class="WpfTutorialSamples.Commands.CommandsWithCommandTargetSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="CommandsWithCommandTargetSample" Height="200" Width="250">
    <DockPanel>
        <WrapPanel DockPanel.Dock="Top" Margin="3">
            <Button Command="ApplicationCommands.Cut" CommandTarget="{Binding ElementName=txtEditor}" Width="60">_Cut</Button>
            <Button Command="ApplicationCommands.Paste" CommandTarget="{Binding ElementName=txtEditor}" Width="60" Margin="3,0">_Paste</Button>
        </WrapPanel>
        <TextBox AcceptsReturn="True" Name="txtEditor" />
    </DockPanel>
</Window>

Pro tento příklad není potřeba žádný kód Code-behind - WPF se o vše postará za nás, ale pouze proto, že chceme použít tyto konkrétní příkazy pro tento konkrétní ovládací prvek. TextBox odvede práci za nás.

Všimněte si, jak používám vlastnosti CommandTarget na tlačítkách, abych přiřadil příkazy k našemu ovládacímu prvku TextBox. V tomto konkrétním příkladu je to vyžadováno, protože WrapPanel nezpracovává fokus stejným způsobem jako například Toolbar (panel nástrojů) nebo Menu, ale dává také docela dobrý smysl dát příkazům cíl.

Shrnutí

Práce s příkazy je docela přímočará, ale zahrnuje trochu navíc značkování a kódu. Odměna je zřejmá zejména, když musíte provádět stejnou akci z více míst, nebo když používáte vestavěné příkazy, které WPF dokáže zpracovat za vás, jak jsme viděli v posledním příkladu.