MVVM übergeben EventArgs als Befehlsparameter

Ich versuche meine Abhängigkeiten auf ein minimum, so dass ich umgesetzt, es selbst zu gehen, anstatt mit EventToCommand von MVVMLight. Bei mir funktioniert so weit, aber feedback ist willkommen.

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

InformationsquelleAutor der Antwort Mike Fuchs

Ich weiß, das ist eine ziemlich alte Frage, aber ich lief in das gleiche problem heute und war nicht allzu interessiert, verweisen auf alle MVVMLight nur so kann ich mit event-Trigger mit event-args. Ich habe verwendet, MVVMLight in der Vergangenheit und es ist ein tolles framework, aber ich will einfach nicht, es zu benutzen für meine Projekte mehr.

Was ich getan habe um dieses problem zu beheben war es, ein ULTRA minimal, EXTREM anpassbare benutzerdefinierte trigger-Aktion, die mir erlauben würde, zu binden, um den Befehl und geben Sie ein Ereignis args-Konverter zu passieren, auf die Argumente der Befehl ist CanExecute und Execute-Funktionen. Sie wollen nicht zum bestehen der Veranstaltung args wörtlich, denn das würde das Ergebnis in der Ansicht layer-Typen an die view-Modell-Ebene (das sollte nie passieren, in MVVM).

Hier ist die EventCommandExecuter Klasse, die ich kam mit:

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

Diese Klasse hat zwei dependency properties, eine Bindung zu Ihrem view-model-Befehl, der anderen erlaubt, Sie zu binden, die Quelle des Ereignisses, wenn Sie es brauchen, bei event-args-Konvertierung. Sie können auch Kultur-Einstellungen, wenn Sie müssen (Sie werden standardmäßig auf die aktuelle UI-Kultur).

Diese Klasse ermöglicht Ihnen das anpassen der event-args, so dass Sie verzehrt werden von Ihrem view-model-s-Befehl-Logik. Allerdings, wenn Sie wollen, geben Sie einfach die event-args auf verbatim, einfach nicht ein Ereignis anzugeben, das args-Konverter.

Die einfachste Nutzung dieser trigger-Aktion in XAML wie folgt:

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

Wenn Sie benötigt werden Zugriff auf die Quelle des Ereignisses, die Sie binden würde, um den Eigentümer der Veranstaltung

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

(dies setzt Voraus, dass die XAML-Knoten Sie befestigen den Trigger zugewiesen wurde x:Name="SomeEventSource"

Diese XAML basiert auf dem Import, dass einige benötigte 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"

erstellen einer IValueConverter (genannt NameChangedArgsToStringConverter in diesem Fall) zu handhaben die eigentliche Konvertierung Logik. Für basic-Konverter, die ich in der Regel erstellen Sie eine Standard - static readonly converter-Instanz, die kann ich dann darauf verweisen, direkt in XAML wie ich es schon oben.

Der Vorteil dieser Lösung ist, dass Sie wirklich brauchen nur fügen Sie eine einzelne Klasse zu jedem Projekt das zusammenspiel Rahmen der gleichen Weise, dass Sie würde es mit InvokeCommandAction. Das hinzufügen einer einzigen Klasse (etwa 75 Zeilen) sollte viel mehr vorzuziehen, um eine ganze Bibliothek zu erreichen das gleiche Ergebnis.

HINWEIS

dies ist etwas ähnlich wie die Antwort von @adabyron aber es nutzt event-Trigger anstelle von Verhaltensweisen. Diese Lösung bietet auch eine event-args-Konvertierung Fähigkeit, nicht, dass @adabyron die Lösung kann das nicht so gut. Ich haben wirklich keinen guten Grund, warum ich bevorzuge Trigger-Verhalten, nur eine persönliche Wahl. IMO entweder Strategie ist eine vernünftige Wahl.

InformationsquelleAutor der Antwort pjs

Hinzufügen, was joshb hat bereits dargelegt - das funktioniert gut für mich. Stellen Sie sicher, dass Sie Referenzen zu Microsoft.Expression.Interactions.dll und System.Windows.Interactivity.dll und in der xaml-do:

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

Landete ich mit sowas für meine Bedürfnisse. Dies zeigt, dass Sie können auch einen benutzerdefinierten parameter ein:

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

InformationsquelleAutor der Antwort EbbnFlow

Mit Verhaltensweisen und Handlungen in Blend für Visual Studio 2013 können Sie die InvokeCommandAction. Ich habe versucht, dies mit dem Drop-Ereignis, und obwohl keine CommandParameter angegeben wurde, die in XAML, zu meiner überraschung, die Ausführen-Aktion enthaltenen parameter der DragEventArgs. Ich nehme an, daß das passieren würde, für andere Ereignisse aber noch nicht getestet.

InformationsquelleAutor der Antwort OzFrog

Hier ist eine version von @adabyron Antwort, die verhindert, dass die undichte EventArgs Abstraktion.

Ersten, die geänderte EventToCommandBehavior Klasse (jetzt eine generische abstrakte Klasse und formatiert mit ReSharper die code-Bereinigung). Hinweis: die neue GetCommandParameter virtuelle Methode und deren default-Implementierung:

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

Als Nächstes ein Beispiel, abgeleitete Klasse, die blendet DragCompletedEventArgs. Einige Leute äußerten Bedenken über undichte die EventArgs Abstraktion, die in Ihrer view-model-assembly. Um dies zu verhindern, erstellte ich eine Schnittstelle repräsentiert die Werte, die uns wichtig sind. Die Schnittstelle kann das view-model-assembly mit dem privaten Umsetzung in der UI-Montage:

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

Besetzung der Kommando-parameter auf IDragCompletedArgsähnlich wie @adabyron Antwort.

InformationsquelleAutor der Antwort NathanAldenSr