Comment puis-je passer une variable en tant que CommandParameter

Je suis en train d'envoyer une variable à partir de ce Dernier en tant que paramètre à une commande. La commande ressemble à ceci:

public class EditPersonCommand : ICommand
{
  private bool _CanExecute = false;

  public bool CanExecute(object parameter)
  {
     PersonModel p = parameter as PersonModel;
     CanExecuteProperty = (p != null) && (p.Age > 0);
     return CanExecuteProperty;
  }

  public event EventHandler CanExecuteChanged;

  public void Execute(object parameter) { }

  private bool CanExecuteProperty
  {
     get { return _CanExecute; }
     set
     {
        if (_CanExecute != value)
        {
           _CanExecute = value;
           EventHandler can_execute = CanExecuteChanged;
           if (can_execute != null)
           {
              can_execute.Invoke(this, EventArgs.Empty);
           }
        }
     }
  }
}

Le ViewModel ressemble à ceci:

public class PersonViewModel : ViewModelBase
{
  private PersonModel _PersonModel;
  private EditPersonCommand _EditPersonCommand;

  ///<remarks>
  ///must use the parameterless constructor to satisfy <Window.Resources>
  ///</remarks>
  public PersonViewModel()
     : this(new PersonModel())
  {

  }

  public PersonViewModel(PersonModel personModel)
  {
     _PersonModel = personModel;
  }

  public ICommand EditPersonCommand
  {
     get
     {
        if (_EditPersonCommand == null)
        {
           _EditPersonCommand = new EditPersonCommand();
        }
        return _EditPersonCommand;
     }
  }
}

Le xaml ressemble à ceci:

<Button Content="Edit" HorizontalAlignment="Right" Height="20" Width="80"
   Command="{Binding EditPersonCommand}" 
   CommandParameter="{Binding _PersonModel}" />

J'ai essayé de créer une propriété du ViewModel au lieu d'utiliser le privé nom de variable locale, mais qui n'a pas fonctionné non plus. Le object parameter montre toujours null dans l'appel à CanExecute et le bouton n'est jamais activé. Si je change le CommandParameter de la valeur à Hello, puis-je recevoir Hello dans l'appel à CanExecute, donc je ne suis pas sûr pourquoi, la variable ne fonctionne pas. Toute aide serait appréciée.

Mise à jour: j'ai aussi essayé de faire un bien public pour le modèle (que je n'ai pas vraiment envie d'exposer le modèle, mais juste essayé pour voir si ça fonctionne, mais il ne marche pas).

//Added this to the ViewModel
public PersonModel PersonModelProp
{
  get
  {
     return _PersonModel;
  }
  set
  {
     _PersonModel = value;
     OnPropertyChanged("PersonModelProp");
  }
}

Et changé le code xaml:

<Button Content="Edit" HorizontalAlignment="Right" Height="20"  Width="80"
   Command="{Binding EditPersonCommand}" 
   CommandParameter="{Binding PersonModelProp}" />

Mais toujours pas de chance. Le ViewModel ne mettre en œuvre INotifyPropertyChanged

Je fais toujours lié propriétés public, je pense qu'ils doivent être, mais pas sûr à ce sujet.
Pas la cause du problème, mais de le porter CanExecuteChanged de CanExecute est faux. CanExecuteChanged doit être soulevée lors de l'appelant doit appeler CanExecute de nouveau. En fonction de votre CanExecute mise en œuvre, il faut relancer CanExecuteChanged lorsque l'âge d'une personne est changé, mais vous aurez probablement vous en sortir avec de ne jamais élever cet événement à tous, trop.
Avez-vous essayé traçage? Quelle erreur de ne yo voir?

OriginalL'auteur SwDevMan81 | 2012-09-11

c#command commandparameter mvvm wpf

Est le CommandParameter toujours la valeur null ou êtes-vous seulement de vérifier la première fois, il est en cours d'exécution?

Il semble que l'ordre dans lequel vous déclarez vos propriétés de la matière dans ce cas depuis la création de la Commande propriété entraîne l'CanExecute à feu immédiatement avant la CommandParameter a été défini.

Essayez de déplacer le CommandParameter bien avant que la Commande de la propriété:

<Button Content="Edit" HorizontalAlignment="Right" Height="20"  Width="80"
 CommandParameter="{Binding PersonModelProp}" 
 Command="{Binding EditPersonCommand}" />

Aussi, voir ici et ici.

Modifier

Pour vous assurer que vos événements sont élevés correctement, vous devriez relancer l'événement CanExecuteChanged lorsque le PersonModelProp les changements de la valeur.

La Commande:

public class EditPersonCommand : ICommand
{
  public bool CanExecute(object parameter)
  {
     PersonModel p = parameter as PersonModel;
     return p != null && p.Age > 0;
  }

  public event EventHandler CanExecuteChanged;

  public void Execute(object parameter) 
  {
      //command implementation
  }

  public void RaiseCanExecuteChanged()
  {
      var handler = CanExecuteChanged;
      if(handler != null)
      {
          handler(this, EventArgs.Empty);
      }
  }
}

Et le modèle de vue:

public class PersonViewModel : ViewModelBase
{
  private PersonModel _PersonModel;
  private EditPersonCommand _EditPersonCommand;

  ///<remarks>
  ///must use the parameterless constructor to satisfy <Window.Resources>
  ///</remarks>
  public PersonViewModel()
     : this(new PersonModel())
  {
      _EditPersonCommand = new EditPersonCommand();
  }

  public PersonViewModel(PersonModel personModel)
  {
     _PersonModel = personModel;
  }

  public ICommand EditPersonCommand
  {
     get
     {
         return _EditPersonCommand;
     }
  }

  public PersonModel PersonModelProp
  {
      get
      {
         return _PersonModel;
      }
      set
      {
         _PersonModel = value;
         OnPropertyChanged("PersonModelProp");
         EditPersonCommand.RaiseCanExecuteChanged();
      }
    }
}

Aïe. En regardant ce Button n', votre réponse est une nette amélioration mais encore incomplète. Command.CanExecute n'est jamais appelé lorsque CommandParameter changements, donc si PersonModelProp peut changer lorsque EditPersonCommand n'est pas le cas, vous n'obtiendrez pas le comportement que vous espérez pour.
Vous êtes correct. Comme vous l'avez dit dans votre commentaire d'origine, un changement doit être fait pour améliorer les CanExecuteChanged toutes les fois que les PersonModelProp des modifications de la propriété.

OriginalL'auteur Dylan Meador

7

Deux points à la réponse:

Tout d'abord, comme @akton mentionné, vous ne pouvez lier à propriétés publiques. Il n'a pas à être un DependencyProperty.

Seconde, ce qui m'a pris un tome à comprendre, c'est que vous devez définir la liaison pour le CommandParameter avant la Commande de la propriété. c'est à dire
```
<Button Content="Edit" HorizontalAlignment="Right" Height="20"  Width="80"
        CommandParameter="{Binding PersonModelProp}"
        Command="{Binding EditPersonCommand}" />
```
Espère que cela aide 🙂

Dans Visual Studio 2015 de la Communauté, toute tentative de déplacer CommandParamater ci-dessus Command seront inversés lors de l'enregistrement du document. En d'autres termes, l'enregistrement du document forces de l' CommandParameter sous la Command. C'est par défaut VS2015 comportement, comme une grande partie intact de l'installation.

OriginalL'auteur AbdouMoumen
4

_PersonModel est privé et ne peut donc pas être accessible. Créer une propriété publique qui l'expose et se lier à celui de la CommandParameter. N'oubliez pas de faire de la propriété d'une propriété de dépendance (techniquement pas obligatoire, mais ça aide) et le ViewModel devrait mettre en œuvre INotifyProperty changé et le feu de l'événement PropertyChanged de sorte que la liaison est mise à jour.

Ouais j'ai essayé d'en faire un bien public, mais qui n'a pas fonctionné non plus.
Était-ce une propriété de dépendance? Avez-vous le feu de l'événement PropertyChanged?
Voir ma mise à jour. Ce n'est pas une propriété de dépendance, mais le ViewModel ne mettre en œuvre INotifyPropertyChanged et la PropertyChanged événement est appelé. D'autres idées?
Temps pour certains binaire de débogage. Changement PersonModelProp pour retourner une codés en dur de type int et voir si cela fonctionne. Si elle le fait, c'est quelque chose de mal avec la liaison. Si cela ne fonctionne pas, il y a peut être une faute de frappe dans le code XAML ou quelque chose.
Si je change l'Hélice à un int, il encore faire le paramètre null, cependant si j'ai mis le CommandParameter avant de la liaison de Commande comme d'autres l'ont suggéré, il fonctionne. C'est étrange. Merci pour l'aide, le temps de comprendre pourquoi l'ordre des questions...

OriginalL'auteur akton

Je pense que vous avez un problème dans votre EditPersonCommand (il a pas tiré ok).J'ai vérifier avec relayCommand et il du travail!

C'est le code:

ViewModel:

 public class PersonViewModel : ViewModelBase
    {
        private PersonModel _PersonModel;
        private ICommand _EditPersonCommand;

        ///<remarks>
        ///must use the parameterless constructor to satisfy <Window.Resources>
        ///</remarks>
        public PersonViewModel()
            : this(new PersonModel())
        {

        }

        public PersonViewModel(PersonModel personModel)
        {
            PersonModelProp = personModel;
        }

        public ICommand EditPersonCommand
        {
            get
            {
                if (_EditPersonCommand == null)
                {
                    _EditPersonCommand = new RelayCommand(ExecuteEditPerson,CanExecuteEditPerson);
                }
                return _EditPersonCommand;
            }
        }


        private bool CanExecuteEditPerson(object parameter)
        {
            PersonModel p = parameter as PersonModel;

            return (p != null) && (p.Age > 0);
        }


        private void ExecuteEditPerson(object o)
        {

        }


        public PersonModel PersonModelProp
        {
            get
            {
                return _PersonModel;
            }
            set
            {
                _PersonModel = value;
                NotifyPropertyChanged("PersonModelProp");
            }
        }


    }

Et ce RelayCommand (Feu événements ok!)

      public class RelayCommand : ICommand
        {
            #region Constants and Fields


            private readonly Predicate<object> canExecute;


            private readonly Action<object> execute;

            #endregion

            #region Constructors and Destructors


            public RelayCommand(Action<object> execute)
                : this(execute, null)
            {
            }

            public RelayCommand(Action<object> execute, Predicate<object> canExecute)
            {
                if (execute == null)
                {
                    throw new ArgumentNullException("execute");
                }

                this.execute = execute;
                this.canExecute = canExecute;
            }

            #endregion

            #region Events


            public event EventHandler CanExecuteChanged
            {
                add
                {
                    CommandManager.RequerySuggested += value;
                }

                remove
                {
                    CommandManager.RequerySuggested -= value;
                }
            }

            #endregion

            #region Implemented Interfaces

            #region ICommand


            [DebuggerStepThrough]
            public bool CanExecute(object parameter)
            {
                return this.canExecute == null || this.canExecute(parameter);
            }

            public void Execute(object parameter)
            {
                this.execute(parameter);
            }

            #endregion

            #endregion
        }

Xmal:

<Button Content="Edit" HorizontalAlignment="Right" Height="20"  Width="80"
 CommandParameter="{Binding PersonModelProp}" 
 Command="{Binding EditPersonCommand}" />

OriginalL'auteur ígor

Vous devez vous connecter pour publier un commentaire.