Question

让我们想象一下我有一些用户控制权。用户控件有一些子窗口。并且用户控制用户想要关闭某种类型的子窗口。用户控制代码中有一种方法：

public void CloseChildWindows(ChildWindowType type)
{
   ...
}

但我无法调用此方法，因为我无法直接访问该视图。

我想到的另一个解决方案是以某种方式将用户控件ViewModel公开为其属性之一（因此我可以绑定它并直接向ViewModel发出命令）。但我不希望用户控制用户知道有关用户控件ViewModel的任何信息。

那么解决这个问题的正确方法是什么？

Answer 1

我觉得我刚刚找到了一个相当不错的MVVM解决方案来解决这个问题。我写了一个暴露类型属性WindowType和布尔属性Open的行为。 DataBinding后者允许ViewModel轻松打开和关闭窗口，而不了解View。

得爱的行为...... :)

enter image description here

的Xaml：

<UserControl x:Class="WpfApplication1.OpenCloseWindowDemo"
             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" 
             xmlns:local="clr-namespace:WpfApplication1"
             xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
             mc:Ignorable="d" 
             d:DesignHeight="300" d:DesignWidth="300">

    <UserControl.DataContext>
        <local:ViewModel />
    </UserControl.DataContext>
    <i:Interaction.Behaviors>
        <!-- TwoWay binding is necessary, otherwise after user closed a window directly, it cannot be opened again -->
        <local:OpenCloseWindowBehavior WindowType="local:BlackWindow" Open="{Binding BlackOpen, Mode=TwoWay}" />
        <local:OpenCloseWindowBehavior WindowType="local:YellowWindow" Open="{Binding YellowOpen, Mode=TwoWay}" />
        <local:OpenCloseWindowBehavior WindowType="local:PurpleWindow" Open="{Binding PurpleOpen, Mode=TwoWay}" />
    </i:Interaction.Behaviors>
    <UserControl.Resources>
        <Thickness x:Key="StdMargin">5</Thickness>
        <Style TargetType="Button" >
            <Setter Property="MinWidth" Value="60" />
            <Setter Property="Margin" Value="{StaticResource StdMargin}" />
        </Style>
        <Style TargetType="Border" >
            <Setter Property="Margin" Value="{StaticResource StdMargin}" />
        </Style>
    </UserControl.Resources>

    <Grid>
        <StackPanel>
            <StackPanel Orientation="Horizontal">
                <Border Background="Black" Width="30" />
                <Button Content="Open" Command="{Binding OpenBlackCommand}" CommandParameter="True" />
                <Button Content="Close" Command="{Binding OpenBlackCommand}" CommandParameter="False" />
            </StackPanel>
            <StackPanel Orientation="Horizontal">
                <Border Background="Yellow" Width="30" />
                <Button Content="Open" Command="{Binding OpenYellowCommand}" CommandParameter="True" />
                <Button Content="Close" Command="{Binding OpenYellowCommand}" CommandParameter="False" />
            </StackPanel>
            <StackPanel Orientation="Horizontal">
                <Border Background="Purple" Width="30" />
                <Button Content="Open" Command="{Binding OpenPurpleCommand}" CommandParameter="True" />
                <Button Content="Close" Command="{Binding OpenPurpleCommand}" CommandParameter="False" />
            </StackPanel>
        </StackPanel>
    </Grid>
</UserControl>

YellowWindow（黑/紫等）：

<Window x:Class="WpfApplication1.YellowWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="YellowWindow" Height="300" Width="300">
    <Grid Background="Yellow" />
</Window>

ViewModel，ActionCommand：

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

namespace WpfApplication1
{
    public class ViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        private void OnPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }

        private bool _blackOpen;
        public bool BlackOpen { get { return _blackOpen; } set { _blackOpen = value; OnPropertyChanged("BlackOpen"); } }

        private bool _yellowOpen;
        public bool YellowOpen { get { return _yellowOpen; } set { _yellowOpen = value; OnPropertyChanged("YellowOpen"); } }

        private bool _purpleOpen;
        public bool PurpleOpen { get { return _purpleOpen; } set { _purpleOpen = value; OnPropertyChanged("PurpleOpen"); } }

        public ICommand OpenBlackCommand { get; private set; }
        public ICommand OpenYellowCommand { get; private set; }
        public ICommand OpenPurpleCommand { get; private set; }


        public ViewModel()
        {
            this.OpenBlackCommand = new ActionCommand<bool>(OpenBlack);
            this.OpenYellowCommand = new ActionCommand<bool>(OpenYellow);
            this.OpenPurpleCommand = new ActionCommand<bool>(OpenPurple);
        }

        private void OpenBlack(bool open) { this.BlackOpen = open; }
        private void OpenYellow(bool open) { this.YellowOpen = open; }
        private void OpenPurple(bool open) { this.PurpleOpen = open; }

    }

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

OpenCloseWindowBehavior：

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Interactivity;

namespace WpfApplication1
{
    public class OpenCloseWindowBehavior : Behavior<UserControl>
    {
        private Window _windowInstance;

        public Type WindowType { get { return (Type)GetValue(WindowTypeProperty); } set { SetValue(WindowTypeProperty, value); } }
        public static readonly DependencyProperty WindowTypeProperty = DependencyProperty.Register("WindowType", typeof(Type), typeof(OpenCloseWindowBehavior), new PropertyMetadata(null));

        public bool Open { get { return (bool)GetValue(OpenProperty); } set { SetValue(OpenProperty, value); } }
        public static readonly DependencyProperty OpenProperty = DependencyProperty.Register("Open", typeof(bool), typeof(OpenCloseWindowBehavior), new PropertyMetadata(false, OnOpenChanged));

        /// <summary>
        /// Opens or closes a window of type 'WindowType'.
        /// </summary>
        private static void OnOpenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var me = (OpenCloseWindowBehavior)d;
            if ((bool)e.NewValue)
            {
                object instance = Activator.CreateInstance(me.WindowType);
                if (instance is Window)
                {
                    Window window = (Window)instance;
                    window.Closing += (s, ev) => 
                    {
                        if (me.Open) // window closed directly by user
                        {
                            me._windowInstance = null; // prevents repeated Close call
                            me.Open = false; // set to false, so next time Open is set to true, OnOpenChanged is triggered again
                        }
                    }; 
                    window.Show();
                    me._windowInstance = window;
                }
                else
                {
                    // could check this already in PropertyChangedCallback of WindowType - but doesn't matter until someone actually tries to open it.
                    throw new ArgumentException(string.Format("Type '{0}' does not derive from System.Windows.Window.", me.WindowType));
                }
            }
            else 
            {
                if (me._windowInstance != null)
                    me._windowInstance.Close(); // closed by viewmodel
            }
        }
    }
}

Answer 2

我过去通过引入WindowManager的概念来处理这种情况，这是一个可怕的名称，所以让它与{{1}配对这只是稍微不那么可怕 - 但基本的想法是：

WindowViewModel

请注意：我只是非常偶然地把它扔在一起;你当然希望根据你的具体需求调整这个想法。

但是，任何人，基本前提是你的命令可以在public class WindowManager { public WindowManager() { VisibleWindows = new ObservableCollection<WindowViewModel>(); VisibleWindows.CollectionChanged += OnVisibleWindowsChanged; } public ObservableCollection<WindowViewModel> VisibleWindows {get; private set;} private void OnVisibleWindowsChanged(object sender, NotifyCollectionChangedEventArgs args) { // process changes, close any removed windows, open any added windows, etc. } } public class WindowViewModel : INotifyPropertyChanged { private bool _isOpen; private WindowManager _manager; public WindowViewModel(WindowManager manager) { _manager = manager; } public bool IsOpen { get { return _isOpen; } set { if(_isOpen && !value) { _manager.VisibleWindows.Remove(this); } if(value && !_isOpen) { _manager.VisibleWindows.Add(this); } _isOpen = value; OnPropertyChanged("IsOpen"); } } public event PropertyChangedEventHandler PropertyChanged = delegate {}; private void OnPropertyChanged(string name) { PropertyChanged(this, new PropertyChangedEventArgs(name)); } }对象上工作，适当地切换WindowViewModel标志，并且经理类处理打开/关闭任何新窗口。有很多可能的方法可以做到这一点，但过去它对我来说很有效（实际实现时并没有在我的手机上一起扔，也就是说）

Answer 3

纯粹主义者的合理方式是创建一个处理导航的服务。简短摘要：创建NavigationService，在NavigationService注册您的视图，并使用视图模型中的NavigationService进行导航。

示例：

class NavigationService
{
    private Window _a;

    public void RegisterViewA(Window a) { _a = a; }

    public void CloseWindowA() { a.Close(); }
}

要获得对NavigationService的引用，您可以在它上面进行抽象（即INavigationService）并通过IoC注册/获取它。更准确地说，您甚至可以进行两个抽象，一个包含注册方法（由视图使用）和一个包含执行器（由视图模型使用）的抽象。

有关更详细的示例，您可以查看Gill Cleeren的实施，该实施严重依赖于IoC：

http://www.silverlightshow.net/video/Applied-MVVM-in-Win8-Webinar.aspx从00:36:30开始

Answer 4

实现此目的的一种方法是视图模型请求关闭子窗口：

public class ExampleUserControl_ViewModel
{
    public Action ChildWindowsCloseRequested;

    ...
}

然后视图将订阅其视图模型的事件，并在触发时关闭窗口。

public class ExampleUserControl : UserControl
{
    public ExampleUserControl()
    {
        var viewModel = new ExampleUserControl_ViewModel();
        viewModel.ChildWindowsCloseRequested += OnChildWindowsCloseRequested;

        DataContext = viewModel;
    }

    private void OnChildWindowsCloseRequested()
    {
        // ... close child windows
    }

    ...
}

因此，视图模型可以确保在不了解视图的情况下关闭子窗口。

Answer 5

此问题的大多数答案都涉及一个由ViewModel控制的状态变量，而View则对此变量的更改起作用。这有利于有状态命令，例如打开或关闭窗口，或者只显示或隐藏某些控件。但它对无状态事件命令效果不佳。您可以在信号的上升沿触发某些操作，但需要再次将信号设置为低（假），否则它将不再触发。

我写了一篇关于 ViewCommand模式的文章来解决这个问题。它基本上是从View到当前ViewModel的常规命令的反方向。它涉及一个接口，每个ViewModel都可以实现该接口，以向所有当前连接的视图发送命令。可以扩展View以在其DataContext属性更改时向每个已分配的ViewModel注册。此注册将View添加到ViewModel中的Views列表。每当ViewModel需要在View中运行命令时，它会遍历所有已注册的视图并在它们上运行命令（如果存在）。这使用反射来查找View类中的ViewCommand方法，但是在相反方向上绑定也是如此。

View类中的ViewCommand方法：

public partial class TextItemView : UserControl
{
    [ViewCommand]
    public void FocusText()
    {
        MyTextBox.Focus();
    }
}

这是从ViewModel调用的：

private void OnAddText()
{
    ViewCommandManager.Invoke("FocusText");
}

该文章可用on my website和旧版on CodeProject。

包含的代码（BSD许可证）提供了允许在代码混淆期间重命名方法的措施。

在MVVM中为View提供一些命令

5 个答案: