MVVM Pasando EventArgs Como Parámetro De Comando

Trato de mantener mis dependencias al mínimo, así que implementé esto yo mismo en lugar de ir con EventToCommand de MVVMLight. Funciona para mí hasta ahora, pero los comentarios son bienvenidos.

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

Orden de acción:

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

Siempre he vuelto aquí por la respuesta, así que quería hacer una simple y corta para ir.

Hay múltiples maneras de hacer esto:

1. Uso de Herramientas WPF. Sencillo.

Agregar espacios de nombres:

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

XAML:

Use el EventName para llamar al evento que desea y luego especifique su nombre Method en el 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>

Código:

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

2. Usando MVVMLight. Mas complicado.

Instale el paquete GalaSoft NuGet.

Obtener los espacios de nombres:

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

XAML:

Use el EventName para llamar al evento que desea y luego especifique su nombre Command en su enlace. Si desea pasar los argumentos del método, marque PassEventArgsToCommand a 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>

Delegados implementadores de código: Fuente

Debe obtener el paquete Prism MVVM NuGet para este.

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

Código Sin DelegateCommand: Fuente

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. Usando Telerik EventToCommandBehavior. Es una opción.

Tendrás que descargar su Paquete NuGet.

XAML:

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

Código:

public ActionCommand<DragEventArgs> DropCommand { get; private set; }

this.DropCommand = new ActionCommand<DragEventArgs>(OnDrop);

private void OnDrop(DragEventArgs e)
{
    // Do Something
}

Sé que esta es una pregunta bastante antigua, pero me encontré con el mismo problema hoy y no estaba demasiado interesado en hacer referencia a todos los MVVMLight solo para poder usar activadores de eventos con args de eventos. He utilizado MVVMLight en el pasado y es un gran framework, pero no quiero usarlo para mis proyectos más.

Lo que hice para resolver este problema fue crear un ULTRA mínimo, EXTREMADAMENTE acción de disparador personalizado adaptable que me permitiría enlazar al comando y proporcionar un convertidor de eventos args para pasar los args a las funciones CanExecute y Execute del comando. No desea pasar los argumentos de evento textualmente, ya que eso daría lugar a que los tipos de capas de vista se enviaran a la capa del modelo de vista (lo que nunca debería ocurrir en MVVM).

Aquí está el EventCommandExecuter clase que se me ocurrió:

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

Esta clase tiene dos propiedades de dependencia, una para permitir el enlace al comando de su modelo de vista, la otra le permite vincular la fuente del evento si lo necesita durante la conversión de args de evento. También puede proporcionar la configuración de la cultura si es necesario (por defecto a la cultura de la IU actual).

Esta clase le permite adaptar los argumentos de eventos para que puedan ser consumidos por la lógica de comandos de su modelo de vista. Sin embargo, si desea simplemente pasar los argumentos de evento en verbatim, simplemente no especifique un convertidor de argumentos de evento.

El uso más simple de esta acción desencadenante en XAML es el siguiente:

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

Si es necesario acceso a la fuente del evento, se vincularía al propietario del evento

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

(esto asume que el nodo XAML al que está adjuntando los disparadores ha sido asignado x:Name="SomeEventSource"

Este XAML se basa en la importación de algunos espacios de nombres requeridos

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"

Y creando un IValueConverter (llamado NameChangedArgsToStringConverter en este caso) para manejar la lógica de conversión real. Para los convertidores básicos generalmente creo una instancia de convertidor predeterminada static readonly, a la que luego puedo hacer referencia directamente en XAML como lo he hecho arriba.

El beneficio de esta solución es que realmente solo necesita agregar una sola clase a cualquier proyecto para usar el marco de interacción de la misma manera que lo usaría con InvokeCommandAction. Agregar una sola clase (de aproximadamente 75 líneas) debería ser mucho más preferible que una biblioteca completa para lograr resultados idénticos.

NOTA

Esto es algo similar a la respuesta de @adabyron, pero utiliza desencadenadores de eventos en lugar de comportamientos. Esta solución también proporciona una capacidad de conversión de args de evento, no es que la solución de @adabyron no pudiera hacer esto también. Realmente no tengo ninguna buena razón por la que prefiero los disparadores a los comportamientos, solo una elección personal. IMO cualquiera de las dos estrategias es una opción razonable.

Para la gente que acaba de encontrar este post, debe saber que en las versiones más recientes (no estoy seguro de la versión exacta, ya que los documentos oficiales son escasos en este tema) el comportamiento predeterminado de InvokeCommandAction, si no se especifica ningún parámetro de comando, es pasar los argumentos del evento al que se adjunta como el parámetro de comando. Por lo tanto, el XAML del póster original podría escribirse simplemente como:

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

Luego, en su comando, puede aceptar un parámetro de tipo NavigationEventArgs (o cualquier tipo de evento args es apropiado) y se proporcionará automáticamente.

Para añadir a lo que joshb ya ha dicho - esto funciona muy bien para mí. Asegúrese de agregar referencias a Microsoft.Expresion.Interacción.dll y Sistema.Windows.Interactividad.dll y en su xaml hacer:

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

Terminé usando algo como esto para mis necesidades. Esto muestra que también puede pasar un parámetro personalizado:

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

No creo que puedas hacerlo fácilmente con el InvokeCommandAction - Echaría un vistazo a EventToCommand de MVVMLight o similar.

Con Comportamientos y acciones en Blend para Visual Studio 2013 puede usar InvokeCommandAction. Probé esto con el evento Drop y aunque no se especificó ningún parámetro de comando en el XAML, para mi sorpresa, el parámetro Execute Action contenía los DragEventArgs. Supongo que esto sucedería para otros eventos, pero no los he probado.

Lo que hago es usar InvokeCommandAction para enlazar el evento de control cargado a un comando en el modelo de vista, darle al control un nombre x:en Xaml y pasar como parámetro de comando, luego en dicho comando cargado hook ver manejadores del modelo hasta los eventos donde necesito obtener los args de eventos.

Aquí hay una versión de la respuesta de @adabyron que evita la abstracción con fugas EventArgs.

Primero, la clase modificada EventToCommandBehavior (ahora una clase abstracta genérica y formateada con limpieza de código ReSharper). Tenga en cuenta el nuevo método virtual GetCommandParameter y su implementación predeterminada:

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

A continuación, una clase derivada de ejemplo que oculta DragCompletedEventArgs. Algunas personas expresaron su preocupación por filtrar la abstracción EventArgs en su conjunto de modelo de vista. Para evitar esto, he creado una interfaz que representa la valores que nos importan. La interfaz puede vivir en el ensamblado del modelo de vista con la implementación privada en el ensamblado de la interfaz de usuario:

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

Envía el parámetro de comando a IDragCompletedArgs, similar a la respuesta de @adabyron.

Como adaptación de la respuesta de @Mike Fuchs, aquí hay una solución aún más pequeña. Estoy usando el Fody.AutoDependencyPropertyMarker para reducir parte de la placa de la caldera.

La Clase

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

Los EventArgs

public class VisibleBoundsArgs : EventArgs
{
    public Rect VisibleVounds { get; }

    public VisibleBoundsArgs(Rect visibleBounds)
    {
        VisibleVounds = visibleBounds;
    }
}

El XAML

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

El modelo de vista

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