Befehlsübersicht

Die Befehle sind ein Eingabemechanismus in Windows Presentation Foundation (WPF), wobei die Eingabebehandlung auf einer semantischeren Ebene als bei der Geräteeingabe erfolgt. Beispiele für Befehle sind die Vorgänge Kopieren, Ausschneiden und Einfügen, die in vielen Anwendungen verwendet werden.

In dieser Übersicht wird definiert, welche Befehle Teil von WPF sind, welche Klassen Teil des Befehlsmodells sind und wie Sie Befehle in Ihren Anwendungen verwenden und erstellen.

Dieses Thema enthält folgende Abschnitte:

• Was sind Befehle?

• Einfaches Befehlsbeispiel für WPF

• Vier Hauptbegriffe für WPF-Befehle

• Befehlsbibliothek

• Erstellen von benutzerdefinierten Befehlen

Was sind Befehle?

Befehle erfüllen mehrere Zwecke. Der erste Zweck besteht in der Trennung der Semantik und des Objekts, von dem ein Befehl aus der Logik aufgerufen wird, durch die der Befehl ausgeführt wird. Auf diese Weise können mehrere unterschiedliche Quellen dieselbe Befehlslogik aufrufen und diese für verschiedene Ziele anpassen. So können beispielsweise die Bearbeitungsvorgänge Kopieren, Ausschneiden und Einfügen, die in den meisten Anwendungen zur Verfügung stehen, durch unterschiedliche Benutzeraktionen aufgerufen werden, sofern diese mit Befehlen implementiert wurden. In einer Anwendung kann es dem Benutzer beispielsweise ermöglicht werden, ausgewählte Objekte oder ausgewählten Text durch Klicken auf eine Schaltfläche, durch Auswählen eines Menüelements oder durch Drücken einer Tastenkombination (beispielsweise STRG+X) auszuschneiden. Mit Befehlen lässt sich jede Art von Benutzeraktion an die gleiche Logik binden.

Ein weiterer Zweck von Befehlen besteht darin anzugeben, ob eine Aktion verfügbar ist. Bleiben wir bei dem Beispiel des Ausschneidens von Objekten oder Text: Diese Aktion ist nur sinnvoll, wenn zuvor etwas ausgewählt wurde. Versucht ein Benutzer, ein Objekt oder Text auszuschneiden, ohne zuvor etwas ausgewählt zu haben, passiert nichts. In vielen Anwendungen werden deshalb Schaltflächen und Menüelemente deaktiviert, damit der Benutzer weiß, ob eine Aktion ausgeführt werden kann. Durch Implementieren der CanExecute-Methode kann von einem Befehl angegeben werden, ob eine Aktion ausgeführt werden kann. Von einer Schaltfläche kann das CanExecuteChanged-Ereignis abonniert werden. Wird nun von CanExecute der Wert false zurückgegeben, wird die Schaltfläche deaktiviert. Wird von CanExecute dagegen der Wert true zurückgegeben, wird die Schaltfläche aktiviert.

Die Semantik eines Befehls kann über Anwendungen und Klassen hinweg konsistent sein, aber die Logik der Aktion ist jeweils spezifisch für das Objekt, für das die Aktion ausgeführt wird. Über die Tastenkombination STRG+X wird zwar der Befehl Ausschneiden in Textklassen, Imageklassen und in Webbrowsern aufgerufen, die eigentliche Logik zum Ausführen der Operation Ausschneiden wird jedoch von der Anwendung definiert, von der der Ausschneidevorgang ausgeführt wird. Mithilfe von RoutedCommand kann die Logik von Clients implementiert werden. Von einem Textobjekt kann der ausgewählte Text ausgeschnitten und in die Zwischenablage eingefügt werden, wohingegen von einem Imageobjekt das ausgewählte Image ausgeschnitten wird. Beim Behandeln des Executed-Ereignisses durch eine Anwendung erhält die Anwendung Zugriff auf das Ziel des Befehls, und je nach Art des Ziels kann die entsprechende Aktion ausgeführt werden.

Einfaches Befehlsbeispiel für WPF

Die einfachste Art der Anwendung eines Befehls in WPF ist das Verwenden eines vordefinierten RoutedCommand-Elements aus einer der Befehlsbibliotheksklassen, das Verwenden eines Steuerelements, das über eine systemeigene Unterstützung zum Verarbeiten des Befehls verfügt, und das Verwenden eines Steuerelements, das über eine systemeigene Unterstützung zum Aufrufen eines Befehls verfügt. Der Befehl Paste ist einer der vordefinierten Befehle in der ApplicationCommands-Klasse. Das TextBox-Steuerelement weist eine integrierte Logik für die Verarbeitung des Befehls Paste auf. Und die MenuItem-Klasse verfügt über eine systemeigene Unterstützung zum Aufrufen von Befehlen.

Das folgende Beispiel zeigt, wie Sie ein MenuItem so einrichten, dass beim Klicken darauf der Befehl Paste für ein TextBox-Steuerelement aufgerufen wird, vorausgesetzt, das TextBox-Steuerelement hat den Tastaturfokus.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>

            ' Creating the UI objects
            Dim mainStackPanel As New StackPanel()
            Dim pasteTextBox As New TextBox()
            Dim stackPanelMenu As New Menu()
            Dim pasteMenuItem As 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

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

// Setting the command target to the TextBox
pasteMenuItem.CommandTarget = pasteTextBox;

Vier Hauptbegriffe für WPF-Befehle

Das Modell der weitergeleiteten Befehle in WPF kann in vier Hauptbegriffe unterteilt werden: Befehl, Befehlsquelle, Befehlsziel und Befehlsbindung:

• Der Befehl ist die Aktion, die ausgeführt werden soll.

• Die Befehlsquelle ist das Objekt, das den Befehl aufruft.

• Das Befehlsziel ist das Objekt, für das der Befehl ausgeführt wird.

• Die Befehlsbindung ist das Objekt, das dem Befehl die Befehlslogik zuordnet.

Im obigen Beispiel ist der Befehl Paste der Befehl, MenuItem ist die Befehlsquelle, TextBox ist das Befehlsziel und die Befehlsbindung wird vom TextBox-Steuerelement bereitgestellt. Dabei ist zu beachten, dass es nicht immer der Fall ist, dass die CommandBinding von dem Steuerelement bereitgestellt wird, bei dem es sich um die Befehlszielklasse handelt. Häufig muss die CommandBinding vom Anwendungsentwickler erstellt werden, oder die CommandBinding muss einem Vorgänger des Befehlsziels zugeordnet werden.

Befehle

Befehle in WPF werden durch Implementieren der ICommand-Schnittstelle implementiert. Von ICommand werden zwei Methoden (Execute und CanExecute) sowie ein Ereignis (CanExecuteChanged) verfügbar gemacht. Execute führt die Aktionen aus, die dem Befehl zugeordnet sind. CanExecute bestimmt, ob der Befehl für das aktuelle Befehlsziel ausgeführt werden kann. CanExecuteChanged wird ausgelöst, wenn der Befehls-Manager, der die Befehlsabläufe zentral verwaltet, eine Änderung der Befehlsquelle erkennt, die einen ausgelösten, aber von der Befehlsbindung noch nicht ausgeführten Befehl ggf. ungültig macht. Die WPF-Implementierung von ICommand ist die RoutedCommand-Klasse, die im Mittelpunkt dieser Übersicht steht.

Die Hauptquellen der Eingabe unter WPF sind die Maus, die Tastatur, Freihandeingaben und weitergeleitete Befehle. Bei den stärker geräteorientierten Eingaben wird ein RoutedEvent verwendet, um Objekte auf einer Anwendungsseite davon in Kenntnis zu setzen, dass ein Eingabeereignis erfolgt ist. Bei einem RoutedCommand verhält es sich genauso. Die Methoden Execute und CanExecute eines RoutedCommand enthalten die Anwendungslogik des Befehls nicht, sondern lösen Routingereignisse aus, die die Elementstruktur per Tunneling und Bubbling durchlaufen, bis sie auf ein Objekt mit einer CommandBinding treffen. Die CommandBinding enthält die Handler für diese Ereignisse und stellt die Handler dar, die den Befehl ausführen. Weitere Informationen zum WPF-Ereignisrouting finden Sie unter Übersicht über Routingereignisse.

Die Execute-Methode eines RoutedCommand löst die Ereignisse PreviewExecuted und Executed für das Befehlsziel aus. Die CanExecute-Methode eines RoutedCommand löst die Ereignisse CanExecute und PreviewCanExecute für das Befehlsziel aus. Diese Ereignisse durchlaufen die Elementstruktur per Tunneling und Bubbling, bis sie auf ein Objekt treffen, das über eine CommandBinding für den jeweiligen Befehl verfügt.

WPF enthält eine Reihe von gängigen weitergeleiteten Befehlen, die auf mehrere Klassen verteilt sind: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands und EditingCommands. Diese Klassen umfassen nur die RoutedCommand-Objekte, nicht die Implementierungslogik des Befehls. Für die Implementierungslogik ist das Objekt verantwortlich, für das der Befehl ausgeführt wird.

Befehlsquellen

Eine Befehlsquelle ist das Objekt, das den Befehl aufruft. Beispiele für Befehlsquellen sind MenuItem, Button und KeyGesture.

Befehlsquellen in WPF implementieren im Allgemeinen die ICommandSource-Schnittstelle.

ICommandSource legt drei Eigenschaften offen: Command, CommandTarget und CommandParameter:

• Command ist der Befehl, der ausgeführt wird, wenn die Befehlsquelle aufgerufen wird.

• CommandTarget ist das Objekt, für das der Befehl ausgeführt wird. Dabei ist zu beachten, dass in WPF die CommandTarget-Eigenschaft für ICommandSource nur anwendbar ist, wenn es sich bei ICommand um einen RoutedCommand handelt. Wenn das CommandTarget für eine ICommandSource festgelegt wurde und der entsprechende Befehl kein RoutedCommand ist, wird das Befehlsziel ignoriert. Wenn das CommandTarget nicht festgelegt ist, wird das Element mit dem Tastaturfokus als Befehlsziel verwendet.

• CommandParameter ist ein benutzerdefinierter Datentyp, der verwendet wird, um Informationen an die Handler zu übergeben, die den Befehl implementieren.

Die WPF-Klassen, die ICommandSource implementieren, sind ButtonBase, MenuItem, Hyperlink und InputBinding. ButtonBase, MenuItem und Hyperlink rufen einen Befehl auf, wenn darauf geklickt wird, und eine InputBinding ruft einen Befehl auf, wenn die zugeordnete InputGesture ausgeführt wird.

Das folgende Beispiel zeigt, wie Sie ein MenuItem in einem ContextMenu als Befehlsquelle für den Properties-Befehl verwenden.

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

            Dim cmdSourcePanel As New StackPanel()
            Dim cmdSourceContextMenu As New ContextMenu()
            Dim cmdSourceMenuItem As New MenuItem()

            ' Add ContextMenu to the StackPanel.
            cmdSourcePanel.ContextMenu = cmdSourceContextMenu
            cmdSourcePanel.ContextMenu.Items.Add(cmdSourceMenuItem)

            ' Associate Command with MenuItem.
            cmdSourceMenuItem.Command = ApplicationCommands.Properties

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;

Normalerweise überwacht eine Befehlsquelle das CanExecuteChanged-Ereignis. Dieses Ereignis benachrichtigt die Befehlsquelle darüber, dass sich die Fähigkeit des Befehls, für das aktuelle Befehlsziel ausgeführt zu werden, ggf. geändert hat. Die Befehlsquelle kann den aktuellen Status für den RoutedCommand abfragen, indem sie die CanExecute-Methode verwendet. Die Befehlsquelle kann sich dann selbst deaktivieren, wenn der Befehl nicht ausgeführt werden kann. Ein Beispiel hierfür ist ein MenuItem, das sich selbst abblendet, wenn ein Befehl nicht ausgeführt werden kann.

Eine InputGesture kann als Befehlsquelle verwendet werden. Zwei Typen von Eingabeaktionen in WPF sind KeyGesture und MouseGesture. Sie können sich eine KeyGesture als Tastenkombination vorstellen, z. B. STRG+C. Eine KeyGesture besteht aus einem Key und verschiedenen ModifierKeys. Eine MouseGesture besteht aus einer MouseAction und einer Reihe optionaler ModifierKeys.

Damit eine InputGesture als Befehlsquelle fungieren kann, muss sie einem Befehl zugeordnet sein. Es gibt einige Möglichkeiten, dies zu erreichen. Ein Ansatz besteht darin, eine InputBinding zu verwenden.

Das folgende Beispiel zeigt, wie Sie zwischen einer KeyGesture und einem RoutedCommand eine KeyBinding erstellen.

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

            Dim OpenKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

            Dim OpenCmdKeybinding As New KeyBinding(ApplicationCommands.Open, OpenKeyGesture)

            Me.InputBindings.Add(OpenCmdKeybinding)

KeyGesture OpenKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

KeyBinding OpenCmdKeybinding = new KeyBinding(
    ApplicationCommands.Open,
    OpenKeyGesture);

this.InputBindings.Add(OpenCmdKeybinding);

Eine andere Möglichkeit, eine InputGesture einem RoutedCommand zuzuordnen, ist das Hinzufügen der InputGesture zur InputGestureCollection des RoutedCommand-Elements.

Das folgende Beispiel zeigt, wie Sie eine KeyGesture der InputGestureCollection eines RoutedCommand-Elements hinzufügen.

            Dim OpenCmdKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

            ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture)

KeyGesture OpenCmdKeyGesture = new KeyGesture(
    Key.B,
    ModifierKeys.Control);

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture);

CommandBinding

Eine CommandBinding ordnet einen Befehl den Ereignishandlern zu, die den Befehl implementieren.

Die CommandBinding-Klasse enthält eine Command-Eigenschaft sowie die Ereignisse PreviewExecuted, Executed, PreviewCanExecute und CanExecute.

Command ist der Befehl, dem die CommandBinding zugeordnet wird. Die Ereignishandler, die den Ereignissen PreviewExecuted und Executed zugeordnet sind, implementieren die Befehlslogik. Die Ereignishandler, die den Ereignissen PreviewCanExecute und CanExecute zugeordnet sind, bestimmen, ob der Befehl für das aktuelle Befehlsziel ausgeführt werden kann.

Das folgende Beispiel zeigt, wie Sie eine CommandBinding für das Window-Stammelement einer Anwendung erstellen. Die CommandBinding ordnet den Open-Befehl den Handlern Executed und CanExecute zu.

<Window.CommandBindings>
  <CommandBinding Command="ApplicationCommands.Open"
                  Executed="OpenCmdExecuted"
                  CanExecute="OpenCmdCanExecute"/>
</Window.CommandBindings>

            ' Creating CommandBinding and attaching an Executed and CanExecute handler
            Dim OpenCmdBinding As New CommandBinding(ApplicationCommands.Open, AddressOf OpenCmdExecuted, AddressOf OpenCmdCanExecute)

            Me.CommandBindings.Add(OpenCmdBinding)

// Creating CommandBinding and attaching an Executed and CanExecute handler
CommandBinding OpenCmdBinding = new CommandBinding(
    ApplicationCommands.Open,
    OpenCmdExecuted,
    OpenCmdCanExecute);

this.CommandBindings.Add(OpenCmdBinding);

Anschließend werden der ExecutedRoutedEventHandler und ein CanExecuteRoutedEventHandler erstellt. Der ExecutedRoutedEventHandler öffnet ein MessageBox, in dem eine Zeichenfolge angezeigt wird, die aussagt, dass der Befehl ausgeführt wurde. Der CanExecuteRoutedEventHandler setzt die CanExecute-Eigenschaft auf true.

Private Sub OpenCmdExecuted(ByVal sender As Object, ByVal e As ExecutedRoutedEventArgs)
    Dim command, targetobj As String
    command = CType(e.Command, RoutedCommand).Name
    targetobj = CType(sender, FrameworkElement).Name
    MessageBox.Show("The " + command + " command has been invoked on target object " + targetobj)
End Sub

void OpenCmdExecuted(object target, ExecutedRoutedEventArgs e)
{
    String command, targetobj;
    command = ((RoutedCommand)e.Command).Name;
    targetobj = ((FrameworkElement)target).Name;
    MessageBox.Show("The " + command +  " command has been invoked on target object " + targetobj);
}

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

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

Eine CommandBinding ist an ein bestimmtes Objekt angefügt, z. B. an das Window-Stammelement der Anwendung oder eines Steuerelements. Das Objekt, an das die CommandBinding angefügt ist, definiert den Bindungsbereich. Eine CommandBinding, die an einen Vorgänger des Befehlsziels angefügt ist, kann z. B. vom Executed-Ereignis erreicht werden, aber eine CommandBinding, die an einen Nachfolger des Befehlsziels angefügt ist, kann nicht erreicht werden. Dies ist eine direkte Folge der Art und Weise, wie ein RoutedEvent die Struktur per Tunneling und Bubbling von einem Objekt durchläuft, das das Ereignis auslöst.

In einigen Situationen ist die CommandBinding an das Befehlsziel selbst angefügt, z. B. bei der TextBox-Klasse und den Befehlen Cut, Copy und Paste. Häufig ist es einfacher, die CommandBinding an einen Vorgänger des Befehlsziels anzufügen, z. B. an das Window-Hauptfenster oder das Application-Objekt, besonders wenn eine CommandBinding für mehrere Befehlsziele verwendet werden kann. Dies sind Entwurfsentscheidungen, die Sie beim Erstellen der Befehlsinfrastruktur berücksichtigen sollten.

Befehlsziel

Das Befehlsziel ist das Element, für das der Befehl ausgeführt wird. Bei einem RoutedCommand ist das Befehlsziel das Element, bei dem das Routing von Executed und CanExecute beginnt. Wie bereits erwähnt, ist in WPF die CommandTarget-Eigenschaft für ICommandSource nur anwendbar ist, wenn es sich bei ICommand um einen RoutedCommand handelt. Wenn das CommandTarget für eine ICommandSource festgelegt wurde und der entsprechende Befehl kein RoutedCommand ist, wird das Befehlsziel ignoriert.

Die Befehlsquelle kann das Befehlsziel explizit festlegen. Wenn das Befehlsziel nicht definiert ist, wird das Element mit dem Tastaturfokus als Befehlsziel verwendet. Einer der Vorteile der Verwendung des Elements mit dem Tastaturfokus als Befehlsziel besteht darin, dass Anwendungsentwickler dieselbe Befehlsquelle verwenden können, um einen Befehl für mehrere Ziele aufzurufen, ohne das Befehlsziel verfolgen zu müssen. Wenn ein MenuItem z. B. den Befehl Einfügen in einer Anwendung aufruft, die über ein TextBox- und ein PasswordBox-Steuerelement verfügt, kann das Ziel entweder das TextBox-oder das PasswordBox-Steuerelement sein. Dies ist davon abhängig, welches Steuerelement gerade den Tastaturfokus besitzt.

Das folgende Beispiel zeigt, wie Sie das Befehlsziel in Markup und in Code-Behind explizit festlegen.

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

            ' Creating the UI objects
            Dim mainStackPanel As New StackPanel()
            Dim pasteTextBox As New TextBox()
            Dim stackPanelMenu As New Menu()
            Dim pasteMenuItem As 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

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

// Setting the command target to the TextBox
pasteMenuItem.CommandTarget = pasteTextBox;

Der CommandManager

Der CommandManager stellt verschiedene befehlsbezogene Funktionen bereit. Er bietet Benutzern eine Reihe von statischen Methoden zum Hinzufügen und Entfernen der Ereignishandler PreviewExecuted, Executed, PreviewCanExecute und CanExecute zu einem bestimmten Element bzw. aus einem bestimmten Element. Sie können ihn verwenden, um CommandBinding- und InputBinding-Objekte für eine spezifische Klasse zu registrieren. Mithilfe von CommandManager können Sie über das RequerySuggested-Ereignis außerdem einem Befehl mitteilen, wann dieser das CanExecuteChanged-Ereignis auslösen soll.

Die InvalidateRequerySuggested-Methode zwingt den CommandManager, das RequerySuggested-Ereignis auszulösen. Dies ist für Bedingungen nützlich, die einen Befehl deaktivieren bzw. aktivieren sollen, ohne dass der CommandManager über diese Bedingungen informiert ist.

Befehlsbibliothek

WPF stellt eine Reihe von vordefinierten Befehlen bereit. Die Befehlsbibliothek besteht aus den folgenden Klassen: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommands und ComponentCommands. Diese Klassen stellen Befehle wie Cut, BrowseBack und BrowseForward, Play, Stop und Pause bereit.

Viele dieser Befehle enthalten verschiedene standardmäßige Eingabebindungen. Wenn Sie z. B. eingeben, dass Ihre Anwendung den Kopierbefehl behandelt, erhalten Sie automatisch die Tastaturbindung "STRG+C". Sie erhalten auch Bindungen für andere Eingabegeräte, z. B. Tablet PC-Stiftbewegungen und -Sprachinformationen.

Wenn Sie mithilfe von XAML auf Befehle in den verschiedenen Bibliotheken verweisen, können Sie normalerweise den Klassennamen der Bibliotheksklasse weglassen, die die statische Befehlseigenschaft offenlegt. In der Regel sind Befehlsnamen als Zeichenfolgen eindeutig, und die besitzenden Typen sind vorhanden, um eine logische Gruppierung der Befehle zu ermöglichen. Sie sind jedoch nicht erforderlich, um die Eindeutigkeit sicherzustellen. Sie können z. B. Command="Cut" anstelle des ausführlicheren Command="ApplicationCommands.Cut" angeben. Dies ist ein Mechanismus, der die Benutzerfreundlichkeit fördert und in den WPF-XAML-Prozessor für Befehle integriert ist (genauer gesagt handelt es sich um ein Typkonverterverhalten von ICommand, auf das der WPF-XAML-Prozessor zur Ladezeit verweist).

Erstellen von benutzerdefinierten Befehlen

Wenn die Befehle in den Befehlsbibliotheksklassen für Ihre Anforderungen nicht ausreichen, können Sie Ihre eigenen Befehle erstellen. Es gibt zwei Möglichkeiten, einen benutzerdefinierten Befehl zu erstellen. Die erste Möglichkeit besteht darin, von Grund auf zu beginnen und die ICommand-Schnittstelle zu implementieren. Eine gängigere Möglichkeit besteht darin, einen RoutedCommand oder einen RoutedUICommand zu erstellen.

Ein Beispiel für die Erstellung einer benutzerdefinierten Version von RoutedCommand finden Sie unter Beispiel für das Erstellen eines benutzerdefinierten "RoutedCommand".

Siehe auch

Aufgaben

Gewusst wie: Implementieren von "ICommandSource"

Gewusst wie: Hinzufügen eines Befehls zu einem MenuItem

Referenz

RoutedCommand

CommandBinding

InputBinding

CommandManager

Konzepte

Übersicht über die Eingabe

Übersicht über Routingereignisse

Weitere Ressourcen

Beispiel für das Erstellen eines benutzerdefinierten "RoutedCommand"