Как связать событие MouseDoubleClick

Question

Как связать событие MouseDoubleClick с DataGrid с командой делегата и получить выделенный элемент этой сетки? Я хочу сделать это в файле XAML, поскольку я использую шаблон Prism 2.0 и MVVM.

Answer 1

Пожалуйста, ознакомьтесь с прилагаемыми свойствами, это будет полезно. Ниже приведен код, который поможет, я видел это где-то, но не помню ни имени сайта, ни имени автора, в любом случае.

/// <summary> 
/// The static class the defines the attached command DP for exposing MouseDoubleClick 
/// event as a command 
/// </summary> 
public static class CommandMouseDoubleClick 
{ 
    #region TheCommandToRun 

    /// <summary> 
    /// TheCommandToRun : The actual ICommand to run 
    /// </summary> 
    public static readonly DependencyProperty TheCommandToRunProperty = 
     DependencyProperty.RegisterAttached("TheCommandToRun", typeof(ICommand), 
     typeof(CommandMouseDoubleClick), 
     new FrameworkPropertyMetadata((ICommand)null)); 

    /// <summary> 
    /// Gets the TheCommandToRun property.  
    /// </summary> 
    public static ICommand GetTheCommandToRun(DependencyObject d) 
    { 
     return (ICommand)d.GetValue(TheCommandToRunProperty); 
    } 

    /// <summary> 
    /// Sets the TheCommandToRun property. 
    /// </summary> 
    public static void SetTheCommandToRun(DependencyObject d, ICommand value) 
    { 
     d.SetValue(TheCommandToRunProperty, value); 
    } 

    #endregion 

    #region RoutedEventName 

    /// <summary> 
    /// RoutedEventName : The event that should actually execute the 
    /// ICommand 
    /// </summary> 
    public static readonly DependencyProperty RoutedEventNameProperty = 
     DependencyProperty.RegisterAttached("RoutedEventName", typeof(String), 
     typeof(CommandMouseDoubleClick), 
     new FrameworkPropertyMetadata((String)String.Empty, 
      new PropertyChangedCallback(OnRoutedEventNameChanged))); 

    /// <summary> 
    /// Gets the RoutedEventName property. 
    /// </summary> 
    public static String GetRoutedEventName(DependencyObject d) 
    { 
     return (String)d.GetValue(RoutedEventNameProperty); 
    } 

    /// <summary> 
    /// Sets the RoutedEventName property. 
    /// </summary> 
    public static void SetRoutedEventName(DependencyObject d, String value) 
    { 
     d.SetValue(RoutedEventNameProperty, value); 
    } 

    /// <summary> 
    /// Hooks up a Dynamically created EventHandler (by using the 
    /// <see cref="MouseDoubleClickEventHooker">MouseDoubleClickEventHooker</see> class) that when 
    /// run will run the associated ICommand 
    /// </summary> 
    private static void OnRoutedEventNameChanged(DependencyObject d, 
     DependencyPropertyChangedEventArgs e) 
    { 
     String routedEvent = (String)e.NewValue; 
     //If the RoutedEvent string is not null, create a new 
     //dynamically created EventHandler that when run will execute 
     //the actual bound ICommand instance (usually in the ViewModel) 
     if (!String.IsNullOrEmpty(routedEvent)) 
     { 
      MouseDoubleClickEventHooker eventHooker = new MouseDoubleClickEventHooker(); 
      eventHooker.ObjectWithAttachedCommand = d; 
      EventInfo eventInfo = d.GetType().GetEvent(routedEvent, 
       BindingFlags.Public | BindingFlags.Instance); 
      //Hook up Dynamically created event handler 
      if (eventInfo != null) 
      { 
       eventInfo.AddEventHandler(d, 
       eventHooker.GetNewEventHandlerToRunCommand(eventInfo)); 
      } 
     } 
    } 

    #endregion 
} 

/// <summary> 
/// Contains the event that is hooked into the source RoutedEvent 
/// that was specified to run the ICommand 
/// </summary> 
sealed class MouseDoubleClickEventHooker 
{ 
    #region Properties 

    /// <summary> 
    /// The DependencyObject, that holds a binding to the actual 
    /// ICommand to execute 
    /// </summary> 
    public DependencyObject ObjectWithAttachedCommand { get; set; } 

    #endregion 

    #region Public Methods 

    /// <summary> 
    /// Creates a Dynamic EventHandler that will be run the ICommand 
    /// when the user specified RoutedEvent fires 
    /// </summary> 
    /// <param name="eventInfo">The specified RoutedEvent EventInfo</param> 
    ///<returns>An Delegate that points to a new EventHandler 
    /// that will be run the ICommand</returns> 
    public Delegate GetNewEventHandlerToRunCommand(EventInfo eventInfo) 
    { 
     Delegate del = null; 
     if (eventInfo == null) 
      throw new ArgumentNullException("eventInfo"); 
     if (eventInfo.EventHandlerType == null) 
      throw new ArgumentException("EventHandlerType is null"); 
     if (del == null) 
      del = Delegate.CreateDelegate(eventInfo.EventHandlerType, this, 
       GetType().GetMethod("OnEventRaised", 
       BindingFlags.NonPublic | 
       BindingFlags.Instance)); 
     return del; 
    } 

    #endregion 

    #region Private Methods 
    /// <summary> 
    /// Runs the ICommand when the requested RoutedEvent fires 
    /// </summary> 
    private void OnEventRaised(object sender, EventArgs e) 
    { 
     ICommand command = (ICommand)(sender as DependencyObject). 
      GetValue(CommandMouseDoubleClick.TheCommandToRunProperty); 
     if (command != null) 
     { 
      command.Execute(null); 
     } 
    } 
    #endregion 
} 

Часть XAML может выглядеть, как показано ниже:

<Label local:CommandMouseLeftButtonDown.RoutedEventName="MouseLeftButtonDown" 
     local:CommandMouseLeftButtonDown.TheCommandToRun="{Binding Path=MouseDownCommand, RelativeSource={RelativeSource TemplatedParent}}" 
     local:CommandMouseDoubleClick.RoutedEventName="MouseDoubleClick" 
     local:CommandMouseDoubleClick.TheCommandToRun="{Binding Path=MouseDoubleClickCommand, RelativeSource={RelativeSource TemplatedParent}}"/>