MVVM Passing EventArgs As Command Parameter

I try to keep my dependencies to a minimum, so I implemented this myself instead of going with EventToCommand of MVVMLight. Works for me so far, but feedback is welcome.

Xaml:

<i:Interaction.Behaviors> <beh:EventToCommandBehavior Command="{Binding DropCommand}" Event="Drop" PassArguments="True" /> </i:Interaction.Behaviors> 

ViewModel:

public ActionCommand<DragEventArgs> DropCommand { get; private set; } this.DropCommand = new ActionCommand<DragEventArgs>(OnDrop); private void OnDrop(DragEventArgs e) { // ... } 

EventToCommandBehavior:

/// <summary> /// Behavior that will connect an UI event to a viewmodel Command, /// allowing the event arguments to be passed as the CommandParameter. /// </summary> public class EventToCommandBehavior : Behavior<FrameworkElement> { private Delegate _handler; private EventInfo _oldEvent; // Event public string Event { get { return (string)GetValue(EventProperty); } set { SetValue(EventProperty, value); } } public static readonly DependencyProperty EventProperty = DependencyProperty.Register("Event", typeof(string), typeof(EventToCommandBehavior), new PropertyMetadata(null, OnEventChanged)); // Command public ICommand Command { get { return (ICommand)GetValue(CommandProperty); } set { SetValue(CommandProperty, value); } } public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(EventToCommandBehavior), new PropertyMetadata(null)); // PassArguments (default: false) public bool PassArguments { get { return (bool)GetValue(PassArgumentsProperty); } set { SetValue(PassArgumentsProperty, value); } } public static readonly DependencyProperty PassArgumentsProperty = DependencyProperty.Register("PassArguments", typeof(bool), typeof(EventToCommandBehavior), new PropertyMetadata(false)); private static void OnEventChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var beh = (EventToCommandBehavior)d; if (beh.AssociatedObject != null) // is not yet attached at initial load beh.AttachHandler((string)e.NewValue); } protected override void OnAttached() { AttachHandler(this.Event); // initial set } /// <summary> /// Attaches the handler to the event /// </summary> private void AttachHandler(string eventName) { // detach old event if (_oldEvent != null) _oldEvent.RemoveEventHandler(this.AssociatedObject, _handler); // attach new event if (!string.IsNullOrEmpty(eventName)) { EventInfo ei = this.AssociatedObject.GetType().GetEvent(eventName); if (ei != null) { MethodInfo mi = this.GetType().GetMethod("ExecuteCommand", BindingFlags.Instance | BindingFlags.NonPublic); _handler = Delegate.CreateDelegate(ei.EventHandlerType, this, mi); ei.AddEventHandler(this.AssociatedObject, _handler); _oldEvent = ei; // store to detach in case the Event property changes } else throw new ArgumentException(string.Format("The event '{0}' was not found on type '{1}'", eventName, this.AssociatedObject.GetType().Name)); } } /// <summary> /// Executes the Command /// </summary> private void ExecuteCommand(object sender, EventArgs e) { object parameter = this.PassArguments ? e : null; if (this.Command != null) { if (this.Command.CanExecute(parameter)) this.Command.Execute(parameter); } } } 

ActionCommand:

public class ActionCommand<T> : ICommand { public event EventHandler CanExecuteChanged; private Action<T> _action; public ActionCommand(Action<T> action) { _action = action; } public bool CanExecute(object parameter) { return true; } public void Execute(object parameter) { if (_action != null) { var castParameter = (T)Convert.ChangeType(parameter, typeof(T)); _action(castParameter); } } } 

I've always come back here for the answer so I wanted to make a short simple one to go to.

There are multiple ways of doing this:

1. Using WPF Tools. Easiest.

Add Namespaces:

• System.Windows.Interactivitiy
• Microsoft.Expression.Interactions

XAML:

Use the EventName to call the event you want then specify your Method name in the MethodName.

<Window> xmlns:wi="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity" xmlns:ei="http://schemas.microsoft.com/expression/2010/interactions"> <wi:Interaction.Triggers> <wi:EventTrigger EventName="SelectionChanged"> <ei:CallMethodAction TargetObject="{Binding}" MethodName="ShowCustomer"/> </wi:EventTrigger> </wi:Interaction.Triggers> </Window> 

Code:

public void ShowCustomer() { // Do something. } 

2. Using MVVMLight. Most difficult.

Install GalaSoft NuGet package.

Get the namespaces:

• System.Windows.Interactivity
• GalaSoft.MvvmLight.Platform

XAML:

Use the EventName to call the event you want then specify your Command name in your binding. If you want to pass the arguments of the method, mark PassEventArgsToCommand to true.

<Window> xmlns:wi="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity" xmlns:cmd="http://www.galasoft.ch/mvvmlight"> <wi:Interaction.Triggers> <wi:EventTrigger EventName="Navigated"> <cmd:EventToCommand Command="{Binding CommandNameHere}" PassEventArgsToCommand="True" /> </wi:EventTrigger> </wi:Interaction.Triggers> </Window> 

Code Implementing Delegates: Source

You must get the Prism MVVM NuGet package for this.

using Microsoft.Practices.Prism.Commands; // With params. public DelegateCommand<string> CommandOne { get; set; } // Without params. public DelegateCommand CommandTwo { get; set; } public MainWindow() { InitializeComponent(); // Must initialize the DelegateCommands here. CommandOne = new DelegateCommand<string>(executeCommandOne); CommandTwo = new DelegateCommand(executeCommandTwo); } private void executeCommandOne(string param) { // Do something here. } private void executeCommandTwo() { // Do something here. } 

Code Without DelegateCommand: Source

using GalaSoft.MvvmLight.CommandWpf public MainWindow() { InitializeComponent(); CommandOne = new RelayCommand<string>(executeCommandOne); CommandTwo = new RelayCommand(executeCommandTwo); } public RelayCommand<string> CommandOne { get; set; } public RelayCommand CommandTwo { get; set; } private void executeCommandOne(string param) { // Do something here. } private void executeCommandTwo() { // Do something here. } 

3. Using Telerik EventToCommandBehavior. It's an option.

You'll have to download it's NuGet Package.

XAML:

<i:Interaction.Behaviors> <telerek:EventToCommandBehavior Command="{Binding DropCommand}" Event="Drop" PassArguments="True" /> </i:Interaction.Behaviors> 

Code:

public ActionCommand<DragEventArgs> DropCommand { get; private set; } this.DropCommand = new ActionCommand<DragEventArgs>(OnDrop); private void OnDrop(DragEventArgs e) { // Do Something } 

For people just finding this post, you should know that in newer versions (not sure on the exact version since official docs are slim on this topic) the default behavior of the InvokeCommandAction, if no CommandParameter is specified, is to pass the args of the event it's attached to as the CommandParameter. So the originals poster's XAML could be simply written as:

<i:Interaction.Triggers> <i:EventTrigger EventName="Navigated"> <i:InvokeCommandAction Command="{Binding NavigatedEvent}"/> </i:EventTrigger> </i:Interaction.Triggers> 

Then in your command, you can accept a parameter of type NavigationEventArgs (or whatever event args type is appropriate) and it will automatically be provided.

I know this is a fairly old question, but I ran into the same problem today and wasn't too interested in referencing all of MVVMLight just so I can use event triggers with event args. I have used MVVMLight in the past and it's a great framework, but I just don't want to use it for my projects any more.

What I did to resolve this problem was create an ULTRA minimal, EXTREMELY adaptable custom trigger action that would allow me to bind to the command and provide an event args converter to pass on the args to the command's CanExecute and Execute functions. You don't want to pass the event args verbatim, as that would result in view layer types being sent to the view model layer (which should never happen in MVVM).

Here is the EventCommandExecuter class I came up with:

public class EventCommandExecuter : TriggerAction<DependencyObject> { #region Constructors public EventCommandExecuter() : this(CultureInfo.CurrentCulture) { } public EventCommandExecuter(CultureInfo culture) { Culture = culture; } #endregion #region Properties #region Command public ICommand Command { get { return (ICommand)GetValue(CommandProperty); } set { SetValue(CommandProperty, value); } } public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(EventCommandExecuter), new PropertyMetadata(null)); #endregion #region EventArgsConverterParameter public object EventArgsConverterParameter { get { return (object)GetValue(EventArgsConverterParameterProperty); } set { SetValue(EventArgsConverterParameterProperty, value); } } public static readonly DependencyProperty EventArgsConverterParameterProperty = DependencyProperty.Register("EventArgsConverterParameter", typeof(object), typeof(EventCommandExecuter), new PropertyMetadata(null)); #endregion public IValueConverter EventArgsConverter { get; set; } public CultureInfo Culture { get; set; } #endregion protected override void Invoke(object parameter) { var cmd = Command; if (cmd != null) { var param = parameter; if (EventArgsConverter != null) { param = EventArgsConverter.Convert(parameter, typeof(object), EventArgsConverterParameter, CultureInfo.InvariantCulture); } if (cmd.CanExecute(param)) { cmd.Execute(param); } } } } 

This class has two dependency properties, one to allow binding to your view model's command, the other allows you to bind the source of the event if you need it during event args conversion. You can also provide culture settings if you need to (they default to the current UI culture).

This class allows you to adapt the event args so that they may be consumed by your view model's command logic. However, if you want to just pass the event args on verbatim, simply don't specify an event args converter.

The simplest usage of this trigger action in XAML is as follows:

<i:Interaction.Triggers> <i:EventTrigger EventName="NameChanged"> <cmd:EventCommandExecuter Command="{Binding Path=Update, Mode=OneTime}" EventArgsConverter="{x:Static c:NameChangedArgsToStringConverter.Default}"/> </i:EventTrigger> </i:Interaction.Triggers> 

If you needed access to the source of the event, you would bind to the owner of the event

<i:Interaction.Triggers> <i:EventTrigger EventName="NameChanged"> <cmd:EventCommandExecuter Command="{Binding Path=Update, Mode=OneTime}" EventArgsConverter="{x:Static c:NameChangedArgsToStringConverter.Default}" EventArgsConverterParameter="{Binding ElementName=SomeEventSource, Mode=OneTime}"/> </i:EventTrigger> </i:Interaction.Triggers> 

(this assumes that the XAML node you're attaching the triggers to has been assigned x:Name="SomeEventSource"

This XAML relies on importing some required namespaces

xmlns:cmd="clr-namespace:MyProject.WPF.Commands" xmlns:c="clr-namespace:MyProject.WPF.Converters" xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity" 

and creating an IValueConverter (called NameChangedArgsToStringConverter in this case) to handle the actual conversion logic. For basic converters I usually create a default static readonly converter instance, which I can then reference directly in XAML as I have done above.

The benefit of this solution is that you really only need to add a single class to any project to use the interaction framework much the same way that you would use it with InvokeCommandAction. Adding a single class (of about 75 lines) should be much more preferable to an entire library to accomplish identical results.

NOTE

this is somewhat similar to the answer from @adabyron but it uses event triggers instead of behaviours. This solution also provides an event args conversion ability, not that @adabyron's solution could not do this as well. I really don't have any good reason why I prefer triggers to behaviours, just a personal choice. IMO either strategy is a reasonable choice.

To add to what joshb has stated already - this works just fine for me. Make sure to add references to Microsoft.Expression.Interactions.dll and System.Windows.Interactivity.dll and in your xaml do:

 xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity" 

I ended up using something like this for my needs. This shows that you can also pass a custom parameter:

<i:Interaction.Triggers> <i:EventTrigger EventName="SelectionChanged"> <i:InvokeCommandAction Command="{Binding Path=DataContext.RowSelectedItem, RelativeSource={RelativeSource AncestorType={x:Type Window}}}" CommandParameter="{Binding Path=SelectedItem, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=DataGrid}}" /> </i:EventTrigger> </i:Interaction.Triggers> 

Prism's InvokeCommandAction will pass the event args by default if CommandParameter is not set.

https://learn.microsoft.com/en-us/previous-versions/msp-n-p/gg405494(v=pandp.40)#passing-eventargs-parameters-to-the-command

Here is an example. Note the use of prism:InvokeCommandAction instead of i:InvokeCommandAction.

<i:Interaction.Triggers> <i:EventTrigger EventName="Sorting"> <prism:InvokeCommandAction Command="{Binding SortingCommand}"/> </i:EventTrigger> </i:Interaction.Triggers> 

The ViewModel

 private DelegateCommand<EventArgs> _sortingCommand; public DelegateCommand<EventArgs> SortingCommand => _sortingCommand ?? (_sortingCommand = new DelegateCommand<EventArgs>(OnSortingCommand)); private void OnSortingCommand(EventArgs obj) { //do stuff } 

There is a new version of the Prismlibrary documentation.

I don't think you can do that easily with the InvokeCommandAction - I would take a look at EventToCommand from MVVMLight or similar.

I know it's a bit late but, Microsoft has made their Xaml.Behaviors open source and it's now much easier to use interactivity with just one namespace.

1. First add Microsoft.Xaml.Behaviors.Wpf Nuget packge to your project.
   https://www.nuget.org/packages/Microsoft.Xaml.Behaviors.Wpf/
2. add xmlns:behaviours="http://schemas.microsoft.com/xaml/behaviors" namespace to your xaml.

Then use it like this,

<Button Width="150" Style="{DynamicResource MaterialDesignRaisedDarkButton}"> <behaviours:Interaction.Triggers> <behaviours:EventTrigger EventName="Click"> <behaviours:InvokeCommandAction Command="{Binding OpenCommand}" PassEventArgsToCommand="True"/> </behaviours:EventTrigger> </behaviours:Interaction.Triggers> Open </Button> 

PassEventArgsToCommand="True" should be set as True and the RelayCommand that you implement can take RoutedEventArgs or objects as template. If you are using object as the parameter type just cast it to the appropriate event type.

The command will look something like this,

OpenCommand = new RelayCommand<object>(OnOpenClicked, (o) => { return true; }); 

The command method will look something like this,

private void OnOpenClicked(object parameter) { Logger.Info(parameter?.GetType().Name); } 

The 'parameter' will be the Routed event object.

And the log incase you are curious,

2020-12-15 11:40:36.3600|INFO|MyApplication.ViewModels.MainWindowViewModel|RoutedEventArgs

As you can see the TypeName logged is RoutedEventArgs

RelayCommand impelmentation can be found here.

Why RelayCommand

PS : You can bind to any event of any control. Like Closing event of Window and you will get the corresponding events.

With Behaviors and Actions in Blend for Visual Studio 2013 you can use the InvokeCommandAction. I tried this with the Drop event and although no CommandParameter was specified in the XAML, to my surprise, the Execute Action parameter contained the DragEventArgs. I presume this would happen for other events but have not tested them.

What I do is to use InvokeCommandAction to bind the control loaded event to a command in the view model, give the control a x:Name in Xaml and pass as CommandParameter, then in said loaded command hook view model handlers up to the events where I need to get the event args.

Here is a version of @adabyron's answer that prevents the leaky EventArgs abstraction.

First, the modified EventToCommandBehavior class (now a generic abstract class and formatted with ReSharper code cleanup). Note the new GetCommandParameter virtual method and its default implementation:

public abstract class EventToCommandBehavior<TEventArgs> : Behavior<FrameworkElement> where TEventArgs : EventArgs { public static readonly DependencyProperty EventProperty = DependencyProperty.Register("Event", typeof(string), typeof(EventToCommandBehavior<TEventArgs>), new PropertyMetadata(null, OnEventChanged)); public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(EventToCommandBehavior<TEventArgs>), new PropertyMetadata(null)); public static readonly DependencyProperty PassArgumentsProperty = DependencyProperty.Register("PassArguments", typeof(bool), typeof(EventToCommandBehavior<TEventArgs>), new PropertyMetadata(false)); private Delegate _handler; private EventInfo _oldEvent; public string Event { get { return (string)GetValue(EventProperty); } set { SetValue(EventProperty, value); } } public ICommand Command { get { return (ICommand)GetValue(CommandProperty); } set { SetValue(CommandProperty, value); } } public bool PassArguments { get { return (bool)GetValue(PassArgumentsProperty); } set { SetValue(PassArgumentsProperty, value); } } protected override void OnAttached() { AttachHandler(Event); } protected virtual object GetCommandParameter(TEventArgs e) { return e; } private void AttachHandler(string eventName) { _oldEvent?.RemoveEventHandler(AssociatedObject, _handler); if (string.IsNullOrEmpty(eventName)) { return; } EventInfo eventInfo = AssociatedObject.GetType().GetEvent(eventName); if (eventInfo != null) { MethodInfo methodInfo = typeof(EventToCommandBehavior<TEventArgs>).GetMethod("ExecuteCommand", BindingFlags.Instance | BindingFlags.NonPublic); _handler = Delegate.CreateDelegate(eventInfo.EventHandlerType, this, methodInfo); eventInfo.AddEventHandler(AssociatedObject, _handler); _oldEvent = eventInfo; } else { throw new ArgumentException($"The event '{eventName}' was not found on type '{AssociatedObject.GetType().FullName}'."); } } private static void OnEventChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var behavior = (EventToCommandBehavior<TEventArgs>)d; if (behavior.AssociatedObject != null) { behavior.AttachHandler((string)e.NewValue); } } // ReSharper disable once UnusedMember.Local // ReSharper disable once UnusedParameter.Local private void ExecuteCommand(object sender, TEventArgs e) { object parameter = PassArguments ? GetCommandParameter(e) : null; if (Command?.CanExecute(parameter) == true) { Command.Execute(parameter); } } } 

Next, an example derived class that hides DragCompletedEventArgs. Some people expressed concern about leaking the EventArgs abstraction into their view model assembly. To prevent this, I created an interface that represents the values we care about. The interface can live in the view model assembly with the private implementation in the UI assembly:

// UI assembly public class DragCompletedBehavior : EventToCommandBehavior<DragCompletedEventArgs> { protected override object GetCommandParameter(DragCompletedEventArgs e) { return new DragCompletedArgs(e); } private class DragCompletedArgs : IDragCompletedArgs { public DragCompletedArgs(DragCompletedEventArgs e) { Canceled = e.Canceled; HorizontalChange = e.HorizontalChange; VerticalChange = e.VerticalChange; } public bool Canceled { get; } public double HorizontalChange { get; } public double VerticalChange { get; } } } // View model assembly public interface IDragCompletedArgs { bool Canceled { get; } double HorizontalChange { get; } double VerticalChange { get; } } 

Cast the command parameter to IDragCompletedArgs, similar to @adabyron's answer.

As an adaption of @Mike Fuchs answer, here's an even smaller solution. I'm using the Fody.AutoDependencyPropertyMarker to reduce some of the boiler plate.

The Class

public class EventCommand : TriggerAction<DependencyObject> { [AutoDependencyProperty] public ICommand Command { get; set; } protected override void Invoke(object parameter) { if (Command != null) { if (Command.CanExecute(parameter)) { Command.Execute(parameter); } } } } 

The EventArgs

public class VisibleBoundsArgs : EventArgs { public Rect VisibleVounds { get; } public VisibleBoundsArgs(Rect visibleBounds) { VisibleVounds = visibleBounds; } } 

The XAML

<local:ZoomableImage> <i:Interaction.Triggers> <i:EventTrigger EventName="VisibleBoundsChanged" > <local:EventCommand Command="{Binding VisibleBoundsChanged}" /> </i:EventTrigger> </i:Interaction.Triggers> </local:ZoomableImage> 

The ViewModel

public ICommand VisibleBoundsChanged => _visibleBoundsChanged ?? (_visibleBoundsChanged = new RelayCommand(obj => SetVisibleBounds(((VisibleBoundsArgs)obj).VisibleVounds))); 

Microsoft Community Toolkit automatically forwards the event-args as a command parameter by default. To avoid tight-coupling the MVVM code with the UI-specific event-args type, you can use a converter to extract the necessary bits from the event-args.

The toolkit also generates the commands from methods declared in the MVVM and are decorated with RelayCommandAttribute.

You can even create a more general-purpose ExtractPropertyConverter and use the InvokeCommandAction's InputConverterParameter property to indicate that the IsSuccess property is to be extracted and passed on to the command.

XAML code:

<WebView2 xmlns:i="using:Microsoft.Xaml.Interactivity" Source="{x:Bind Source}"> <interactivity:Interaction.Behaviors> <i:EventTriggerBehavior EventName="NavigationCompleted"> <i:InvokeCommandAction Command="{x:Bind ViewModel.NavigationCompletedCommand}" InputConverter="{StaticResource NavigationCompletedArgsConverter}" /> </i:EventTriggerBehavior> </i:Interaction.Behaviors> ... 

MVVM code:

[RelayCommand] private Task NavigationCompleted(bool isSuccess) { ... } 

Optional converter code:

public class NavigationCompletedArgsConverter : IValueConverter { public object Convert(object? value, Type targetType, object? parameter, string language) { if (value is CoreWebView2NavigationCompletedEventArgs args) return args.IsSuccess; return false; } public object ConvertBack(object? value, Type targetType, object? parameter, string language) => throw new NotSupportedException(); }