Freigeben über

ICommand Schnittstelle

  • Referenz

Definition

Namespace:
Microsoft.UI.Xaml.Input
Bearbeiten

Definiert das Befehlsverhalten eines interaktiven UI-Elements, das beim Aufrufen eine Aktion ausführt, z. B. das Senden einer E-Mail, das Löschen eines Elements oder das Senden eines Formulars.

public interface class ICommand
/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.UI.Xaml.WinUIContract, 65536)]
/// [Windows.Foundation.Metadata.Guid(3853464898, 51815, 16513, 153, 91, 112, 157, 209, 55, 146, 223)]
struct ICommand
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.Guid(3853464898, 51815, 16513, 153, 91, 112, 157, 209, 55, 146, 223)]
public interface ICommand
Public Interface ICommand
Abgeleitet
Attribute
ContractVersionAttribute GuidAttribute

Beispiele

Hier definieren wir einen Befehl, der seine Funktionalität einfach an andere Objekte weitergibt.

Die vollständige Anwendung finden Sie im XAML-Beispiel (UI Basics ).

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
namespace AppUIBasics.Common
{
    /// <summary>
    /// A command whose sole purpose is to relay its functionality
    /// to other objects by invoking delegates.
    /// The default return value for the CanExecute method is 'true'.
    /// RaiseCanExecuteChanged needs to be called whenever
    /// CanExecute is expected to return a different value.
    /// </summary>
    public class RelayCommand : ICommand
    {
        private readonly Action _execute;
        private readonly Func<bool> _canExecute;
        /// <summary>
        /// Raised when RaiseCanExecuteChanged is called.
        /// </summary>
        public event EventHandler CanExecuteChanged;
        /// <summary>
        /// Creates a new command that can always execute.
        /// </summary>
        /// <param name="execute">The execution logic.</param>
        public RelayCommand(Action execute)
            : this(execute, null)
        {
        }
        /// <summary>
        /// Creates a new command.
        /// </summary>
        /// <param name="execute">The execution logic.</param>
        /// <param name="canExecute">The execution status logic.</param>
        public RelayCommand(Action execute, Func<bool> canExecute)
        {
            if (execute == null)
                throw new ArgumentNullException("execute");
            _execute = execute;
            _canExecute = canExecute;
        }
        /// <summary>
        /// Determines whether this RelayCommand can execute in its current state.
        /// </summary>
        /// <param name="parameter">
        /// Data used by the command. If the command does not require data to be passed,
        /// this object can be set to null.
        /// </param>
        /// <returns>true if this command can be executed; otherwise, false.</returns>
        public bool CanExecute(object parameter)
        {
            return _canExecute == null ? true : _canExecute();
        }
        /// <summary>
        /// Executes the RelayCommand on the current command target.
        /// </summary>
        /// <param name="parameter">
        /// Data used by the command. If the command does not require data to be passed,
        /// this object can be set to null.
        /// </param>
        public void Execute(object parameter)
        {
            _execute();
        }
        /// <summary>
        /// Method used to raise the CanExecuteChanged event
        /// to indicate that the return value of the CanExecute
        /// method has changed.
        /// </summary>
        public void RaiseCanExecuteChanged()
        {
            var handler = CanExecuteChanged;
            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
    }
}

Hinweise

XamlUICommand implementiert diese ICommand Schnittstelle für C++ oder System.Windows.Input.ICommand für C# (hinzufügen verschiedener UI-Eigenschaften, Methoden und Ereignisse).

Ein einfaches Beispiel finden Sie im Button-Steuerelement , das einen Befehl aufruft, wenn ein Benutzer darauf klickt. Es gibt zwei Möglichkeiten, die Befehlsoberfläche zu verwalten:

  • Behandeln des Ereignisses Click
  • Binden der Command Eigenschaft an eine ICommand Implementierung, die die Befehlslogik beschreibt

Methoden

CanExecute(Object)

Ruft ab, ob der Befehl im aktuellen Zustand ausgeführt werden kann.
Execute(Object)

Definiert die Methode, die aufgerufen wird, wenn der Befehl aufgerufen wird.

Ereignisse

CanExecuteChanged

Tritt auf, wenn etwas geschieht, das sich darauf auswirkt, ob der Befehl ausgeführt werden kann.

Gilt für:

Weitere Informationen