Freigeben über

Befehlsübersicht

Die Befehlssteuerung ist ein Eingabemechanismus in Windows Presentation Foundation (WPF), der die Eingabebehandlung auf einer mehr semantischen Ebene als die Geräteeingabe bereitstellt. Beispiele für Befehle sind die Vorgänge "Kopieren", " Ausschneiden" und " Einfügen" in vielen Anwendungen.

Diese Übersicht definiert, welche Befehle in WPF enthalten sind, welche Klassen Teil des Befehlsmodells sind und wie Sie Befehle in Ihren Anwendungen verwenden und erstellen.

Dieses Thema enthält die folgenden Abschnitte:

Was sind Befehle?

Befehle haben mehrere Zwecke. Der erste Zweck besteht darin, die Semantik und das Objekt zu trennen, das einen Befehl von der Logik aufruft, die den Befehl ausführt. Dies ermöglicht es mehreren und unterschiedlichen Quellen, dieselbe Befehlslogik aufzurufen, und die Befehlslogik kann für verschiedene Ziele angepasst werden. Beispielsweise können die Bearbeitungsvorgänge "Kopieren", " Ausschneiden" und " Einfügen", die in vielen Anwendungen gefunden werden, mithilfe verschiedener Benutzeraktionen aufgerufen werden, wenn sie mithilfe von Befehlen implementiert werden. Eine Anwendung kann es einem Benutzer ermöglichen, ausgewählte Objekte oder Text auszuschneiden, indem er entweder auf eine Schaltfläche klickt, ein Element in einem Menü auswählt oder eine Tastenkombination verwendet, z. B. STRG+X. Mithilfe von Befehlen können Sie jeden Benutzeraktionstyp an dieselbe Logik binden.

Ein weiterer Zweck von Befehlen besteht darin, anzugeben, ob eine Aktion verfügbar ist. Wenn Sie das Beispiel zum Ausschneiden eines Objekts oder Texts fortsetzen möchten, ist die Aktion nur dann sinnvoll, wenn etwas markiert ist. Wenn ein Benutzer versucht, ein Objekt oder Text zu schneiden, ohne etwas ausgewählt zu haben, würde nichts passieren. Um dies für den Benutzer anzugeben, deaktivieren viele Anwendungen Schaltflächen und Menüelemente, damit der Benutzer weiß, ob es möglich ist, eine Aktion auszuführen. Ein Befehl kann angeben, ob eine Aktion möglich ist, indem die CanExecute Methode implementiert wird. Eine Schaltfläche kann das CanExecuteChanged Ereignis abonnieren und deaktiviert werden, wenn CanExecutefalse zurückgibt, oder aktiviert werden, wenn CanExecutetrue zurückgibt.

Die Semantik eines Befehls kann in allen Anwendungen und Klassen konsistent sein, aber die Logik der Aktion ist spezifisch für das jeweilige Objekt, auf das reagiert wird. Die Tastenkombination STRG+X ruft den Befehl "Ausschneiden " in Textklassen, Bildklassen und Webbrowsern auf, die eigentliche Logik zum Ausführen des Cut-Vorgangs wird jedoch von der Anwendung definiert, die den Ausschnitt ausführt. A RoutedCommand ermöglicht Clients die Implementierung der Logik. Ein Textobjekt kann den markierten Text in die Zwischenablage ausschneiden, während ein Bildobjekt das ausgewählte Bild ausschneiden kann. Wenn eine Anwendung das Executed Ereignis behandelt, hat sie Zugriff auf das Ziel des Befehls und kann je nach Typ des Ziels geeignete Aktionen ausführen.

Einfaches Befehlsbeispiel in WPF

Die einfachste Möglichkeit, einen Befehl in WPF zu verwenden, besteht darin, eine vordefinierte RoutedCommand aus einer der Befehlsbibliotheksklassen zu verwenden. Verwenden Sie ein Steuerelement, das systemeigene Unterstützung für die Behandlung des Befehls hat, und verwenden Sie ein Steuerelement, das systemeigene Unterstützung für das Aufrufen eines Befehls hat. Der Paste Befehl ist einer der vordefinierten Befehle in der ApplicationCommands Klasse. Das TextBox Steuerelement verfügt über eine integrierte Logik für die Behandlung des Paste Befehls. Und die MenuItem Klasse bietet native Unterstützung für das Ausführen von Befehlen.

Das folgende Beispiel zeigt, wie Sie ein MenuItem so einrichten, dass der Paste Befehl auf ein TextBox Steuerelement aufgerufen wird, wenn darauf geklickt wird, vorausgesetzt, dass der TextBox den Tastaturfokus hat.

<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 im WPF-Commanding

Das Routingbefehlsmodell in WPF kann in vier Hauptkonzepte unterteilt werden: der Befehl, die Befehlsquelle, das Befehlsziel und die Befehlsbindung:

  • Der Befehl ist die auszuführende Aktion.

  • 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 die Befehlslogik dem Befehl zuordnet.

Im vorherigen Beispiel ist der Befehl der Paste Befehl, die MenuItem Befehlsquelle, das TextBox Befehlsziel, und die Befehlsbindung wird vom TextBox Steuerelement bereitgestellt. Es ist erwähnenswert, dass das CommandBinding nicht immer von der Steuerung bereitgestellt wird, die die Befehlszielklasse ist. Oft muss das CommandBinding vom Anwendungsentwickler erstellt werden, oder das CommandBinding könnte an ein übergeordnetes Element des Befehlsziels angefügt werden.

Befehle

Befehle in WPF werden durch Implementieren der ICommand Schnittstelle erstellt. ICommand stellt zwei Methoden, Execute und CanExecute, sowie ein Ereignis, CanExecuteChanged, bereit. Execute führt die Aktionen aus, die dem Befehl zugeordnet sind. CanExecute bestimmt, ob der Befehl auf dem aktuellen Befehlsziel ausgeführt werden kann. CanExecuteChanged wird ausgelöst, wenn der Befehls-Manager, der die Befehlsvorgänge zentralisiert, eine Änderung in der Befehlsquelle erkennt, die möglicherweise einen Befehl ungültig macht, der ausgelöst wurde, aber noch nicht von der Befehlsbindung ausgeführt wurde. Die WPF-Implementierung von ICommand ist die RoutedCommand Klasse und ist der Schwerpunkt dieser Übersicht.

Die Hauptquellen für Eingaben in WPF sind Maus, Tastatur, Freihand und geroutete Befehle. Geräteorientierte Eingaben verwenden RoutedEvent, um Objekte auf einer Anwendungsseite zu benachrichtigen, dass ein Eingabeereignis aufgetreten ist. A RoutedCommand ist nicht anders. Die Execute und CanExecute Methoden von RoutedCommand enthalten nicht die Anwendungslogik für den Befehl, sondern sie lösen Routingereignisse aus, die sich durch die Elementstruktur tunneln und verteilen, bis sie auf ein Objekt mit einem CommandBinding stoßen. Die CommandBinding enthält die Handler für diese Ereignisse, und es handelt sich um die Handler, die den Befehl ausführen. Weitere Informationen zum Ereignisrouting in WPF finden Sie unter "Übersicht über Routingereignisse".

Die Execute-Methode bei einem RoutedCommand löst die PreviewExecuted- und die Executed-Ereignisse am Befehlsziel aus. Die CanExecute-Methode auf einem RoutedCommand löst die CanExecute- und PreviewCanExecute-Ereignisse am Befehlsziel aus. Diese Ereignisse tunneln und breiten sich durch den Elementbaum aus, bis sie auf ein Objekt stoßen, das einen CommandBinding für den betreffenden Befehl hat.

WPF stellt eine Reihe gängiger Routingbefehle aus mehreren Klassen zur Auswahl: MediaCommands, , ApplicationCommands, NavigationCommands, ComponentCommandsund EditingCommands. Diese Klassen bestehen nur aus den RoutedCommand Objekten und nicht aus der Implementierungslogik des Befehls. Die Implementierungslogik liegt in der Verantwortung des Objekts, für das der Befehl ausgeführt wird.

Befehlsquellen

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

Befehlsquellen in WPF implementieren die ICommandSource Schnittstelle im Allgemeinen.

ICommandSource macht drei Eigenschaften verfügbar: Command, , CommandTargetund CommandParameter:

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

  • CommandTarget ist das Objekt, für das der Befehl ausgeführt werden soll. Beachten Sie, dass die CommandTarget-Eigenschaft auf ICommandSource in WPF nur anwendbar ist, wenn ICommand ein RoutedCommand ist. Wenn die CommandTarget-Einstellung auf einem ICommandSource erfolgt und der entsprechende Befehl kein RoutedCommand ist, wird das Befehlsziel ignoriert. Wenn dies CommandTarget nicht festgelegt ist, ist das Element mit Tastaturfokus das Befehlsziel.

  • 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 bei einem Klick auf, und ein InputBinding wird aufgerufen, wenn der damit verbundene InputGesture ausgeführt wird.

Das folgende Beispiel zeigt, wie Sie eine MenuItem in einer ContextMenu Befehlsquelle für den Properties Befehl verwenden.

<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 lauscht eine Befehlsquelle auf das CanExecuteChanged Ereignis. Dieses Ereignis informiert die Befehlsquelle, dass sich die Fähigkeit des Befehls zur Ausführung auf dem aktuellen Befehlsziel möglicherweise geändert hat. Die Befehlsquelle kann den aktuellen Status von RoutedCommand abfragen, indem sie die Methode CanExecute verwendet. Die Befehlsquelle kann sich dann selbst deaktivieren, wenn der Befehl nicht ausgeführt werden kann. Ein Beispiel hierfür ist, dass eine MenuItem selbst grau wird, wenn ein Befehl nicht ausgeführt werden kann.

Eine InputGesture kann als Befehlsquelle verwendet werden. Zwei Arten von Eingabegesten in WPF sind die KeyGesture und MouseGesture. Sie können sich eine KeyGesture als Tastenkombination wie STRG+C vorstellen. A KeyGesture besteht aus einer Key und einer Reihe von ModifierKeys. A MouseGesture besteht aus einer MouseAction und einer optionalen Gruppe von ModifierKeys.

Damit eine InputGesture Befehlsquelle als Befehlsquelle fungiert, muss sie einem Befehl zugeordnet sein. Es gibt einige Möglichkeiten, dies zu erreichen. Eine Möglichkeit besteht darin, eine InputBinding.

Das folgende Beispiel zeigt, wie man einen KeyBinding zwischen einem KeyGesture und einem RoutedCommand erstellt.

<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, ein InputGesture mit einem RoutedCommand zu verknüpfen, besteht darin, das InputGesture zum InputGestureCollection auf dem RoutedCommand hinzuzufügen.

Im folgenden Beispiel wird gezeigt, wie Sie eine KeyGesture zur InputGestureCollection eines RoutedCommand hinzufügen.

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)

CommandBinding

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

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

Command ist der Befehl, dem die CommandBinding zugeordnet ist. Die Ereignishandler, die an die Ereignisse PreviewExecuted und Executed angefügt sind, implementieren die Befehlslogik. Die Ereignishandler, die an die Ereignisse PreviewCanExecute und CanExecute angefügt sind, bestimmen, ob der Befehl auf dem aktuellen Befehlsziel ausgeführt werden kann.

Im folgenden Beispiel wird gezeigt, wie Sie ein CommandBinding im Stamm Window einer Anwendung erstellen. Der CommandBinding Befehl ordnet den Open Befehl Executed und CanExecute den Handlern zu.

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

Zunächst werden ExecutedRoutedEventHandler und eine CanExecuteRoutedEventHandler erstellt. Das ExecutedRoutedEventHandler öffnet ein MessageBox, das einen Text anzeigt, dass der Befehl ausgeführt wurde. CanExecuteRoutedEventHandler setzt die Eigenschaft CanExecute auf 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

A CommandBinding wird an ein bestimmtes Objekt angefügt, z. B. dem Stamm Window der Anwendung oder eines Steuerelements. Das Objekt, an das die CommandBinding Bindung angefügt ist, definiert den Bereich der Bindung. Beispielsweise kann ein CommandBinding an ein Vorgänger des Befehlsziels angefügtes Element durch das Executed Ereignis erreicht werden, aber ein CommandBinding an ein untergeordnetes Element des Befehlsziels angefügtes Element kann nicht erreicht werden. Dies ist eine direkte Folge der Art und Weise, wie ein RoutedEvent vom Objekt, das das Ereignis auslöst, tunnelt und blubbert.

In einigen Fällen wird die CommandBinding direkt am Befehlsziel angebracht, z. B. mit der TextBox Klasse und den Cut, Copy und Paste Befehlen. Häufig ist es jedoch praktischer, das CommandBinding Element an einen Vorgänger des Befehlsziels anzufügen, z. B. das Hauptobjekt Window oder das Application-Objekt, insbesondere, wenn dasselbe CommandBinding für mehrere Befehlsziele verwendet werden kann. Dies sind Entwurfsentscheidungen, die Sie berücksichtigen möchten, wenn Sie Ihre Befehlsinfrastruktur erstellen.

Befehlsziel

Das Befehlsziel ist das Element, auf dem der Befehl ausgeführt wird. In Bezug auf ein RoutedCommand ist das Element, das als Ziel der Befehle fungiert, das Element, bei dem die Weiterleitung von Executed und CanExecute beginnt. Wie bereits erwähnt, gilt die CommandTarget-Eigenschaft in WPF nur, wenn ICommandSource ein ICommand ist auf RoutedCommand. Wenn die CommandTarget-Einstellung auf einem ICommandSource erfolgt 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 Tastaturfokus als Befehlsziel verwendet. Einer der Vorteile der Verwendung des Elements mit Tastaturfokus als Befehlsziel besteht darin, dass der Anwendungsentwickler dieselbe Befehlsquelle verwenden kann, um einen Befehl auf mehreren Zielen aufzurufen, ohne das Befehlsziel nachverfolgen zu müssen. Wenn z. B. ein MenuItem Aufruf des Befehls "Einfügen" in einer Anwendung mit einem TextBox Steuerelement und einem PasswordBox Steuerelement erfolgt, kann das Ziel entweder das TextBox Oder PasswordBox abhängig davon sein, welches Steuerelement den Tastaturfokus hat.

Das folgende Beispiel zeigt, wie das Befehlsziel explizit im Markup und im Code-Behind festgelegt wird.

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

Das CommandManager erfüllt eine Vielzahl von befehlsbezogenen Funktionen. Es stellt eine Reihe statischer Methoden bereit, um PreviewExecuted, Executed, PreviewCanExecute und CanExecute Ereignishandler zu einem bestimmten Element hinzuzufügen und zu entfernen. Es bietet eine Möglichkeit zum Registrieren von CommandBinding- und InputBinding-Objekten auf eine spezifische Klasse. Das CommandManager bietet auch eine Möglichkeit, einen Befehl über das RequerySuggested Ereignis zu benachrichtigen, wenn das CanExecuteChanged Ereignis ausgelöst werden soll.

Die Methode InvalidateRequerySuggested erzwingt, dass CommandManager das Ereignis RequerySuggested auslöst. Dies ist nützlich für Bedingungen, die einen Befehl deaktivieren/aktivieren sollten, von denen CommandManager jedoch keine Kenntnis hat.

Befehlsbibliothek

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

Viele dieser Befehle enthalten eine Reihe von Standardeingabebindungen. Wenn Sie beispielsweise angeben, dass Ihre Anwendung den Kopierbefehl verarbeitet, erhalten Sie automatisch die Tastaturbindung "STRG+C". Sie erhalten auch Bindungen für andere Eingabegeräte, z. B. Tablet PC-Stiftgesten und Sprachinformationen.

Wenn Sie auf Befehle in den verschiedenen Befehlsbibliotheken mit XAML verweisen, können Sie in der Regel den Klassennamen der Bibliotheksklasse weglassen, die die statische Befehlseigenschaft verfügbar macht. Im Allgemeinen sind die Befehlsnamen unzweideutig als Zeichenfolgen, und die eigenen Typen sind vorhanden, um eine logische Gruppierung von Befehlen bereitzustellen, sind jedoch nicht für die Mehrdeutigkeit erforderlich. Beispielsweise können Sie Command="Cut" angeben, anstatt die ausführlichere Command="ApplicationCommands.Cut" zu verwenden. Dies ist ein Bequemlichkeitsmechanismus, der in den WPF-XAML-Prozessor für Befehle integriert ist (genauer gesagt handelt es sich um ein Typkonverterverhalten von ICommand, auf welches der WPF-XAML-Prozessor zur Ladezeit verweist).

Erstellen benutzerdefinierter Befehle

Wenn die Befehle in den Befehlsbibliotheksklassen nicht Ihren Anforderungen entsprechen, können Sie eigene Befehle erstellen. Es gibt zwei Möglichkeiten zum Erstellen eines benutzerdefinierten Befehls. Die erste besteht darin, von Grund auf zu beginnen und die ICommand Schnittstelle zu implementieren. Die andere Möglichkeit und der häufigere Ansatz besteht darin, ein RoutedCommand oder ein RoutedUICommand zu erstellen.

Ein Beispiel zum Erstellen eines benutzerdefinierten RoutedCommand finden Sie unter dem Beispiel für eine benutzerdefinierte RoutedCommand-Erstellung.

Siehe auch