更新对嵌套ViewModel命令的引用？

Question

我知道我可能会遗漏一些简单而明显的东西，但目前却没有找到我。

我正在尝试使用MVVM模式。

如何在链接到子视图模型的视图模型中更新对命令的引用？

我有一个绑定到viewmodel（MainViewModel）的视图（MainView）。 在MainView上，我有一个绑定到viewmodel（SummaryViewModel）的另一个视图（SummaryView）的实例。 SummaryViewModel包含第三个视图模型的集合（SummaryFilterViewModel）。

在SummaryView上，有一个TabControl，其上的每个选项卡都绑定到SummaryViewodel集合中的一个SummaryFilterViewModel实例。

在MainView上，有一个按钮绑定到MainViewModel中的命令。

我想要发生的是命令逻辑存在于SummaryFilterViewModel类中。因此，当前显示的任何选项卡都需要连接到MainView上的按钮触发的命令。

我试图做的是：

1. 存储在SummaryViewModel集合中的各个SummaryFilterViewModel对象包含ShoutCommand的实际实现。
2. MainView的XAML中的CommandReference对象绑定到MainViewModel的ShoutCommand属性
3. MainViewModel的ShoutCommand属性返回对MainViewModel中存储的SummaryViewModel对象的ShoutCommand属性的引用。
4. SummaryViewModel的ShoutCommand属性返回对当前所选SummaryFilterViewModel中ShoutCommand属性的引用。

当用户更改标签时，该命令不会更新。

我是如何实现这一目标的？ 我是否需要将命令的实现移动到SummaryViewModel类中？

提前感谢您的帮助！

我的解决方案的来源如下：

的ViewModels

的 SummaryView.xaml 的

<UserControl x:Class="NestedCommands.Views.SummaryView"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
         mc:Ignorable="d" 
         d:DesignHeight="309" d:DesignWidth="476">
<Grid>
    <TabControl SelectedIndex="{Binding SelectedTabIndex}">
        <TabItem DataContext="{Binding Filters[0]}" Header="{Binding FilterName}">
            <ListBox ItemsSource="{Binding ListData}" />
        </TabItem>
        <TabItem DataContext="{Binding Filters[1]}" Header="{Binding FilterName}">
            <ListBox ItemsSource="{Binding ListData}" />
        </TabItem>
        <TabItem DataContext="{Binding Filters[2]}" Header="{Binding FilterName}">
            <ListBox ItemsSource="{Binding ListData}" />
        </TabItem>
    </TabControl>
</Grid>

的 MainView.xaml 的

<Window x:Class="NestedCommands.Views.MainView"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:v="clr-namespace:NestedCommands.Views"
    xmlns:c="clr-namespace:NestedCommands.Commands"
    Title="MainView" Height="336" Width="420">
<Window.Resources>
    <c:CommandReference x:Key="ShoutCommandReference" Command="{Binding ShoutCommand}" />
</Window.Resources>
<Grid>
    <Grid.RowDefinitions>
        <RowDefinition Height="1*" />
        <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
    <v:SummaryView Grid.Row="0"
                   DataContext="{Binding SummaryViewModel}" />
    <Button Content="Shout Command"
            Grid.Row="1"
            Command="{StaticResource ShoutCommandReference}" />
</Grid>

---

命令类

的 CommandReference.cs 的

using System;
using System.Windows;
using System.Windows.Input;

namespace NestedCommands.Commands
{
    /// <summary>
    /// This class facilitates associating a key binding in XAML markup to a command
    /// defined in a View Model by exposing a Command dependency property.
    /// The class derives from Freezable to work around a limitation in WPF when data-binding from XAML.
    /// </summary>
    public class CommandReference : Freezable, ICommand
    {
        public CommandReference()
        {
            // Blank
        }

        public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("Command", typeof(ICommand), typeof(CommandReference), new PropertyMetadata(new PropertyChangedCallback(OnCommandChanged)));

        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }

        #region ICommand Members

        public bool CanExecute(object parameter)
        {
            if (Command != null)
                return Command.CanExecute(parameter);
            return false;
        }

        public void Execute(object parameter)
        {
            Command.Execute(parameter);
        }

        public event EventHandler CanExecuteChanged;

        private static void OnCommandChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            CommandReference commandReference = d as CommandReference;
            ICommand oldCommand = e.OldValue as ICommand;
            ICommand newCommand = e.NewValue as ICommand;

            if (oldCommand != null)
            {
                oldCommand.CanExecuteChanged -= commandReference.CanExecuteChanged;
            }
            if (newCommand != null)
            {
                newCommand.CanExecuteChanged += commandReference.CanExecuteChanged;
            }
        }

        #endregion

        #region Freezable

        protected override Freezable CreateInstanceCore()
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}

的 DelegateCommand.cs 的

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Input;

namespace NestedCommands.Commands
{
    /// <summary>
    ///     This class allows delegating the commanding logic to methods passed as parameters,
    ///     and enables a View to bind commands to objects that are not part of the element tree.
    /// </summary>
    public class DelegateCommand : ICommand
    {
        #region Constructors

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action executeMethod)
            : this(executeMethod, null, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod)
            : this(executeMethod, canExecuteMethod, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action executeMethod, Func<bool> canExecuteMethod, bool isAutomaticRequeryDisabled)
        {
            if (executeMethod == null)
            {
                throw new ArgumentNullException("executeMethod");
            }

            _executeMethod = executeMethod;
            _canExecuteMethod = canExecuteMethod;
            _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled;
        }

        #endregion

        #region Public Methods

        /// <summary>
        ///     Method to determine if the command can be executed
        /// </summary>
        public bool CanExecute()
        {
            if (_canExecuteMethod != null)
            {
                return _canExecuteMethod();
            }
            return true;
        }

        /// <summary>
        ///     Execution of the command
        /// </summary>
        public void Execute()
        {
            if (_executeMethod != null)
            {
                _executeMethod();
            }
        }

        /// <summary>
        ///     Property to enable or disable CommandManager's automatic requery on this command
        /// </summary>
        public bool IsAutomaticRequeryDisabled
        {
            get
            {
                return _isAutomaticRequeryDisabled;
            }
            set
            {
                if (_isAutomaticRequeryDisabled != value)
                {
                    if (value)
                    {
                        CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers);
                    }
                    else
                    {
                        CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers);
                    }
                    _isAutomaticRequeryDisabled = value;
                }
            }
        }

        /// <summary>
        ///     Raises the CanExecuteChaged event
        /// </summary>
        public void RaiseCanExecuteChanged()
        {
            OnCanExecuteChanged();
        }

        /// <summary>
        ///     Protected virtual method to raise CanExecuteChanged event
        /// </summary>
        protected virtual void OnCanExecuteChanged()
        {
            CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
        }

        #endregion

        #region ICommand Members

        /// <summary>
        ///     ICommand.CanExecuteChanged implementation
        /// </summary>
        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested += value;
                }
                CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
            }
            remove
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested -= value;
                }
                CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
            }
        }

        bool ICommand.CanExecute(object parameter)
        {
            return CanExecute();
        }

        void ICommand.Execute(object parameter)
        {
            Execute();
        }

        #endregion

        #region Data

        private readonly Action _executeMethod = null;
        private readonly Func<bool> _canExecuteMethod = null;
        private bool _isAutomaticRequeryDisabled = false;
        private List<WeakReference> _canExecuteChangedHandlers;

        #endregion
    }

    /// <summary>
    ///     This class allows delegating the commanding logic to methods passed as parameters,
    ///     and enables a View to bind commands to objects that are not part of the element tree.
    /// </summary>
    /// <typeparam name="T">Type of the parameter passed to the delegates</typeparam>
    public class DelegateCommand<T> : ICommand
    {
        #region Constructors

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action<T> executeMethod)
            : this(executeMethod, null, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action<T> executeMethod, Func<T, bool> canExecuteMethod)
            : this(executeMethod, canExecuteMethod, false)
        {
        }

        /// <summary>
        ///     Constructor
        /// </summary>
        public DelegateCommand(Action<T> executeMethod, Func<T, bool> canExecuteMethod, bool isAutomaticRequeryDisabled)
        {
            if (executeMethod == null)
            {
                throw new ArgumentNullException("executeMethod");
            }

            _executeMethod = executeMethod;
            _canExecuteMethod = canExecuteMethod;
            _isAutomaticRequeryDisabled = isAutomaticRequeryDisabled;
        }

        #endregion

        #region Public Methods

        /// <summary>
        ///     Method to determine if the command can be executed
        /// </summary>
        public bool CanExecute(T parameter)
        {
            if (_canExecuteMethod != null)
            {
                return _canExecuteMethod(parameter);
            }
            return true;
        }

        /// <summary>
        ///     Execution of the command
        /// </summary>
        public void Execute(T parameter)
        {
            if (_executeMethod != null)
            {
                _executeMethod(parameter);
            }
        }

        /// <summary>
        ///     Raises the CanExecuteChaged event
        /// </summary>
        public void RaiseCanExecuteChanged()
        {
            OnCanExecuteChanged();
        }

        /// <summary>
        ///     Protected virtual method to raise CanExecuteChanged event
        /// </summary>
        protected virtual void OnCanExecuteChanged()
        {
            CommandManagerHelper.CallWeakReferenceHandlers(_canExecuteChangedHandlers);
        }

        /// <summary>
        ///     Property to enable or disable CommandManager's automatic requery on this command
        /// </summary>
        public bool IsAutomaticRequeryDisabled
        {
            get
            {
                return _isAutomaticRequeryDisabled;
            }
            set
            {
                if (_isAutomaticRequeryDisabled != value)
                {
                    if (value)
                    {
                        CommandManagerHelper.RemoveHandlersFromRequerySuggested(_canExecuteChangedHandlers);
                    }
                    else
                    {
                        CommandManagerHelper.AddHandlersToRequerySuggested(_canExecuteChangedHandlers);
                    }
                    _isAutomaticRequeryDisabled = value;
                }
            }
        }

        #endregion

        #region ICommand Members

        /// <summary>
        ///     ICommand.CanExecuteChanged implementation
        /// </summary>
        public event EventHandler CanExecuteChanged
        {
            add
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested += value;
                }
                CommandManagerHelper.AddWeakReferenceHandler(ref _canExecuteChangedHandlers, value, 2);
            }
            remove
            {
                if (!_isAutomaticRequeryDisabled)
                {
                    CommandManager.RequerySuggested -= value;
                }
                CommandManagerHelper.RemoveWeakReferenceHandler(_canExecuteChangedHandlers, value);
            }
        }

        bool ICommand.CanExecute(object parameter)
        {
            // if T is of value type and the parameter is not
            // set yet, then return false if CanExecute delegate
            // exists, else return true
            if (parameter == null &&
                typeof(T).IsValueType)
            {
                return (_canExecuteMethod == null);
            }
            return CanExecute((T)parameter);
        }

        void ICommand.Execute(object parameter)
        {
            Execute((T)parameter);
        }

        #endregion

        #region Data

        private readonly Action<T> _executeMethod = null;
        private readonly Func<T, bool> _canExecuteMethod = null;
        private bool _isAutomaticRequeryDisabled = false;
        private List<WeakReference> _canExecuteChangedHandlers;

        #endregion
    }

    /// <summary>
    ///     This class contains methods for the CommandManager that help avoid memory leaks by
    ///     using weak references.
    /// </summary>
    internal class CommandManagerHelper
    {
        internal static void CallWeakReferenceHandlers(List<WeakReference> handlers)
        {
            if (handlers != null)
            {
                // Take a snapshot of the handlers before we call out to them since the handlers
                // could cause the array to me modified while we are reading it.

                EventHandler[] callees = new EventHandler[handlers.Count];
                int count = 0;

                for (int i = handlers.Count - 1; i >= 0; i--)
                {
                    WeakReference reference = handlers[i];
                    EventHandler handler = reference.Target as EventHandler;
                    if (handler == null)
                    {
                        // Clean up old handlers that have been collected
                        handlers.RemoveAt(i);
                    }
                    else
                    {
                        callees[count] = handler;
                        count++;
                    }
                }

                // Call the handlers that we snapshotted
                for (int i = 0; i < count; i++)
                {
                    EventHandler handler = callees[i];
                    handler(null, EventArgs.Empty);
                }
            }
        }

        internal static void AddHandlersToRequerySuggested(List<WeakReference> handlers)
        {
            if (handlers != null)
            {
                foreach (WeakReference handlerRef in handlers)
                {
                    EventHandler handler = handlerRef.Target as EventHandler;
                    if (handler != null)
                    {
                        CommandManager.RequerySuggested += handler;
                    }
                }
            }
        }

        internal static void RemoveHandlersFromRequerySuggested(List<WeakReference> handlers)
        {
            if (handlers != null)
            {
                foreach (WeakReference handlerRef in handlers)
                {
                    EventHandler handler = handlerRef.Target as EventHandler;
                    if (handler != null)
                    {
                        CommandManager.RequerySuggested -= handler;
                    }
                }
            }
        }

        internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler)
        {
            AddWeakReferenceHandler(ref handlers, handler, -1);
        }

        internal static void AddWeakReferenceHandler(ref List<WeakReference> handlers, EventHandler handler, int defaultListSize)
        {
            if (handlers == null)
            {
                handlers = (defaultListSize > 0 ? new List<WeakReference>(defaultListSize) : new List<WeakReference>());
            }

            handlers.Add(new WeakReference(handler));
        }

        internal static void RemoveWeakReferenceHandler(List<WeakReference> handlers, EventHandler handler)
        {
            if (handlers != null)
            {
                for (int i = handlers.Count - 1; i >= 0; i--)
                {
                    WeakReference reference = handlers[i];
                    EventHandler existingHandler = reference.Target as EventHandler;
                    if ((existingHandler == null) || (existingHandler == handler))
                    {
                        // Clean up old handlers that have been collected
                        // in addition to the handler that is to be removed.
                        handlers.RemoveAt(i);
                    }
                }
            }
        }
    }
}

---

查看模型

的 ViewModelBase.cs 的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;

namespace NestedCommands.ViewModels
{
    class ViewModelBase : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(object sender, string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                PropertyChanged(sender, new PropertyChangedEventArgs(propertyName));
            }
        }
    }
}

的 MainViewModel.cs 的

using System;
using System.Windows.Input;

namespace NestedCommands.ViewModels
{
    class MainViewModel : ViewModelBase
    {
        public MainViewModel()
        {
            _SummaryViewModel = new SummaryViewModel();
        }

        private SummaryViewModel _SummaryViewModel;
        public SummaryViewModel SummaryViewModel
        {
            get { return _SummaryViewModel; }
            set
            {
                _SummaryViewModel = value;
                OnPropertyChanged(this, "SummaryViewModel");
            }
        }

        public ICommand ShoutCommand
        {
            get { return _SummaryViewModel.ShoutCommand; }
        }
    }
}

的 SummaryViewModel.cs 的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NestedCommands.Commands;
using System.Windows.Input;

namespace NestedCommands.ViewModels
{
    class SummaryViewModel : ViewModelBase
    {
        #region Constructor

        public SummaryViewModel()
        {
            List<SummaryFilterViewModel> filters = new List<SummaryFilterViewModel>();
            filters.Add(new SummaryFilterViewModel("Filter 1"));
            filters.Add(new SummaryFilterViewModel("Filter 2"));
            filters.Add(new SummaryFilterViewModel("Filter 3"));
            Filters = filters;
        }

        #endregion

        #region Properties

        private List<SummaryFilterViewModel> _Filters;
        public List<SummaryFilterViewModel> Filters
        {
            get { return _Filters; }
            set
            {
                _Filters = value;
                OnPropertyChanged(this, "Filters");
            }
        }

        private int _SelectedTabIndex;
        public int SelectedTabIndex
        {
            get { return _SelectedTabIndex; }
            set
            {
                _SelectedTabIndex = value;
                OnPropertyChanged(this, "SelectedTabIndex");
            }
        }

        #endregion

        #region Command References

        public ICommand ShoutCommand
        {
            get { return Filters[SelectedTabIndex].ShoutCommand; }
        }

        #endregion
    }
}

的 SummaryFilterViewModel.cs 的

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NestedCommands.Commands;
using System.Windows.Input;

namespace NestedCommands.ViewModels
{
    class SummaryFilterViewModel : ViewModelBase
    {
        #region Constructor

        public SummaryFilterViewModel(string FilterName)
        {
            this.FilterName = FilterName;

            List<string> listData = new List<string>();
            for (int i = 1; i < 10; i++)
            {
                listData.Add(string.Format("{0}: {1}", FilterName, i));
            }
            ListData = listData;
        }

        #endregion

        #region Properties

        private string _FilterName;
        public string FilterName
        {
            get { return _FilterName; }
            set
            {
                _FilterName = value;
                OnPropertyChanged(this, "FilterName");
            }
        }

        private List<string> _ListData;
        public List<string> ListData
        {
            get { return _ListData; }
            set
            {
                _ListData = value;
                OnPropertyChanged(this, "ListData");
            }
        }

        #endregion

        #region Shout Command

        private DelegateCommand _ShoutCommand;
        public ICommand ShoutCommand
        {
            get { return _ShoutCommand ?? (_ShoutCommand = new DelegateCommand(Shout, CanShout)); }
        }

        private void Shout()
        {
            System.Windows.MessageBox.Show(string.Format("Called from SummaryFilterViewModel: {0}", FilterName));
        }

        private bool CanShout()
        {
            return true;
        }

        #endregion
    }
}

Answer 1

我认为你要走的道路很快会变得复杂而且紧密耦合。您应该看一下使用Mediator Pattern来促进SummaryFilterViewModel中的更改与MainViewModel的通信。

使用中介模式，您可以实现订阅和发布消息的方法，允许一个视图模型与另一个视图模型进行通信，而不会使用紧密耦合的视图模型。

基本上，当选项卡选择发生更改时，摘要视图模型将使用包含引用对象或其他数据的消息有效内容发布更改。主视图模型将订阅此消息的发布并相应地修改其状态。

您可以查看Mediator Pattern上的一些资源：

• http://www.eggheadcafe.com/tutorials/aspnet/ec832ac7-6e4c-4ea8-81ab-7374d3da3425/wpf-and-the-model-view-vi.aspx
• http://marlongrech.wordpress.com/2008/03/20/more-than-just-mvc-for-wpf/
• http://marlongrech.wordpress.com/2009/04/16/mediator-v2-for-mvvm-wpf-and-silverlight-applications/

Answer 2

你的帖子很长，我承认我没有完全阅读它。但是，我不理解CommandReference的目的。为什么不直接绑定到MainViewModel.ShoutCommand？考虑：

• 将ItemsSource的{​​{1}}绑定到子视图模型集合
• 将TabControl的{​​{1}}绑定到跟踪所选子视图模型的另一个属性
• 当上述属性发生变化时，也会提升SelectedItem属性的TabControl事件
• 在PropertyChanged属性的getter中，只需返回所选子视图模型的ShoutCommand

Answer 3

我对我的示例解决方案进行了一些更改，以回应Kent Boogaart提出的一些建议。肯特，再次感谢你的答复，它给了我一个新的方向。

我会尽量保持这个。

• MainView基本上是一个容纳应用程序主命令接口的框架集。在示例中，SummaryView直接嵌入在MainView的XAML中。在真正的解决方案中，它是一个内容控件，可能包含不同类型的子视图。每种类型的子视图都可能实现或不实现该命令。
• 我能够将SelectedIndex连接到一个属性，这样我就不需要依赖System.Windows.Control库了。当该属性更改时，我还为ShoutCommand属性调用OnPropertyChanged。
• 然而，这并未将该更改转发给MainView对象。所以，在MainViewModel中，我监听_SummaryViewModel.PropertyChanged事件。
• 当MainView听到_SummaryViewModel.PropertyChanged事件被触发时，我调用OnPropertyChanged（这个，“ShoutCommand”），它将更改传播到MainView。

所以，我想我想知道MainViewModel是否有必要像我正在做的那样收听_SummaryViewModel的PropertyChanged事件，或者是否有更简洁的方法来执行它。

我的代码列在下面:(我尽可能多地拿出来）

谢谢！

<强>的MainView

<v:SummaryView Grid.Row="0"
               DataContext="{Binding SummaryViewModel}" />
<Button Content="Shout Command"
        Grid.Row="1"
        Command="{Binding ShoutCommand}" />

<强> MainViewModel

public MainViewModel()
{
    _SummaryViewModel = new SummaryViewModel();
    _SummaryViewModel.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_SummaryViewModel_PropertyChanged);
}

void _SummaryViewModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
    switch (e.PropertyName)
    {
        case "ShoutCommand":
            OnPropertyChanged(this, "ShoutCommand");
            break;
    }
}

private SummaryViewModel _SummaryViewModel;
public SummaryViewModel SummaryViewModel {...}

public ICommand ShoutCommand
{
    get { return _SummaryViewModel.ShoutCommand; }
}

<强> SummaryView

<TabControl SelectedIndex="{Binding SelectedTabIndex}">
    <TabItem DataContext="{Binding Filters[0]}" Header="{Binding FilterName}">
        <ListBox ItemsSource="{Binding ListData}" />
    </TabItem>
    <!-- TabItem repeated two more times -->
</TabControl>

<强> SummaryViewModel

private List<SummaryFilterViewModel> _Filters;
public List<SummaryFilterViewModel> Filters {...}

private int _SelectedTabIndex;
public int SelectedTabIndex 
{
    get { return _SelectedTabIndex; }
    set
    {
        _SelectedTabIndex = value;
        OnPropertyChanged(this, "SelectedTabIndex");
        OnPropertyChanged(this, "ShoutCommand");
    }
}

public ICommand ShoutCommand
{
    get {
        int selectedTabIndex = SelectedTabIndex;

        return (selectedTabIndex == -1) ? null : Filters[SelectedTabIndex].ShoutCommand; 
    }
}