ICommand Interfaccia

  • Riferimento

Definizione

Spazio dei nomi:
Microsoft.UI.Xaml.Input
Modifica

Definisce il comportamento del comando di un elemento interattivo dell'interfaccia utente che esegue un'azione quando viene richiamata, ad esempio l'invio di un messaggio di posta elettronica, l'eliminazione di un elemento o l'invio di un modulo.

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
Derivato
Attributi
ContractVersionAttribute GuidAttribute

Esempio

In questo caso viene definito un comando che inoltra semplicemente la funzionalità ad altri oggetti.

Vedi l'esempio di nozioni di base dell'interfaccia utente (XAML) per l'applicazione completa.

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

Commenti

XamlUICommand implementa questa ICommand interfaccia per C++ o System.Windows.Input.ICommand per C# (aggiungendo varie proprietà, metodi ed eventi dell'interfaccia utente).

Per un esempio di base, vedere il controllo Button , che richiama un comando quando un utente lo fa clic. Esistono due modi per gestire l'esperienza dei comandi:

  • Gestire l'evento Click
  • Associare la Command proprietà a un'implementazione ICommand che descrive la logica del comando

Metodi

CanExecute(Object)

Recupera un valore che indica se il comando può essere eseguito nello stato corrente.
Execute(Object)

Definisce il metodo da chiamare quando il comando viene richiamato.

Eventi

CanExecuteChanged

Si verifica ogni volta che si verifica un evento che influisce sul fatto che il comando possa essere eseguito.

Si applica a

Vedi anche