MVVM이 EventArgs를 명령 매개 변수로 전달

MVVM이 EventArgs를 명령 매개 변수로 전달

Blend 4 Microsoft Expression Blend 4 를
.., ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★」

[ XAML ] Connection View "뒤에 있는 빈 코드"

        <WebBrowser local:AttachedProperties.BrowserSource="{Binding Source}">
            <i:Interaction.Triggers>
                <i:EventTrigger>
                    <i:InvokeCommandAction Command="{Binding LoadedEvent}"/>
                </i:EventTrigger>
                <i:EventTrigger EventName="Navigated">
                    <i:InvokeCommandAction Command="{Binding NavigatedEvent}" CommandParameter="??????"/>
                </i:EventTrigger>
            </i:Interaction.Triggers>
        </WebBrowser>  

[C#] AttachedProperties 클래스

public static class AttachedProperties
    {
        public static readonly DependencyProperty BrowserSourceProperty = DependencyProperty . RegisterAttached ( "BrowserSource" , typeof ( string ) , typeof ( AttachedProperties ) , new UIPropertyMetadata ( null , BrowserSourcePropertyChanged ) );

        public static string GetBrowserSource ( DependencyObject _DependencyObject )
        {
            return ( string ) _DependencyObject . GetValue ( BrowserSourceProperty );
        }

        public static void SetBrowserSource ( DependencyObject _DependencyObject , string Value )
        {
            _DependencyObject . SetValue ( BrowserSourceProperty , Value );
        }

        public static void BrowserSourcePropertyChanged ( DependencyObject _DependencyObject , DependencyPropertyChangedEventArgs _DependencyPropertyChangedEventArgs )
        {
            WebBrowser _WebBrowser = _DependencyObject as WebBrowser;
            if ( _WebBrowser != null )
            {
                string URL = _DependencyPropertyChangedEventArgs . NewValue as string;
                _WebBrowser . Source = URL != null ? new Uri ( URL ) : null;
            }
        }
    }

[C#] Connection View Model 클래스

public class ConnectionViewModel : ViewModelBase
    {
            public string Source
            {
                get { return Get<string> ( "Source" ); }
                set { Set ( "Source" , value ); }
            }

            public void Execute_ExitCommand ( )
            {
                Application . Current . Shutdown ( );
            }

            public void Execute_LoadedEvent ( )
            {
                MessageBox . Show ( "___Execute_LoadedEvent___" );
                Source = ...... ;
            }

            public void Execute_NavigatedEvent ( )
            {
                MessageBox . Show ( "___Execute_NavigatedEvent___" );
            }
    }

[C#] View Model Base 클래스 여기서

한 바인딩은 는 "MessageBox"로 표시됩니다.

---

:★★★★★★★★★★★★★★★★★★★」
네비게이션 이벤트 발생 시 NavigationEventArgs를 명령 파라미터로 전달하는 방법

쉽게 지지되지 않습니다.다음은 EventArgs를 명령어파라미터로 전달하는 방법에 대한 설명입니다.

MVMLight를 사용하는 것을 검토해 주십시오.MVMLight는 EventArgs in 명령어를 직접 지원합니다.상황은 다음과 같습니다.

 <i:Interaction.Triggers>
    <i:EventTrigger EventName="Navigated">
        <cmd:EventToCommand Command="{Binding NavigatedEvent}"
            PassEventArgsToCommand="True" />
    </i:EventTrigger>
 </i:Interaction.Triggers>

의존성을 최소화하려고 노력하기 때문에 MVMLight의 EventToCommand를 사용하는 대신 직접 구현했습니다.지금까지는 괜찮지만, 피드백은 환영입니다.

Xaml:

<i:Interaction.Behaviors>
    <beh: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)
{
    // ...
}

Event To Command Behavior:

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

Action Command:

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

<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. MVMLight를 사용한다.가장 어렵다.

GalaSoft NuGet 패키지를 설치합니다.

네임스페이스를 가져옵니다.

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

XAML:

하다를 사용하세요.EventName하려면 , 「이벤트」를 해 주세요.Command이름을 입력합니다., 이 방법을 사용하다, 라고 표시해 주세요.PassEventArgsToCommand정말이야.

<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 Package를 다운로드해야 합니다.

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
}

이 게시물을 찾은 사용자는 최신 버전(이 항목에서는 공식 문서가 슬림하므로 정확한 버전에서는 알 수 없음)에서 명령 매개 변수가 지정되지 않은 경우 InvokeCommandAction의 기본 동작은 해당 게시물이 연결된 이벤트의 arg를 명령 매개 변수로 전달하는 것임을 알아야 합니다.오리지널 포스터의 XAML은 다음과 같이 간단하게 기재할 수 있습니다.

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

명령어로 을 하다'라고 하는 타입의 할 수 있습니다.NavigationEventArgs(또는 이벤트 args 유형이 적절한 경우) 자동으로 제공됩니다.

꽤 오래된 질문인 것은 알지만, 오늘 같은 문제에 부딪혔기 때문에 이벤트 트리거를 이벤트 arg와 함께 사용할 수 있도록 모든 MVMLight를 참조하는 것에 그다지 관심이 없었습니다.예전에 MVMLight를 사용한 적이 있고, 훌륭한 프레임워크이지만, 더 이상 프로젝트에 사용하고 싶지 않습니다.

이 문제를 해결하기 위해 저는 명령어에 바인드하여 이벤트 args 컨버터를 제공하여 명령어의 CanExecute 및 Execute 함수에 args를 전달할 수 있도록 하는 ULTRA 최소의 매우 적응성이 뛰어난 커스텀트리거 액션을 작성했습니다.이벤트 args를 말 그대로 전달하면 뷰 계층 유형이 뷰 모델 계층으로 전송되기 때문에(MVVM에서는 절대 발생하지 않습니다).

Event Command는 다음과 같습니다.내가 생각해낸 실행자 클래스:

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 변환 중에 필요한 경우 이벤트의 소스를 바인딩할 수 있습니다.필요한 경우 문화 설정을 제공할 수도 있습니다(기본값은 현재 UI 문화입니다).

이 클래스를 사용하면 이벤트 Arg를 조정하여 뷰 모델의 명령 로직에서 사용할 수 있습니다.단, event args를 문자 그대로 전달하려면 event 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>

되어 있는 로 하고 있습니다x:Name="SomeEventSource"

이 XAML은 몇 가지 필요한 네임스페이스를 Import해야 합니다.

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의 솔루션에서는 이를 수행할 수 없었습니다.제가 행동보다 방아쇠를 당기는 것을 선호하는 좋은 이유는 없습니다. 단지 개인적인 선택일 뿐입니다.IMO는 어느쪽이든 합리적인 선택입니다.

Joshb가 이미 말한 것을 덧붙이자면, 이것은 나에게 아주 좋습니다.Microsoft 에 레퍼런스를 추가해 주세요.표현.Interactions.dll 및 시스템.창문들.interactivity.dll 및 xaml에서 다음 작업을 수행합니다.

    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>

리즘 prism prismInvokeCommandAction는 arg가 arg인 경우 기본적으로 이벤트 합니다.CommandParameter설정되지 않았습니다.

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

여기 예가 있습니다.「 」의 .prism:InvokeCommandActioni:InvokeCommandAction.

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

View Model

    private DelegateCommand<EventArgs> _sortingCommand;

    public DelegateCommand<EventArgs> SortingCommand => _sortingCommand ?? (_sortingCommand = new DelegateCommand<EventArgs>(OnSortingCommand));

    private void OnSortingCommand(EventArgs obj)
    {
        //do stuff
    }

프리즘 라이브러리 문서의 새로운 버전이 있습니다.

할 수 것 않아요.InvokeCommandAction·MVMLight등에서 보고 싶다.

Blend for Visual Studio 2013의 동작 및 동작과 함께 InvokeCommandAction을 사용할 수 있습니다.Drop 이벤트에서 시도했는데 XAML에서 Command Parameter가 지정되지 않았지만 놀랍게도 Execute Action 파라미터에는 DragEventArgs가 포함되어 있었습니다.다른 이벤트에서는 이런 일이 일어날 것이라고 추측하지만 테스트하지 않았습니다.

조금 늦은 감이 있지만 마이크로소프트는 Xaml을 만들었다.동작 오픈 소스로, 1개의 네임스페이스만으로 인터랙티브를 사용할 수 있게 되었습니다.

1. 저 microsoft Microsoft xx xx xx Behaviors.」, 「를 에 적용합니다.「WPF Nuget」(WPF Nuget.
   https://www.nuget.org/packages/Microsoft.Xaml.Behaviors.Wpf/httpswww.nuget.org/packages/Microsoft.Xaml..Wpf/
2. xmlns:exmlours="http://schemas.microsoft.com/xaml/behaviors" 네임스페이스를 xaml에 추가합니다.

그럼 이렇게 쓰세요.

<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"는 True로 설정해야 하며 구현한 RelayCommand는 RoutedEventArgs 또는 개체를 템플릿으로 가져올 수 있습니다.객체를 파라미터 유형으로 사용하는 경우 해당 이벤트 유형으로 캐스트하십시오.

명령어는 다음과 같습니다.

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

명령 방법은 다음과 같습니다.

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

'parameter'는 라우팅된 이벤트 개체가 됩니다.

그리고 그 일지는 당신이 궁금해 할 수 있도록

2020-12-15 11:40:36.3600|INFO|My Application.View Models(모델 표시)메인 윈도 뷰 모델|RoutedEventArgs

보시는 것처럼 TypeName은 RoutedEventArgs 입니다.

RelayCommand 임플리케이션은 여기에서 확인할 수 있습니다.

Relay Command가 필요한 이유

PS : 임의의 컨트롤 이벤트에 바인드 할 수 있습니다.Window의 Closing event처럼 해당 이벤트가 표시됩니다.

InvokeCommandAction을 사용하여 컨트롤 로드된 이벤트를 뷰 모델의 명령에 바인드하고 Xaml에서 컨트롤에 x:Name을 지정하고 CommandParameter로 전달한 다음 해당 로드된 명령 후크 뷰 모델 핸들러를 이벤트 Arg를 가져와야 하는 이벤트까지 전달합니다.

다음은 누출을 방지하는 @adabyron의 답변 버전입니다.EventArgs추상화

우선 수정한 것은EventToCommandBehaviorclass(지금은 일반 추상 클래스이며 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 어셈블리의 프라이빗 구현과 함께 뷰 모델 어셈블리에 존재할 수 있습니다.

// 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 mi @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>

View Model

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

언급URL : https://stackoverflow.com/questions/6205472/mvvm-passing-eventargs-as-command-parameter