Passer des paramètres à MVVM Commande

Personne ne sait comment passer des paramètres à Command à l'aide de CommandHandler? Supposons que je voudrais faire passer la chaîne de valeur codée en dur à partir de XAML. Je sais comment passer de XAML, mais pas comment le gérer dans MVVM code derrière. Le code ci-dessous fonctionne très bien si il n'est pas nécessaire de passer des paramètres.

public ICommand AttachmentChecked
{
    get
    {
        return _attachmentChecked ?? (_attachmentChecked = new CommandHandler(() => ExecuteAttachmentChecked(), CanExecuteAttachmentChecked()));
    }
}

private void ExecuteAttachmentChecked()
{        
}

private bool CanExecuteAttachmentChecked()
{
    return true;
}

CommandHandler:

public class CommandHandler : ICommand
{
    private Action _action;
    private bool _canExecute;

    public CommandHandler(Action action, bool canExecute)
    {
        _action = action;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter)
    {
        return _canExecute;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        _action();
    }
}

OriginalL'auteur lucas | 2016-02-12

c#mvvm wpf

Vous avez besoin de changer deux choses

1.Changer votre Commandhandler pour accepter le paramètre

 public class CommandHandler : ICommand
{
    private Action<object> _action;
    private bool _canExecute;
    public CommandHandler(Action<object> action, bool canExecute)
    {
        _action = action;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter)
    {
        return _canExecute;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        _action(parameter);
    }
}

2.Modifier la méthode d'accepter la CommandParameter:

public ICommand AttachmentChecked
{
    get
    {
        return _attachmentChecked ?? (_attachmentChecked = new CommandHandler(param => ExecuteAttachmentChecked(param), CanExecuteAttachmentChecked()));
    }
}

private void ExecuteAttachmentChecked(object param)
{
 //param will the value of `CommandParameter` sent from Binding
}

private bool CanExecuteAttachmentChecked()
{
    return true;
}

OriginalL'auteur Kylo Ren

Vous devez juste écrire votre chaîne en CommandParameter:

<Button Command="{Binding NextCommand}" 
CommandParameter="Hello" 
Content="Next" />

et le changement à partir de:

private Action _action;
private bool _canExecute;

pour permettre à accepter les paramètres:

readonly Action<object> _execute;        
readonly Predicate<object> _canExecute;

En supposant que vous utilisez RelayCommand en paramètre obj de la méthode DoSmth sera "Bonjour":

public RelayCommand YourCommand { get; set; }
public YourViewModel()
{
    NextCommand = new RelayCommand(DoSmth);
}

private void DoSmth(object obj)
{
    Message.Box(obj.ToString()); 
}

OriginalL'auteur StepUp

6

Cela a déjà été répondu, mais vous ne pouvez pas savoir qu'il existe des Cadres de autour pour éviter de code réutilisable liées à des commandes (et INotifyPropertyChanged) dans MVVM.

L'un des plus célèbres est MVVM Light qui va gérer un peu les choses pour vous.

À l'aide de ce cadre, c'est la façon dont vous gérer une commande avec des paramètres :

(Note : Nous allons créer une commande qui a changé le UserControl affichées, comme le UserControl est la "partie principale" de l'application)

1) Dans votre ViewModel, de définir un RelayCommand avec le type de l'argument (dans ce cas, un UserControl)
```
public RelayCommand<UserControl> changePageCommand { get; private set; }
```
2) Définir la méthode pour être appliqué à la commande (simplifiée ici)
```
public void navigate(UserControl nextPage)
{
    currentUserControl = nextPage; 
}
```
3) Lier votre commande à la méthode que vous venez de définir
```
changePageCommand = new RelayCommand<UserControl>((page) => navigate(page));
```
Votre commande est maintenant configuré et prêt à l'emploi dans votre XAML, disons que vous voulez changer de page avec les sélections de menu, par exemple...

4) de Liaison de Commande avec le paramètre de Contrôle (XAML)
```
<Menu>
    <MenuItem Header="_Pages">
        <MenuItem Header="_Account"
                  Command="{Binding changePageCommand}"
                  CommandParameter="{Binding pageManager.accountPage}" />
        <MenuItem Header="_Profile"
                  Command="{Binding changePageCommand}"
                  CommandParameter="{Binding pageManager.profilePage}" />
    </MenuItem>
</Menu>
```
Remarque : pageManager est simplement une classe qui initialise toutes mes pages de leurs états par défaut, il y a évidemment une référence dans mon ViewModel.

Espère que cela vous aide à vous ou à quelqu'un en passant par

OriginalL'auteur Lionel Pire

Le paramètre est transmis dans le ICommand.Execute méthode, vous avez juste besoin de passer à travers à votre gestionnaire.

public class CommandHandler : ICommand
{
    private Action<object> _action;
    private bool _canExecute;
    public CommandHandler(Action<object> action, bool canExecute)
    {
        _action = action;
        _canExecute = canExecute;
    }

    public bool CanExecute(object parameter)
    {
        return _canExecute;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
        _action(parameter);
    }
}

OriginalL'auteur Eldar Dordzhiev

Vous devez vous connecter pour publier un commentaire.