Предотвратить всплытие выполнения команды привязанной к MouseDoubleClick

using Logic.DTO;
using Simplified;
using System;
using System.Collections.ObjectModel;
 
namespace Layer
{
    public abstract class MainTreeViewModelAbstract : ViewModelBase, IMainTreeViewModel
    {
        public ObservableCollection<RootVM> Roots { get; } = new ObservableCollection<RootVM>();
        public ObservableCollection<ChildVM> Children { get; } = new ObservableCollection<ChildVM>();
        public RelayCommand<RootVM> RootEditCommand { get; }
        public RelayCommand<ChildVM> ChildEditCommand { get; }
 
        protected readonly EditDialogHandler<RootDto, string> rootTitleEditDialog;
        protected readonly EditDialogHandler<ChildDto, string> childTitleEditDialog;
 
        protected MainTreeViewModelAbstract(EditDialogHandler<RootDto, string> rootTitleEditDialog,
                                            EditDialogHandler<ChildDto, string> childTitleEditDialog)
        {
            this.rootTitleEditDialog = rootTitleEditDialog ?? throw new ArgumentNullException(nameof(rootTitleEditDialog));
            this.childTitleEditDialog = childTitleEditDialog ?? throw new ArgumentNullException(nameof(childTitleEditDialog));
 
            RootEditCommand = new RelayCommand<RootVM>(RootEditExecute, RootEditCanExecute);
            ChildEditCommand = new RelayCommand<ChildVM>(ChildEditExecute, ChildEditCanExecute);
        }
 
        /// <summary>Метод сохранения данных корневого элемента.</summary>
        /// <param name="root">Исходные Данные отражающие элемент.</param>
        /// <param name="title">Данные для сохранения.</param>
        /// <returns>Новый экземпляр Данных отражающих элемент.</returns>
        protected abstract RootDto RootSave(RootDto root, string title);
 
        /// <summary>Метод сохранения данных дочернего элемента.</summary>
        /// <param name="root">Исходные Данные отражающие элемент.</param>
        /// <param name="title">Данные для сохранения.</param>
        /// <returns>Новый экземпляр Данных отражающих элемент.</returns>
        protected abstract ChildDto ChildSave(ChildDto root, string title);
 
        private void RootEditExecute(RootVM root)
        {
            if (rootTitleEditDialog(root.Data, out string title))
            {
                root.SetData(RootSave(root.Data, title));
            }
        }
        protected virtual bool RootEditCanExecute(RootVM root)
        {
            return true;
        }
        private void ChildEditExecute(ChildVM child)
        {
            if (childTitleEditDialog(child.Data, out string title))
            {
                child.SetData(ChildSave(child.Data, title));
            }
        }
        protected virtual bool ChildEditCanExecute(ChildVM child)
        {
            return true;
        }
    }
 
    /// <summary>Делегат диалога редактирования.</summary>
    /// <typeparam name="InT">Тип Данных для редактирования.</typeparam>
    /// <typeparam name="OutT">Тип Данных содержащий результаты редактирования.</typeparam>
    /// <param name="inData">Данные для редактирования.</param>
    /// <param name="outData">Данные содержащие результаты редактирования.</param>
    /// <returns><see langword="true"/> - если нужно сохранить результаты редактирования.</returns>
    public delegate bool EditDialogHandler<InT, OutT>(in InT inData, out OutT outData);
 
}

namespace Layer
{
    /// <summary>Класс сущности для представления одно элемента Данных.</summary>
    public class EntityVM<T> : BaseInpc
    {
 
        /// <summary>Получение другого элемента с данными.</summary>
        /// <param name="data">Новый элемент с данными.</param>
        public void SetData(T data) => Data = data;

using Logic;
using Logic.DTO;
using System;
 
namespace ViewModelLayer
{
    public class MainTreeViewModel : MainTreeViewModelAbstract
    {
        private readonly IMainLogic model;
 
        public MainTreeViewModel(IMainLogic model)
        {
            this.model = model ?? throw new ArgumentNullException(nameof(model));
        }
 
        protected override ChildDto ChildSave(ChildDto root, string title)
        {
            throw new NotImplementedException();
        }
 
        protected override RootDto RootSave(RootDto root, string title)
        {
            throw new NotImplementedException();
        }
    }
}

        public MainTreeViewModel(IMainLogic model,
                                 EditDialogHandler<RootDto, string> rootTitleEditDialog,
                                 EditDialogHandler<ChildDto, string> childTitleEditDialog)
            : base(rootTitleEditDialog, childTitleEditDialog)
        {
            this.model = model ?? throw new ArgumentNullException(nameof(model));
        }

        private async void InitAsync()
        {
            // Здесь нужна обработка исключений,
            // потом позже сами сделаете.
            Roots.AddRange((await model.GetRoots()).Select(CreateVM));
            Children.AddRange((await model.GetChildren()).Select(CreateVM));
        }
 
        public static RootVM CreateVM(RootDto dto)
        {
            RootVM root = new RootVM();
            root.SetData(dto);
            return root;
        }
        public static ChildVM CreateVM(ChildDto dto)
        {
            ChildVM child = new ChildVM();
            child.SetData(dto);
            return child;
        }

            if (Dispatcher.CheckAccess())
            {
                BindingOperations.EnableCollectionSynchronization(Roots, ((ICollection)Roots).SyncRoot);
                BindingOperations.EnableCollectionSynchronization(Children, ((ICollection)Children).SyncRoot);
            }
            else
            {
                Dispatcher.Invoke(() =>
                {
                    BindingOperations.EnableCollectionSynchronization(Roots, ((ICollection)Roots).SyncRoot);
                    BindingOperations.EnableCollectionSynchronization(Children, ((ICollection)Children).SyncRoot);
                });
            }

       
protected override ChildDto ChildSave(ChildDto child, string title)
        {
            Task.Run(() => model.UpdateChild(child));
            return child;
        }
 
        protected override RootDto RootSave(RootDto root, string title)
        {
            Task.Run(() => model.UpdateRoot(root));
            return root;
        }

        private async void RootEditExecute(RootVM root)
        {
            // Если возможны исключения, то здесь их нужно обрабатывать
            if (rootTitleEditDialog(root.Data, out string title))
            {
                root.SetData(await RootSaveAsync(root.Data, title));
            }
        }

        protected abstract Task<RootDto> RootSaveAsync(RootDto root, string title);

         public async void Execute(object parameter)
        {
            await ExecuteAsync(parameter);
        }