C# 如何将变量作为 CommandParameter 传递

How do I pass a variable as a CommandParameter

提问by SwDevMan81

I'm trying to send a variable from the ViewModel as a parameter to a command. The command looks like this:

我正在尝试将 ViewModel 中的变量作为参数发送给命令。该命令如下所示：

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

The ViewModel looks like this:

ViewModel 看起来像这样：

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

The xaml looks like this:

xaml 看起来像这样：

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

I've tried creating a property in the ViewModel instead of using the private local variable name, but that didnt work either. The object parameteralways shows nullin the call to CanExecuteand the button is never enabled. If I change the CommandParametervalue to Hello, then I receive Helloin the call to CanExecute, so I'm not sure why the variable doesnt work. Any help would be appreciated.

我试过在 ViewModel 中创建一个属性而不是使用私有局部变量名称，但这也不起作用。将object parameter始终显示null在调用CanExecute和按钮从未启用。如果我将CommandParameter值更改为Hello，那么我会收到Hello对 的调用CanExecute，所以我不确定为什么该变量不起作用。任何帮助，将不胜感激。

Update:I've also tried making a public property to the model (which I dont really want to expose the model, but just tried it to see if it works, but it doesnt).

更新：我也试过为模型创建一个公共属性（我真的不想公开模型，只是试过它看看它是否有效，但它没有）。

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

And changed the xaml to this:

并将 xaml 更改为：

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

But still no luck. The ViewModel does implement INotifyPropertyChanged

但仍然没有运气。ViewModel 确实实现了INotifyPropertyChanged

采纳答案by Dylan Meador

Is the CommandParameter always null or are you only checking the first time it is being executed?

CommandParameter 是否始终为空，还是仅在第一次执行时进行检查？

It appears that the order in which you declare your properties matters in this case since setting the Command property causes the CanExecute to fire immediately before the CommandParameter has been set.

在这种情况下，您声明属性的顺序似乎很重要，因为设置 Command 属性会导致 CanExecute 在设置 CommandParameter 之前立即触发。

Try moving the CommandParameter property before the Command property:

尝试在 Command 属性之前移动 CommandParameter 属性：

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

Also, see hereand here.

另外，请参阅此处和此处。

Edit

编辑

To ensure that your events are being raised properly you should raise the CanExecuteChanged event when the PersonModelPropvalue changes.

为确保正确引发事件，您应该在PersonModelProp值更改时引发 CanExecuteChanged 事件。

The Command:

命令：

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

And the view model:

和视图模型：

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

回答by akton

_PersonModelis private and so cannot be accessed. Create a public property that exposes it and bind to that in the CommandParameter. Remember to make the property a dependency property (technically not required but it helps) and the ViewModel should implement INotifyProperty changed and fire the PropertyChanged event so the binding is updated.

_PersonModel是私有的，因此无法访问。创建一个公开它的公共属性并绑定到CommandParameter. 请记住使该属性成为依赖属性（技术上不需要，但它有帮助）并且 ViewModel 应该实现 INotifyProperty 更改并触发 PropertyChanged 事件以便更新绑定。

回答by AbdouMoumen

Two points to the answer:

回答的两点：

First, as @akton mentioned, you can only bind to public properties. It doesn't have tobe a DependencyPropertythough.

首先，正如@akton 提到的，您只能绑定到公共属性。不过，它不一定是DependencyProperty。

Second, which took me some tome to figure out, is that you have to set the binding for the CommandParameterbeforethe Commandproperty. i.e.

其次，我花了一些时间才弄清楚，您必须在Command属性之前设置CommandParameter的绑定。IE

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

Hope this helps :)

希望这可以帮助 ：）

回答by ígor

I think you have a problem in your EditPersonCommand (it not fired ok).I check it with relayCommand and it work!

我认为你的 EditPersonCommand 有问题（它没有被触发）。我用relayCommand 检查它并且它工作！

This is the 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");
            }
        }


    }

And this RelayCommand (Fire events ok!)

还有这个 RelayCommand（火灾事件好！）

      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}" />