MVVM передача EventArgs в качестве параметра команды

Я стараюсь свести свои зависимости к минимуму, поэтому я реализовал это сам, а не пошел с EventToCommand MVVMLight. Работает для меня до сих пор, но обратная связь приветствуется.

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

Я всегда возвращался сюда за ответом, поэтому я хотел сделать короткий простой, чтобы пойти.

есть несколько способов сделать это:

1. Использование инструментов WPF. Простейший.

Добавить Пространства Имен:

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

XAML:

использовать EventName чтобы вызвать событие, которое вы хотите, укажите свой Method название в 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>

код:

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

2. С Помощью MVVMLight. Самый трудный.

установить пакет GalaSoft NuGet.

сделать пространства имен:

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

XAML:

использовать EventName чтобы вызвать событие, которое вы хотите, укажите свой Command имя в привязке. Если вы хотите передать аргументы метод, Марк PassEventArgsToCommand значение 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>

Делегаты Реализации Кода:источник

вы должны получить пакет Prism MVVM NuGet для этого.

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

Код Без DelegateCommand: источник

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. Используя Telerik EventToCommandBehavior. Это вариант.

вам придется скачать это NuGet для Пакет.

XAML:

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

код:

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

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

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

Я знаю, что это довольно старый вопрос, но сегодня я столкнулся с той же проблемой и не был слишком заинтересован в ссылке на все MVVMLight, чтобы я мог использовать триггеры событий с событиями args. Я использовал MVVMLight в прошлом, и это отличная структура, но я просто больше не хочу использовать ее для своих проектов.

что я сделал, чтобы решить эту проблему, это создать ультра минимальный, очень адаптируемое пользовательское действие триггера, которое позволит мне свяжите с командой и предоставьте преобразователь args событий для передачи args в CanExecute команды и выполнения функций. Вы не хотите передавать args событий дословно, так как это приведет к отправке типов слоев представления в слой модели представления (что никогда не должно происходить в MVVM).

здесь EventCommandExecuter класс, который я придумал:

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

этот класс имеет два свойства зависимостей, одно из которых позволяет привязку к модели представления команда, другая позволяет привязать источник события, если вам это нужно во время преобразования событий args. Вы также можете предоставить параметры культуры, если вам нужно (они по умолчанию для текущей культуры пользовательского интерфейса).

этот класс позволяет адаптировать args событий так, чтобы они могли быть потреблены командной логикой вашей модели представления. Однако, если вы хотите просто передать args события на verbatim, просто не указывайте конвертер args события.

самое простое использование этого триггерного действия в XAML выглядит следующим образом:

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

Если вам нужен доступ к источнику события, вы свяжетесь с владельцем события

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

(предполагается, что узел XAML, к которому вы присоединяете триггеры, был назначен x:Name="SomeEventSource"

этот XAML использует импорт некоторых требуемых пространств имен

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"

и создании IValueConverter (под названием NameChangedArgsToStringConverter в этом случае) для обработки фактической логики преобразования. Для основных конвертеров я обычно создаю по умолчанию static readonly экземпляр конвертера, на который я могу ссылаться непосредственно в XAML, как я сделал выше.

преимущество этого решения заключается в том, что вам действительно нужно добавить только один класс в любой проект, чтобы использовать структуру взаимодействия так же, как вы бы использовали его с InvokeCommandAction. Добавление одного класса (около 75 строк) должно быть намного предпочтительнее всей библиотеки для достижения идентичных результатов.

Примечание

это несколько похоже на ответ от @adabyron, но он использует триггеры событий вместо поведения. Это решение также предоставляет возможность преобразования событий args, а не то, что решение @adabyron не могло этого сделать. У меня действительно нет веской причины, почему я предпочитаю триггеры поведению, просто личный выбор. Любая стратегия ИМО является разумным выбором.

для людей, просто находящих этот пост, вы должны знать, что в более новых версиях (не уверен в точной версии, поскольку официальные документы тонки в этой теме) поведение по умолчанию InvokeCommandAction, если не указан CommandParameter, должно передать args события, к которому он прикреплен как CommandParameter. Таким образом, XAML оригиналов плаката может быть просто написан как:

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

затем в вашей команде вы можете принять параметр типа NavigationEventArgs (или любые args события тип подходит), и он будет автоматически предоставлен.

чтобы добавить к тому, что joshb уже заявил - это работает просто отлично для меня. Обязательно добавьте ссылки на Microsoft.Выражение.Взаимодействия.dll и система.Окна.Интерактивность.dll и в вашем xaml do:

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

Я закончил тем, что использовал что-то подобное для своих нужд. Это показывает, что вы также можете передать пользовательский параметр:

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

Я не думаю, что вы можете сделать это легко с InvokeCommandAction - Я бы посмотрел на EventToCommand от MVVMLight или аналогичного.

с поведением и действиями в Blend для Visual Studio 2013 можно использовать InvokeCommandAction. Я попробовал это с событием Drop, и хотя в XAML не был указан CommandParameter, к моему удивлению, параметр Execute Action содержал DragEventArgs. Я предполагаю, что это произойдет для других событий, но не проверял их.

Что я делаю, это использовать InvokeCommandAction для привязки события загрузки элемента управления к команде в модели представления, дать элементу управления x: Name в Xaml и передать как CommandParameter, а затем в указанных обработчиках модели представления загруженной команды до событий, где мне нужно получить args событий.

вот версия ответа @adabyron, которая предотвращает утечку EventArgs абстракция.

во-первых, изменен EventToCommandBehavior class (теперь общий абстрактный класс и отформатирован с очисткой кода ReSharper). Обратите внимание на новый GetCommandParameter виртуальный метод и его реализация по умолчанию:

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

далее, пример производного класса, который скрывает DragCompletedEventArgs. Некоторые люди выразили озабоченность по поводу утечки EventArgs абстракция в сборку модели представления. Чтобы предотвратить это, я создал интерфейс, представляющий ценности, которые нам небезразличны. Интерфейс может жить в сборке модели представления с частной реализацией в сборке пользовательского интерфейса:

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

приведите Параметр команды в IDragCompletedArgs, подобно ответу @adabyron.

как адаптация ответа @Mike Fuchs, вот еще меньшее решение. Я использую Fody.AutoDependencyPropertyMarker уменьшить некоторую из плиты боилера.

Класс

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

В EventArgs В

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

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

в XAML

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

ViewModel

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