MvvMCross bind command with parameter (in C# code) - binding

Question

How can I bind a command to a button in code in MvvMCross (Xamarin.iOS) with specifying a command parameter?
// command definition
public MvxCommand SaveDealerDataCommand
{
get { return new MvxCommand<bool>(DoSaveDealerDataAction); }
}
public void DoSaveDealerDataAction(bool show)
{
//...
}
// binding
bindingset.Bind(saveButton).To(vm => vm.SaveDealerDataCommand);
Where can I specify the parameter (true/false) that will be passed to the command?

Answer 1

Android and iOS buttons don't have CommandParameter properties in the same way that Windows ones do.
However, MvvmCross did recently introduce a way to introduce CommandParameter bindings via Value Converters - see http://slodge.blogspot.co.uk/2013/06/commandparameter-binding.html
This binding should work as:
bindingset
.Bind(saveButton)
.To(vm => vm.SaveDealerDataCommand)
.WithConversion("CommandParameter", true);
or:
bindingset
.Bind(saveButton)
.To(vm => vm.SaveDealerDataCommand)
.WithConversion(new MvxCommandParameterValueConverter(), true);
Note that this CommandParameter binding isn't completely in the 3.0.8.1 package which is the stable nuget release, so to make this work you may need to either:
Add this manual value converter registration in your Setup.cs
protected override void FillValueConverters(IMvxValueConverterRegistry registry)
{
base.FillValueConverters(registry);
registry.AddOrOverwrite(
"CommandParameter",
new Cirrious.MvvmCross.Binding.MvxCommandParameterValueConverter()
);
}
Or use one of the beta nuget packages uploaded since 3.0.8.1 (set nuget to include prereleases to see these packages).
Or build the source yourself

Answer 2

To achieve your dynamic command parameter using the text in one of your UITextField controls, you could bind the text in that UITextField to a string property on you ViewModel and the code that runs in your button's bound command would be able to access the value via that property when it executes.
In your ViewController, something like:
UITextField textField = new UTextField();
textField.Frame = new RectangleF(0,0,120,30);
Add(textField);
UIButton button = new UIButton();
button.Frame = new RectangleF(70,40,50,30);
button.SetTitle("Click Me");
Add(button);
var bindingSet = this.CreateBindingSet<MyView, MyViewModel>();
bindingSet.Bind(textField).To(vm => vm.StringProperty);
bindingSet.Bind(button).To(vm => vm.ClickCommand);
bindingSet.Apply();
Then, in your ViewModel:
private string _stringProperty = string.Empty;
public string StringProperty
{
get { return _stringProperty; }
set
{
_stringProperty = value;
RaisePropertyChanged(() => StringProperty);
}
}
public ICommand ClickCommand
{
get
{
return new MvxCommand(HandleClick);
}
}
public void HandleClick()
{
//Code that accesses StringProperty (which contains the UITextField's value)
}

Answer 3

To pass a dynamic command parameters to the command in the view model you could create a new class e.g. like this DynamicCommandParameterValueConverter:
/// <summary>
/// This class is inspired by MvvmCross MvxCommandParameterValueConverter,
/// but because we need dynamic command parameters, we need to implement our own combined with a CustomMvxWrappingCommand.
/// </summary>
/// <typeparam name="T">The type of the 'selected item' for the command</typeparam>
/// <typeparam name="TResult">The returned result that is used as input for the command.</typeparam>
public class DynamicCommandParameterValueConverter<T, TResult> : MvxValueConverter<ICommand, ICommand>
{
private readonly Func<T, TResult> commandParameterExpression;
public DynamicCommandParameterValueConverter(Func<T, TResult> commandParameterExpression)
{
this.commandParameterExpression = commandParameterExpression;
}
protected override ICommand Convert(ICommand value, Type targetType, object parameter, CultureInfo culture)
{
return new CustomMvxWrappingCommand<T, TResult>(value, commandParameterExpression);
}
}
The CustomMvxWrappingCommand takes a Func as argument, and is later invoked and passed into the commands CanExecute/Execute method. Here is a snippet of how part of that class could look like:
public void Execute(object parameter)
{
if (wrapped == null)
{
return;
}
if (parameter != null)
{
Mvx.Warning("Non-null parameter overridden in MvxWrappingCommand");
}
wrapped.Execute(commandParameterOverride((T)parameter));
}
You could modify the MvxWrappingCommand class from Mvx to implement the above example.
The use of it all:
set.Bind(myControl).For(control => control.ItemClick).To(vm => vm.MyCommand).WithConversion(
new DynamicCommandParameterValueConverter<MyModel, string>((MyModel item) =>
{
// Do custom logic before parsing the item..
}));