ICommand Antarmuka

Referensi

Definisi

Ruang nama:: Microsoft.UI.Xaml.Input

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Edit

Menentukan perilaku perintah elemen UI interaktif yang melakukan tindakan saat dipanggil, seperti mengirim email, menghapus item, atau mengirimkan formulir.

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

Turunan: Microsoft.UI.Xaml.Input.XamlUICommand

Atribut: ContractVersionAttribute GuidAttribute

Contoh

Di sini, kami mendefinisikan perintah yang hanya menyampaikan fungsionalitasnya ke objek lain.

Lihat sampel dasar-dasar UI (XAML) untuk aplikasi lengkap.

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

Keterangan

XamlUICommand mengimplementasikan antarmuka ini ICommand untuk C++ atau System.Windows.Input.ICommand untuk C# (menambahkan berbagai properti, metode, dan peristiwa UI).

Untuk contoh dasar, lihat Kontrol tombol , yang memanggil perintah saat pengguna mengkliknya. Ada dua cara Anda mengelola pengalaman perintah:

Click Menangani peristiwa
Mengikat properti ke CommandICommand implementasi yang menjelaskan logika perintah

Metode

CanExecute(Object)	Mengambil apakah perintah dapat dijalankan dalam statusnya saat ini.
Execute(Object)	Menentukan metode yang akan dipanggil ketika perintah dipanggil.

Acara

CanExecuteChanged

Terjadi setiap kali terjadi sesuatu yang memengaruhi apakah perintah dapat dijalankan.

Berlaku untuk

Bagikan melalui