BefehlsübersichtCommanding Overview

Befehle sind ein Eingabemechanismus in Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF), der Eingabeverarbeitung auf einer höheren Ebene als die Geräteeingabe bereitstellt.Commanding is an input mechanism in Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) which provides input handling at a more semantic level than device input. Beispiele für Befehle sind die in vielen Programmen enthaltenen Vorgänge Kopieren, Ausschneiden und Einfügen.Examples of commands are the Copy, Cut, and Paste operations found on many applications.

In dieser Übersicht werden die in WPFWPF enthaltenen Befehle, die Klassen, die Teil des Befehlsmodells sind, und die Verwendung und Erstellung von Befehlen in Ihren Anwendungen vorgestellt.This overview defines what commands are in WPFWPF, which classes are part of the commanding model, and how to use and create commands in your applications.

Dieses Thema enthält folgende Abschnitte:This topic contains the following sections:

Was sind Befehle?What Are Commands?

Befehle haben mehrere Zwecke.Commands have several purposes. Der erste ist die Trennung der Semantik und des von einem Befehl aufgerufenen Objekts von der Logik, die den Befehl ausführt.The first purpose is to separate the semantics and the object that invokes a command from the logic that executes the command. Dadurch können mehrere und unterschiedliche Quellen dieselbe Befehlslogik aufrufen, und die Befehlslogik kann für verschiedene Ziele angepasst werden.This allows for multiple and disparate sources to invoke the same command logic, and it allows the command logic to be customized for different targets. Die Bearbeitungsvorgänge Kopieren, Ausschneiden und Einfügen, die in vielen Programmen vorkommen, können z.B. mithilfe anderer Benutzeraktionen aufgerufen werden, wenn sie mithilfe von Befehlen implementiert werden.For example, the editing operations Copy, Cut, and Paste, which are found in many applications, can be invoked by using different user actions if they are implemented by using commands. In manchen Anwendungen lassen sich ausgewählte Objekte oder Text durch einen Klick auf eine Schaltfläche, durch Auswählen eines Elements in einem Menü oder über eine Tastenkombination wie STRG+X ausschneiden.An application might allow a user to cut selected objects or text by either clicking a button, choosing an item in a menu, or using a key combination, such as CTRL+X. Mithilfe von Befehlen können Sie jede Art von Benutzeraktion an die gleiche Logik binden.By using commands, you can bind each type of user action to the same logic.

Ein weiterer Zweck von Befehlen ist es, die Verfügbarkeit von Aktionen anzugeben.Another purpose of commands is to indicate whether an action is available. Setzen wir das vorherige Beispiel fort: Das Ausschneiden eines Objekts oder Texts ist nur sinnvoll, wenn ein Objekt ausgewählt wurde.To continue the example of cutting an object or text, the action only makes sense when something is selected. Wenn ein Benutzer versucht, ein Objekt oder Text auszuschneiden, ohne dass etwas ausgewählt wurde, passiert nichts.If a user tries to cut an object or text without having anything selected, nothing would happen. Um dies für Benutzer kenntlich zu machen, werden Schaltflächen und Menüelemente in vielen Anwendungen deaktiviert. So weiß der Benutzer, ob es möglich ist, eine Aktion auszuführen.To indicate this to the user, many applications disable buttons and menu items so that the user knows whether it is possible to perform an action. Ein Befehl kann durch Implementierung der Methode CanExecute angegeben, ob eine Aktion möglich ist.A command can indicate whether an action is possible by implementing the CanExecute method. Eine Schaltfläche kann das Ereignis CanExecuteChanged abonnieren und deaktiviert werden, wenn CanExecute den Wert false zurückgibt, oder aktiviert werden, wenn CanExecute den Wert true zurückgibt.A button can subscribe to the CanExecuteChanged event and be disabled if CanExecute returns false or be enabled if CanExecute returns true.

Die Semantik eines Befehls kann anwendungs- und klassenübergreifend konsistent sein. Die Logik einer Aktion ist aber dem betreffenden Objekt eigen, auf das die Aktion ausgeführt wird.The semantics of a command can be consistent across applications and classes, but the logic of the action is specific to the particular object acted upon. Die Tastenkombination STRG+X ruft zwar den Befehl Ausschneiden in Textklassen, Bildklassen und Webbrowsern auf, aber die eigentliche Logik für die Ausführung des Vorgangs Ausschneiden wird von der Anwendung definiert, die ihn ausführt.The key combination CTRL+X invokes the Cut command in text classes, image classes, and Web browsers, but the actual logic for performing the Cut operation is defined by the application that performs the cut. RoutedCommand aktiviert Clients, um die Logik zu implementieren.A RoutedCommand enables clients to implement the logic. Ein Textobjekt kann den markierten Text ausschneiden und in die Zwischenablage kopieren, während ein Bildobjekt das markierte Bild ausschneiden kann.A text object may cut the selected text into the clipboard, while an image object may cut the selected image. Wenn eine Anwendung das Ereignis Executed verarbeitet, kann sie auf das Ziel des Befehls zugreifen und je nach Zielart geeignete Maßnahmen ergreifen.When an application handles the Executed event, it has access to the target of the command and can take appropriate action depending on the target's type.

Beispiel eines einfachen Befehls in WPFSimple Command Example in WPF

Die einfachste Möglichkeit, einen Befehl in WPFWPF zu verwenden, ist die Verwendung eines vordefinierten RoutedCommand-Befehls aus einer der Klassen der Befehlsbibliothek. Verwenden Sie ein Steuerelement mit nativer Unterstützung für die Verarbeitung des Befehls und eines mit nativer Unterstützung zum Aufrufen eines Befehls.The simplest way to use a command in WPFWPF is to use a predefined RoutedCommand from one of the command library classes; use a control that has native support for handling the command; and use a control that has native support for invoking a command. Der Befehl Paste ist einer der vordefinierten Befehle in der Klasse ApplicationCommands.The Paste command is one of the predefined commands in the ApplicationCommands class. Das Steuerelement TextBox verfügt über integrierte Logik zum Verarbeiten des Befehls Paste.The TextBox control has built in logic for handling the Paste command. Und die Klasse MenuItem verfügt über native Unterstützung für das Aufrufen von Befehlen.And the MenuItem class has native support for invoking commands.

Im folgenden Beispiel wird dargestellt, wie MenuItem eingerichtet wird, damit der Befehl Paste auf TextBox mit der Annahme, dass TextBox über den Tastaturfokus verfügt, aufgerufen wird, wenn darauf geklickt wird.The following example shows how to set up a MenuItem so that when it is clicked it will invoke the Paste command on a TextBox, assuming the TextBox has keyboard focus.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>
  // 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;
' 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

Vier Hauptkonzepte für WPF-BefehleFour Main Concepts in WPF Commanding

Das Modell der weitergeleiteten Befehle in WPFWPF kann auf vier Hauptkonzepte heruntergebrochen werden: der Befehl, die Befehlsquelle, das Ziel des Befehls und die Befehlsbindung:The routed command model in WPFWPF can be broken up into four main concepts: the command, the command source, the command target, and the command binding:

  • Die Befehl ist die Aktion, die ausgeführt werden soll.The command is the action to be executed.

  • Die Befehlsquelle ist das Objekt, das den Befehl aufruft.The command source is the object which invokes the command.

  • Das Befehlsziel ist das Objekt, auf das der Befehl ausgeführt wird.The command target is the object that the command is being executed on.

  • Die Befehlsbindung ist das Objekt, das den Befehl der Befehlslogik zuordnet.The command binding is the object which maps the command logic to the command.

Im vorherigen Beispiel ist Paste der Befehl, MenuItem die Befehlsquelle, TextBox das Befehlsziel und die Befehlsbindung wird vom Steuerelement TextBox bereitgestellt.In the previous example, the Paste command is the command, the MenuItem is the command source, the TextBox is the command target, and the command binding is supplied by the TextBox control. Beachten Sie, dass CommandBinding nicht immer vom Steuerelement angegeben wird, das die Befehlszielklasse darstellt.It is worth noting that it is not always the case that the CommandBinding is supplied by the control that is the command target class. CommandBinding muss oft vom Anwendungsentwickler erstellt werden, sonst kann es vorkommen, dass CommandBinding mit einem Vorgänger des Befehlsziels verbunden ist.Quite often the CommandBinding must be created by the application developer, or the CommandBinding might be attached to an ancestor of the command target.

BefehleCommands

Befehle in WPFWPF werden durch Implementieren der ICommand-Schnittstelle erstellt.Commands in WPFWPF are created by implementing the ICommand interface. ICommand stellt die zwei Methoden Execute und CanExecute sowie ein CanExecuteChanged-Ereignis zur Verfügung.ICommand exposes two methods, Execute, and CanExecute, and an event, CanExecuteChanged. Execute führt die Aktionen durch, die dem Befehl zugeordnet sind.Execute performs the actions that are associated with the command. CanExecute bestimmt, ob der Befehl auf dem aktuellen Befehlsziel ausgeführt werden kann.CanExecute determines whether the command can execute on the current command target. CanExecuteChanged wird ausgelöst, wenn der Befehls-Manager, der die Befehlsvorgänge zentralisiert, eine Änderung in der Befehlsquelle erkennt, die einen durch die Befehlsbindung ausgelösten Befehl, der noch nicht ausgeführt wurde, für ungültig erklären kann.CanExecuteChanged is raised if the command manager that centralizes the commanding operations detects a change in the command source that might invalidate a command that has been raised but not yet executed by the command binding. Die WPFWPF-Implementierung von ICommand ist die Klasse RoutedCommand und der Schwerpunkt dieser Übersicht.The WPFWPF implementation of ICommand is the RoutedCommand class and is the focus of this overview.

Die Hauptquellen für die Eingabe in WPFWPF sind die Maus, Tastatur, Freihandeingaben und weitergeleitete Befehle.The main sources of input in WPFWPF are the mouse, the keyboard, ink, and routed commands. Stärker geräteorientierte Eingaben verwenden ein RoutedEvent-Objekt, um Objekte auf einer Anwendungsseite darüber zu benachrichtigen, das ein Eingabeereignis aufgetreten ist.The more device-oriented inputs use a RoutedEvent to notify objects in an application page that an input event has occurred. Für RoutedCommand besteht kein Unterschied.A RoutedCommand is no different. Die Methoden Execute und CanExecute von RoutedCommand enthalten keine Anwendungslogik für den Befehl, stattdessen lösen sie Routingereignisse aus, die durch die Elementstruktur tunneln und bubblen, bis sie ein Objekt mit CommandBinding finden.The Execute and CanExecute methods of a RoutedCommand do not contain the application logic for the command, but rather they raise routed events that tunnel and bubble through the element tree until they encounter an object with a CommandBinding. CommandBinding enthält die Handler für diese Ereignisse, und die Handler führen den Befehl aus.The CommandBinding contains the handlers for these events and it is the handlers that perform the command. Weitere Informationen zum Ereignisrouting in WPFWPF finden Sie unter Übersicht über Routingereignisse.For more information on event routing in WPFWPF, see Routed Events Overview.

Die Methode Execute auf RoutedCommand löst die Ereignisse PreviewExecuted und Executed auf dem Befehlsziel aus.The Execute method on a RoutedCommand raises the PreviewExecuted and the Executed events on the command target. Die Methode CanExecute auf RoutedCommand löst die Ereignisse CanExecute und PreviewCanExecute auf dem Befehlsziel aus.The CanExecute method on a RoutedCommand raises the CanExecute and PreviewCanExecute events on the command target. Diese Ereignisse tunneln und bubblen in der Elementstruktur, bis sie ein Objekt finden, das CommandBinding für diesen speziellen Befehl ausweist.These events tunnel and bubble through the element tree until they encounter an object which has a CommandBinding for that particular command.

WPFWPF stellt eine Reihe von häufig verwendeten Befehlen bereit, die auf mehrere Klassen verteilt sind: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands und EditingCommands.supplies a set of common routed commands spread across several classes: MediaCommands, ApplicationCommands, NavigationCommands, ComponentCommands, and EditingCommands. Diese Klassen umfassen nur RoutedCommand-Objekte und nicht die Implementierungslogik des Befehls.These classes consist only of the RoutedCommand objects and not the implementation logic of the command. Die Implementierungslogik ist die Verantwortung des Objekts, für das der Befehl ausgeführt wird.The implementation logic is the responsibility of the object on which the command is being executed on.

BefehlsquellenCommand Sources

Eine Befehlsquelle ist das Objekt, das den Befehl aufruft.A command source is the object which invokes the command. MenuItem, Button und KeyGesture sind Beispiele für Befehlsquellen.Examples of command sources are MenuItem, Button, and KeyGesture.

Befehlsquellen in WPFWPF implementieren in der Regel die Schnittstelle ICommandSource.Command sources in WPFWPF generally implement the ICommandSource interface.

ICommandSource stellt drei Eigenschaften zur Verfügung: Command, CommandTarget und CommandParameter:ICommandSource exposes three properties: Command, CommandTarget, and CommandParameter:

Die WPFWPF-Klassen, die ICommandSource implementieren, sind ButtonBase, MenuItem, Hyperlink und InputBinding.The WPFWPF classes that implement ICommandSource are ButtonBase, MenuItem, Hyperlink, and InputBinding. ButtonBase, MenuItem und Hyperlink rufen einen Befehl auf, wenn auf sie geklickt wird, und InputBinding ruft einen Befehl auf, wenn das zugeordnete InputGesture ausgeführt wird.ButtonBase, MenuItem, and Hyperlink invoke a command when they are clicked, and an InputBinding invokes a command when the InputGesture associated with it is performed.

Im folgenden Beispiel wird veranschaulicht, wie MenuItem in ContextMenu als Befehlsquelle für den Befehl Properties verwendet wird.The following example shows how to use a MenuItem in a ContextMenu as a command source for the Properties command.

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

In der Regel überwacht eine Befehlsquelle das Ereignis CanExecuteChanged.Typically, a command source will listen to the CanExecuteChanged event. Dieses Ereignis teilt der Befehlsquelle mit, dass sich die Fähigkeit des Befehls zur Ausführung für das aktuelle Befehlsziel möglicherweise geändert hat.This event informs the command source that the ability of the command to execute on the current command target may have changed. Die Befehlsquelle kann mithilfe der Methode CanExecute den aktuellen Status von RoutedCommand abfragen.The command source can query the current status of the RoutedCommand by using the CanExecute method. Befehlsquelle sich kann dann selbst deaktivieren, wenn der Befehl nicht ausgeführt werden kann.The command source can then disable itself if the command cannot execute. Ein Beispiel hierfür ist ein ausgegrautes MenuItem, wenn ein Befehl nicht ausgeführt werden kann.An example of this is a MenuItem graying itself out when a command cannot execute.

InputGesture kann als Befehlsquelle verwendet werden.An InputGesture can be used as a command source. KeyGesture und MouseGesture sind zwei Arten von Eingabegesten in WPFWPF.Two types of input gestures in WPFWPF are the KeyGesture and MouseGesture. Sie können sich KeyGesture wie eine Tastenkombination vorstellen, z.B. STRG+C.You can think of a KeyGesture as a keyboard shortcut, such as CTRL+C. KeyGesture besteht aus einem Key und einer Reihe von ModifierKeys.A KeyGesture is comprised of a Key and a set of ModifierKeys. MouseGesture besteht aus einem MouseAction und einer optionalen Reihe von ModifierKeys.A MouseGesture is comprised of a MouseAction and an optional set of ModifierKeys.

Damit InputGesture sich wie eine Befehlsquelle verhält, muss es einem Befehl zugeordnet werden.In order for an InputGesture to act as a command source, it must be associated with a command. Hierzu gibt es zwei Möglichkeiten.There are a few ways to accomplish this. Eine Möglichkeit ist die Verwendung von InputBinding.One way is to use an InputBinding.

Im folgenden Beispiel wird veranschaulicht, wie ein KeyBinding zwischen KeyGesture und RoutedCommand erstellt wird.The following example shows how to create a KeyBinding between a KeyGesture and a RoutedCommand.

<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);
Dim OpenKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

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

Me.InputBindings.Add(OpenCmdKeybinding)

Eine weitere Möglichkeit, um InputGesture einem RoutedCommand zuzuordnen, besteht darin, InputGesture dem InputGestureCollection auf RoutedCommand hinzuzufügen.Another way to associate an InputGesture to a RoutedCommand is to add the InputGesture to the InputGestureCollection on the RoutedCommand.

Im folgenden Beispiel wird gezeigt, wie ein KeyGesture der InputGestureCollection von RoutedCommand hinzugefügt wird.The following example shows how to add a KeyGesture to the InputGestureCollection of a RoutedCommand.

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

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture);
Dim OpenCmdKeyGesture As New KeyGesture(Key.B, ModifierKeys.Control)

ApplicationCommands.Open.InputGestures.Add(OpenCmdKeyGesture)

CommandBindingCommandBinding

CommandBinding ordnet ein Befehl den Ereignishandlern zu, die den Befehl implementieren.A CommandBinding associates a command with the event handlers that implement the command.

Die Klasse CommandBinding enthält eine Command-Eigenschaft und die Ereignisse PreviewExecuted, Executed, PreviewCanExecute und CanExecute.The CommandBinding class contains a Command property, and PreviewExecuted, Executed, PreviewCanExecute, and CanExecute events.

Command ist der Befehl, dem CommandBinding zugeordnet wird.Command is the command that the CommandBinding is being associated with. Die Ereignishandler, die den Ereignissen PreviewExecuted und Executed zugeordnet sind, implementieren die Befehlslogik.The event handlers which are attached to the PreviewExecuted and Executed events implement the command logic. Die Ereignishandler, die den Ereignissen PreviewCanExecute und CanExecute zugeordnet sind, bestimmen, ob der Befehl auf dem aktuellen Befehlsziel ausgeführt werden kann.The event handlers attached to the PreviewCanExecute and CanExecute events determine if the command can execute on the current command target.

Das folgende Beispiel veranschaulicht das Erstellen von CommandBinding auf dem Window-Stamm einer Anwendung.The following example shows how to create a CommandBinding on the root Window of an application. CommandBinding ordnet den Befehl Open den Handlern Executed und CanExecute zu.The CommandBinding associates the Open command with Executed and CanExecute handlers.

<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);
' Creating CommandBinding and attaching an Executed and CanExecute handler
Dim OpenCmdBinding As New CommandBinding(ApplicationCommands.Open, AddressOf OpenCmdExecuted, AddressOf OpenCmdCanExecute)

Me.CommandBindings.Add(OpenCmdBinding)

Als Nächstes werden die ExecutedRoutedEventHandler- und CanExecuteRoutedEventHandler-Objekte erstellt.Next, the ExecutedRoutedEventHandler and a CanExecuteRoutedEventHandler are created. ExecutedRoutedEventHandler öffnet eine MessageBox-Klasse, die eine Zeichenfolge anzeigt, die angibt, dass der Befehl ausgeführt wurde.The ExecutedRoutedEventHandler opens a MessageBox that displays a string saying the command has been executed. Der CanExecuteRoutedEventHandler legt die CanExecute-Eigenschaft auf true fest.The CanExecuteRoutedEventHandler sets the CanExecute property to true.

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 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 OpenCmdCanExecute(object sender, CanExecuteRoutedEventArgs e)
{
    e.CanExecute = true;
}
Private Sub OpenCmdCanExecute(ByVal sender As Object, ByVal e As CanExecuteRoutedEventArgs)
    e.CanExecute = True
End Sub

CommandBinding wird einem spezifischen Objekt zugeordnet, z.B. dem Window-Stamm der Anwendung oder eines Steuerelements.A CommandBinding is attached to a specific object, such as the root Window of the application or a control. Das Objekt, dem CommandBinding zugeordnet ist, definiert den Bereich der Bindung.The object that the CommandBinding is attached to defines the scope of the binding. Einem Vorgänger des Befehlsziels zugeordnete CommandBinding kann beispielsweise mit dem Ereignis Executed erreicht werden, jedoch kann eine CommandBinding, die einem Nachfolger des Befehlsziels zugeordnet ist, nicht erreicht werden.For example, a CommandBinding attached to an ancestor of the command target can be reached by the Executed event, but a CommandBinding attached to a descendant of the command target cannot be reached. Dies ist eine direkte Folge der Art und Weise, wie RoutedEvent vom Objekt in der Hierarchie ab- und aufsteigt (tunneln und bubbeln), das das Ereignis auslöst.This is a direct consequence of the way a RoutedEvent tunnels and bubbles from the object that raises the event.

In manchen Situationen wird CommandBinding dem Befehlsziel selbst zugeordnet, z.B. bei der Klasse TextBox und den Befehlen Cut, Copy und Paste.In some situations the CommandBinding is attached to the command target itself, such as with the TextBox class and the Cut, Copy, and Paste commands. In vielen Fällen ist er einfacher, CommandBinding dem Vorgänger des Befehlsziels zuzuordnen, z.B. der Window-Hauptklasse oder dem Anwendungsobjekt, insbesondere wenn dieselbe CommandBinding für mehrere Befehlsziele verwendet werden kann.Quite often though, it is more convenient to attach the CommandBinding to an ancestor of the command target, such as the main Window or the Application object, especially if the same CommandBinding can be used for multiple command targets. Bei Erstellung Ihrer Befehlsinfrastruktur sollten Sie einige Entwurfsentscheidungen in beachten.These are design decisions you will want to consider when you are creating your commanding infrastructure.

BefehlszielCommand Target

Das Befehlsziel ist das Element, für das der Befehl ausgeführt wird.The command target is the element on which the command is executed. Bei RoutedCommand ist das Befehlsziel das Element, bei dem das Routing von Executed und CanExecute startet.With regards to a RoutedCommand, the command target is the element at which routing of the Executed and CanExecute starts. Wie bereits erwähnt, ist die Eigenschaft CommandTarget in WPFWPF nur auf ICommandSource anwendbar, wenn ICommand ein RoutedCommand ist.As noted previously, in WPFWPF the CommandTarget property on ICommandSource is only applicable when the ICommand is a RoutedCommand. Wenn CommandTarget auf eine ICommandSource festgelegt und der entsprechende Befehl kein RoutedCommand ist, wird das Befehlsziel ignoriert.If the CommandTarget is set on an ICommandSource and the corresponding command is not a RoutedCommand, the command target is ignored.

Die Befehlsquelle kann das Befehlsziel explizit festlegen.The command source can explicitly set the command target. Wenn das Befehlsziel nicht definiert ist, wird das Element mit dem Tastaturfokus als Befehlsziel verwendet.If the command target is not defined, the element with keyboard focus will be used as the command target. Einer der Vorteile daran, das Elements mit dem Tastaturfokus als Befehlsziel zu verwenden, ist die Tatsache, dass dies dem Anwendungsentwickler erlaubt, dieselbe Befehlsquelle zu verwenden, um einen Befehl für mehrere Ziele aufzurufen, ohne das Befehlsziel nachverfolgen zu müssen.One of the benefits of using the element with keyboard focus as the command target is that it allows the application developer to use the same command source to invoke a command on multiple targets without having to keep track of the command target. Wenn MenuItem den Befehl Paste in einer Anwendung aufruft, die über ein TextBox- und ein PasswordBox-Steuerelement verfügt, kann das Ziel entweder TextBox oder PasswordBox sein, je nachdem, welches Steuerelement über den Tastaturfokus verfügt.For example, if a MenuItem invokes the Paste command in an application that has a TextBox control and a PasswordBox control, the target can be either the TextBox or PasswordBox depending on which control has keyboard focus.

Im folgenden Beispiel wird das explizite Festlegen des Befehlsziels in Markup und der CodeBehind-Datei veranschaulicht.The following example shows how to explicitly set the command target in markup and in code behind.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste"
              CommandTarget="{Binding ElementName=mainTextBox}" />
  </Menu>
  <TextBox Name="mainTextBox"/>
</StackPanel>
  // 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;
' 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

Der CommandManagerThe CommandManager

CommandManager stellt eine Reihe von befehlsbezogenen Funktionen bereit.The CommandManager serves a number of command related functions. Er bietet eine Reihe von statischen Methoden zum Hinzufügen und Entfernen der Ereignishandler PreviewExecuted, Executed, PreviewCanExecute und CanExecute in und aus einem spezifischen Element.It provides a set of static methods for adding and removing PreviewExecuted, Executed, PreviewCanExecute, and CanExecute event handlers to and from a specific element. Er ermöglicht das Registrieren der Objekte CommandBinding und InputBinding auf einer bestimmten Klasse.It provides a means to register CommandBinding and InputBinding objects onto a specific class. CommandManager ermöglicht durch das Ereignis RequerySuggested außerdem das Benachrichtigen eines Befehls, wenn er das Ereignis CanExecuteChanged auslösen soll.The CommandManager also provides a means, through the RequerySuggested event, to notify a command when it should raise the CanExecuteChanged event.

Die Methode InvalidateRequerySuggested zwingt CommandManager zum Auslösen des Ereignisses RequerySuggested.The InvalidateRequerySuggested method forces the CommandManager to raise the RequerySuggested event. Dies ist für Bedingungen nützlich, die einen Befehl nicht deaktivieren oder aktivieren sollen, aber keine Bedingungen sind, die CommandManager beachtet.This is useful for conditions that should disable/enable a command but are not conditions that the CommandManager is aware of.

BefehlsbibliothekCommand Library

WPFWPF stellt eine Reihe von vordefinierten Befehlen bereit.provides a set of predefined commands. Die Befehlsbibliothek besteht aus den folgenden Klassen: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommands und ComponentCommands.The command library consists of the following classes: ApplicationCommands, NavigationCommands, MediaCommands, EditingCommands, and the ComponentCommands. Diese Klassen stellen Befehle wie die Folgenden bereit: Cut, BrowseBack, BrowseForward, Play, Stop und Pause.These classes provide commands such as Cut, BrowseBack and BrowseForward, Play, Stop, and Pause.

Viele dieser Befehle enthalten einen Satz von Standardeingabebindungen.Many of these commands include a set of default input bindings. Wenn Sie z. b. angeben, dass die Anwendung den Kopier Befehl verarbeitet, erhalten Sie automatisch die Tastatur Bindung "STRG + C", und Sie erhalten auch Bindungen für andere Eingabegeräte, z. b. Tablet PC-Stift Gesten und Sprachinformationen.For example, if you specify that your application handles the copy command, you automatically get the keyboard binding "CTRL+C" You also get bindings for other input devices, such as Tablet PC pen gestures and speech information.

Wenn Sie in den verschiedenen Bibliotheken mit XAMLXAML auf Befehle verweisen, können Sie normalerweise den Klassennamen der Bibliotheksklasse weglassen, die die statische Befehlseigenschaft verfügbar macht.When you reference commands in the various command libraries using XAMLXAML, you can usually omit the class name of the library class that exposes the static command property. In der Regel sind die Befehlsnamen als Zeichenfolgen eindeutig, und die besitzenden Typen sind vorhanden, um eine logische Gruppierung der Befehle bereitzustellen. Zur Mehrdeutigkeitsvermeidung sind sie nicht erforderlich.Generally, the command names are unambiguous as strings, and the owning types exist to provide a logical grouping of commands but are not necessary for disambiguation. Sie können z.B. Command="Cut" anstelle des ausführlicheren Command="ApplicationCommands.Cut" angeben.For instance, you can specify Command="Cut" rather than the more verbose Command="ApplicationCommands.Cut". Dies ist ein benutzerfreundlicher Mechanismus, der in den WPFWPF-XAMLXAML-Prozessor für Befehle integriertet ist (genauer gesagt, es ist das Verhalten des Typkonverters ICommand, auf den der WPFWPF-XAMLXAML-Prozessor zur Ladezeit verweist).This is a convenience mechanism that is built in to the WPFWPF XAMLXAML processor for commands (more precisely, it is a type converter behavior of ICommand, which the WPFWPF XAMLXAML processor references at load time).

Erstellen von benutzerdefinierten BefehlenCreating Custom Commands

Wenn die Befehle in den Klassen der Befehlsbibliothek nicht Ihren Bedürfnissen entsprechen, können Sie eigene Befehle erstellen.If the commands in the command library classes do not meet your needs, then you can create your own commands. Sie können auf zwei Arten und Weisen einen benutzerdefinierten Befehl erstellen.There are two ways to create a custom command. Die Erste besteht darin, von Grund auf zu beginnen und die Schnittstelle ICommand zu implementieren.The first is to start from the ground up and implement the ICommand interface. Die andere, gängigere Möglichkeit besteht in der Erstellung eines RoutedCommand oder RoutedUICommand.The other way, and the more common approach, is to create a RoutedCommand or a RoutedUICommand.

Ein Beispiel für das Erstellen eines benutzerdefinierten RoutedCommand finden Sie unter Create a Custom RoutedCommand Sample (Erstellen eines benutzerdefinierten „RoutedCommand“-Beispiels).For an example of creating a custom RoutedCommand, see Create a Custom RoutedCommand Sample.

Siehe auchSee also