Pourquoi RelayCommand

Commandes sont utilisées pour séparer la sémantique et l'objet qui invoque une commande de la logique qui exécute la commande c'est-à-dire qu'il sépare le composant UI de la logique qui doit être exécutée sur l'invocation de commande. Ainsi, que vous pouvez tester la logique d'affaires séparément en utilisant des cas de test et aussi votre code D'UI est vaguement couplé à la logique d'affaires.

maintenant, cela étant dit, choisissons vos questions une à une:

quel travail fait-il faire?

j'ai ajouté les détails ci-dessus. Espérons qu'il efface l'utilisation de commandes.

Est-il utilisable pour toutes les commandes dans mon formulaire?

certains contrôles exposent la dépendance de la commande comme Button, MenuItem, etc. qui ont un événement par défaut enregistré. Pour le Bouton Click événement. Donc, si vous liez ICommand déclaré dans ViewModel avec la commande DP du bouton, il sera invoqué chaque fois que le bouton est cliqué sur.

pour les autres événements, vous pouvez lier en utilisant Interactivity triggers. Reportez-vous à la taille de l'échantillon ici comment les utiliser pour se lier à ICommand dans le ViewModel.

comment désactiver le bouton quand(a) certaines zones de texte ne sont pas rempli?

le lien que vous avez posté ne fournit pas la mise en œuvre complète de RelayCommand. Il manque le constructeur surchargé pour définir CanExecute prédicat qui joue un rôle clé dans activer / désactiver le contrôle UI auquel votre commande est liée.

lient les boîtes de textes avec certaines propriétés dans ViewModel et dans CanExecute délégué retourne false si l'un des bindings propriété est null ou vide automatiquement désactivé le contrôle de la commande est affectée.

mise en oeuvre complète de RelayCommand:

public class RelayCommand<T> : ICommand
{
    #region Fields

    readonly Action<T> _execute = null;
    readonly Predicate<T> _canExecute = null;

    #endregion

    #region Constructors

    /// <summary>
    /// Initializes a new instance of <see cref="DelegateCommand{T}"/>.
    /// </summary>
    /// <param name="execute">Delegate to execute when Execute is called on the command.  This can be null to just hook up a CanExecute delegate.</param>
    /// <remarks><seealso cref="CanExecute"/> will always return true.</remarks>
    public RelayCommand(Action<T> 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<T> execute, Predicate<T> canExecute)
    {
        if (execute == null)
            throw new ArgumentNullException("execute");

        _execute = execute;
        _canExecute = canExecute;
    }

    #endregion

    #region ICommand Members

    ///<summary>
    ///Defines the method that determines whether the command 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((T)parameter);
    }

    ///<summary>
    ///Occurs when changes occur that affect whether or not the command should execute.
    ///</summary>
    public event EventHandler CanExecuteChanged
    {
        add { CommandManager.RequerySuggested += value; }
        remove { CommandManager.RequerySuggested -= value; }
    }

    ///<summary>
    ///Defines the method to be called when the command is invoked.
    ///</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 <see langword="null" />.</param>
    public void Execute(object parameter)
    {
        _execute((T)parameter);
    }

    #endregion
}