ICommand Interface

  • Référence

Définition

Espace de noms:
Windows.UI.Xaml.Input
Modifier

Définit le comportement de commande d’un élément d’interface utilisateur interactif qui effectue une action lorsqu’il est appelé, comme l’envoi d’un e-mail, la suppression d’un élément ou l’envoi d’un formulaire.

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

Configuration requise pour Windows

Famille d’appareils
Windows 10 (introduit dans 10.0.10240.0)
API contract
Windows.Foundation.UniversalApiContract (introduit dans v1.0)

Exemples

Ici, nous définissons une commande qui relaie simplement ses fonctionnalités à d’autres objets.

Consultez l’exemple De base de l’interface utilisateur (XAML) pour connaître l’application complète.

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

Remarques

XamlUICommand implémente cette interface ICommand pour C++ ou System.Windows.Input.ICommand pour C# (ajout de différentes propriétés, méthodes et événements d’interface utilisateur).

Pour obtenir un exemple de base, consultez le contrôle Button , qui appelle une commande lorsqu’un utilisateur clique dessus. Il existe deux façons de gérer l’expérience de commande :

  • Gérer l’événement Click
  • Lier la propriété Command à une implémentation ICommand qui décrit la logique de commande

Méthodes

CanExecute(Object)

Récupère si la commande peut s’exécuter dans son état actuel.
Execute(Object)

Définit la méthode à appeler lorsque la commande est invoquée.

Événements

CanExecuteChanged

Se produit chaque fois que quelque chose se produit qui affecte si la commande peut s’exécuter.

S’applique à

Voir aussi