(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

ICommandSource-Schnittstelle

Definiert ein Objekt, das einen Befehl aufrufen kann.

Namespace:  System.Windows.Input
Assembly:  PresentationCore (in PresentationCore.dll)

public interface ICommandSource

Der ICommandSource-Typ macht die folgenden Member verfügbar.

  NameBeschreibung
Öffentliche EigenschaftCommandRuft den Befehl ab, der ausgeführt wird, wenn die Befehlsquelle aufgerufen wird.
Öffentliche EigenschaftCommandParameterStellt einen benutzerdefinierten Datenwert dar, der bei der Ausführung an den Befehl übergeben werden kann.
Öffentliche EigenschaftCommandTargetDas Objekt, für das der Befehl ausgeführt wird.
Zum Seitenanfang

Die Befehlsquelle definiert, wie ein Befehl vom jeweiligen Objekt aufgerufen wird. Wenn einem Befehl beispielsweise ein Button zugeordnet ist, wird der Befehl beim Klicken auf den Button aufgerufen.

Eine Befehlsquelle deaktiviert sich i. d. R. selbst, wenn der zugeordnete Befehl für das aktuelle Befehlsziel nicht ausgeführt werden kann. Ein MenuItem, das dem Paste-Befehl zugeordnet ist, unterlegt sich beispielsweise selbsttätig grau, wenn der Paste-Befehl für das aktuelle Befehlsziel nicht ausgeführt werden kann.

Normalerweise überwacht die Befehlsquelle das CanExecuteChanged-Ereignis für den Befehl. Diese informiert die Befehlsquelle, wenn sich Bedingungen für das Befehlsziel ändern, z. B. den Verlust des Tastaturfokus. Dann kann die Befehlsquelle den Befehl abfragen, indem die CanExecute-Methode verwendet wird.

Einige der Klassen in WPF, die ICommandSource implementieren, sind: ButtonBase, MenuItem und Hyperlink.

Im Windows Presentation Foundation (WPF)-Befehlssystem ist die CommandTarget-Eigenschaft einer ICommandSource nur anwendbar, wenn der ICommand ein RoutedCommand ist. Wenn das CommandTarget auf eine ICommandSource festgelegt wurde und der entsprechende Befehl kein RoutedCommand ist, wird das Befehlsziel ignoriert.

Dieses Beispiel zeigt, wie Sie eine Befehlsquelle erstellen, indem Sie ICommandSource implementieren. Eine Befehlsquelle ist ein Objekt, das weiß, wie ein Befehl aufgerufen wird. Die ICommandSource-Schnittstelle verfügt über drei Methoden: Command, CommandParameter und CommandTarget. Command ist der Befehl, der aufgerufen wird. Der CommandParameter ist ein benutzerdefinierter Datentyp, der von der Befehlsquelle an die Methode übergeben wird, die den Befehl verarbeitet. CommandTarget ist das Objekt, für das der Befehl ausgeführt wird.

In diesem Beispiel wird eine Klasse erstellt, die das Slider-Steuerelement als Unterklasse festlegt und ICommandSource implementiert.

WPF stellt verschiedene Klassen bereit, die das ICommandSource-Element implementieren, z. B. Button, MenuItem und ListBoxItem. Eine Befehlsquelle definiert, wie ein Befehl aufgerufen wird. Button und MenuItem rufen einen Befehl auf, wenn darauf geklickt wird. Ein ListBoxItem ruft einen Befehl auf, wenn darauf doppelt geklickt wird. Diese Klassen werden nur zu einer Befehlsquelle, wenn ihre Command-Eigenschaft festgelegt wird.

In diesem Beispiel wird der Befehl aufgerufen, wenn der Schieberegler verschoben wird, also eigentlich, wenn sich die Value-Eigenschaft ändert.

Unten ist die Klassendefinition angegeben.


public class CommandSlider : Slider, ICommandSource
{
    public CommandSlider() : base()
    {

    }


Der nächste Schritt besteht darin, die ICommandSource-Member zu implementieren. In diesem Beispiel werden die Eigenschaften als DependencyProperty-Objekte implementiert. Auf diese Weise können die Eigenschaften die Datenbindung verwenden. Weitere Informationen zur DependencyProperty-Klasse finden Sie unter Übersicht über Abhängigkeitseigenschaften. Weitere Informationen zur Datenbindung finden Sie unter Übersicht über Datenbindung.

Hier ist nur die Command-Eigenschaft dargestellt.


// Make Command a dependency property so it can use databinding.
public static readonly DependencyProperty CommandProperty =
    DependencyProperty.Register(
        "Command",
        typeof(ICommand),
        typeof(CommandSlider),
        new PropertyMetadata((ICommand)null,
        new PropertyChangedCallback(CommandChanged)));

public ICommand Command
{
    get 
    {
        return (ICommand)GetValue(CommandProperty);
    }
    set 
    {
        SetValue(CommandProperty, value);
    }
}


Im Folgenden ist der Rückruf der DependencyProperty-Änderung dargestellt.


// Command dependency property change callback.
private static void CommandChanged(DependencyObject d,
    DependencyPropertyChangedEventArgs e)
{
    CommandSlider cs = (CommandSlider)d;
    cs.HookUpCommand((ICommand)e.OldValue,(ICommand)e.NewValue);
}


Der nächste Schritt besteht darin, den Befehl hinzuzufügen und zu entfernen, der der Befehlsquelle zugeordnet ist. Die Command-Eigenschaft kann nicht einfach überschrieben werden, wenn ein neuer Befehl hinzugefügt wird, da die Ereignishandler, die dem vorherigen Befehl (falls vorhanden) zugeordnet sind, zuerst entfernt werden müssen.


// Add a new command to the Command Property.
private void HookUpCommand(ICommand oldCommand, ICommand newCommand)
{
    // If oldCommand is not null, then we need to remove the handlers.
    if (oldCommand != null)
    {
        RemoveCommand(oldCommand, newCommand);
    }
    AddCommand(oldCommand, newCommand);
}

// Remove an old command from the Command Property.
private void RemoveCommand(ICommand oldCommand, ICommand newCommand)
{
    EventHandler handler = CanExecuteChanged;
    oldCommand.CanExecuteChanged -= handler;
}

// Add the command.
private void AddCommand(ICommand oldCommand, ICommand newCommand)
{
    EventHandler handler = new EventHandler(CanExecuteChanged);
    canExecuteChangedHandler = handler;
    if (newCommand != null)
    {
        newCommand.CanExecuteChanged += canExecuteChangedHandler;
    }
}


Der letzte Schritt besteht darin, die Logik für den CanExecuteChanged-Handler und die Execute-Methode zu erstellen.

Das CanExecuteChanged-Ereignis benachrichtigt die Befehlsquelle, dass sich die Fähigkeit des Befehls, für das aktuelle Befehlsziel ausgeführt zu werden, ggf. geändert hat. Wenn eine Befehlsquelle dieses Ereignis empfängt, ruft es für den Befehl normalerweise die CanExecute-Methode auf. Wenn der Befehl für das aktuelle Befehlsziel nicht ausgeführt werden kann, deaktiviert sich die Befehlsquelle in der Regel selbst. Wenn der Befehl für das aktuelle Befehlsziel ausgeführt werden kann, aktiviert sich die Befehlsquelle in der Regel selbst.


private void CanExecuteChanged(object sender, EventArgs e)
{

    if (this.Command != null)
    {
        RoutedCommand command = this.Command as RoutedCommand;

        // If a RoutedCommand.
        if (command != null)
        {
            if (command.CanExecute(CommandParameter, CommandTarget))
            {
                this.IsEnabled = true;
            }
            else
            {
                this.IsEnabled = false;
            }
        }
        // If a not RoutedCommand.
        else
        {
            if (Command.CanExecute(CommandParameter))
            {
                this.IsEnabled = true;
            }
            else
            {
                this.IsEnabled = false;
            }
        }
    }
}


Der letzte Schritt ist die Execute-Methode. Wenn es sich bei einem Befehl um einen RoutedCommand handelt, wird die RoutedCommand-Execute-Methode aufgerufen. Andernfalls wird die ICommand Execute-Methode aufgerufen.


// If Command is defined, moving the slider will invoke the command;
// Otherwise, the slider will behave normally.
protected override void OnValueChanged(double oldValue, double newValue)
{
    base.OnValueChanged(oldValue, newValue);

    if (this.Command != null)
    {
        RoutedCommand command = Command as RoutedCommand;

        if (command != null)
        {
            command.Execute(CommandParameter, CommandTarget);
        }
        else
        {
            ((ICommand)Command).Execute(CommandParameter);
        }
    }
}


.NET Framework

Unterstützt in: 4.5, 4, 3.5, 3.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

Es werden nicht alle Versionen sämtlicher Plattformen von .NET Framework unterstützt.. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft