Pourquoi RelayCommand

Commandes sont utilisées pour séparée de la sémantique et de l'objet qui appelle une commande à partir de la logique qui exécute la commande c'est à dire qu'il sépare composant de l'INTERFACE utilisateur de la logique qui doit être exécutée sur commande d'invocation. Alors, que vous pouvez tester la logique métier séparément à l'aide de cas de test et aussi votre code de l'INTERFACE utilisateur est faiblement couplé à une logique d'entreprise.

Maintenant, cela étant dit, nous allons chercher vos questions une par une:

À l'emploi que fait-il?

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 à l'exposé de Commande DependencyProperty comme le Bouton, MenuItem etc. qui ont des valeurs par défaut de l'événement sont enregistrés. Pour le Bouton c'est Click événement. Donc, si vous liez ICommand déclaré dans le ViewModel avec Bouton de Commande du DP, il sera appelée chaque fois que le bouton est cliqué.

Pour d'autres événements, vous pouvez les lier à l'aide d' Interactivity triggers. Reportez-vous à l'exemple de ici comment les utiliser pour se lier à ICommand dans le ViewModel.

---

Comment puis-je faire sur le bouton désactiver lorsque (a) certaines zone de texte(es) ne sont pas
rempli?

Le lien que vous avez posté ne fournit pas de terminer la mise en œuvre de RelayCommand. Il manque de la surcharge de constructeur pour définir CanExecute prédicat qui joue un rôle clé dans l'activation/la désactivation de l'INTERFACE de contrôle à laquelle votre commande est relié.

Lier des zones de texte avec des propriétés dans le 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.

---

La pleine mise en œuvre 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
}