WPF MVVM模式下如何从ViewModel关闭以窗口打开的UserControl

作为WPF MVVM新手，你担心当前写法违反MVVM是完全正确的——直接在ViewModel里实例化Window、操作View的可见性（比如win.bankRectangle.Visibility），这些都属于让ViewModel依赖具体View实现的反模式，会导致代码耦合度高、难以测试和维护。下面给你一套符合MVVM规范的实现方案：

核心思路：用服务模式解耦UI操作 #

MVVM的核心是ViewModel不直接依赖View，所有和UI相关的操作（比如打开/关闭窗口）都应该通过抽象服务来封装，ViewModel只依赖抽象接口，具体的UI实现交给服务类处理。

1. 定义窗口服务接口 #

首先创建一个抽象的窗口服务接口，封装打开弹窗、关闭弹窗的操作：

public interface IWindowService
{
    // 以对话框形式打开指定ViewModel对应的View
    bool? ShowDialog<TViewModel>(TViewModel viewModel) where TViewModel : class;
    
    // 关闭指定ViewModel对应的窗口
    void CloseWindow<TViewModel>(TViewModel viewModel) where TViewModel : class;
}

2. 实现窗口服务 #

接下来写这个接口的具体实现，负责实际的窗口创建和关闭逻辑：

public class WindowService : IWindowService
{
    // 存储ViewModel和对应窗口的映射，方便后续关闭
    private readonly Dictionary<object, Window> _viewModelToWindowMap = new();

    public bool? ShowDialog<TViewModel>(TViewModel viewModel) where TViewModel : class
    {
        // 根据ViewModel找到对应的View（约定View名称为ViewModel名称去掉"ViewModel"后缀，比如OtherOptionsViewModel对应OtherOptionsView）
        var viewType = Type.GetType(typeof(TViewModel).FullName.Replace("ViewModel", "View"));
        if (viewType == null)
            throw new InvalidOperationException($"未找到对应View：{typeof(TViewModel).Name}");

        var view = Activator.CreateInstance(viewType) as FrameworkElement;
        if (view == null)
            throw new InvalidOperationException($"View {viewType.Name}不是FrameworkElement");

        // 绑定ViewModel到View的DataContext
        view.DataContext = viewModel;

        var window = new Window
        {
            WindowStyle = WindowStyle.None,
            SizeToContent = SizeToContent.WidthAndHeight,
            ResizeMode = ResizeMode.NoResize,
            Content = view,
            Owner = Application.Current.MainWindow,
            WindowStartupLocation = WindowStartupLocation.CenterOwner
        };

        // 记录ViewModel和窗口的映射
        _viewModelToWindowMap.Add(viewModel, window);

        // 窗口关闭时移除映射
        window.Closed += (s, e) => _viewModelToWindowMap.Remove(viewModel);

        return window.ShowDialog();
    }

    public void CloseWindow<TViewModel>(TViewModel viewModel) where TViewModel : class
    {
        if (_viewModelToWindowMap.TryGetValue(viewModel, out var window))
        {
            window.Close();
        }
    }
}

3. 改造MainWindowViewModel #

现在MainWindowViewModel不再直接创建窗口，而是依赖IWindowService来打开弹窗，同时把bankRectangle的可见性改成绑定ViewModel的属性：

public class MainWindowViewModel : INotifyPropertyChanged
{
    private readonly IWindowService _windowService;
    private Visibility _bankRectangleVisibility = Visibility.Collapsed;

    public Visibility BankRectangleVisibility
    {
        get => _bankRectangleVisibility;
        set
        {
            _bankRectangleVisibility = value;
            OnPropertyChanged();
        }
    }

    public ICommand OpenOtherOptionsCommand { get; }

    public MainWindowViewModel(IWindowService windowService)
    {
        _windowService = windowService;
        OpenOtherOptionsCommand = new RelayCommand(ExecuteOpenOtherOptions);
    }

    private void ExecuteOpenOtherOptions(object parameter)
    {
        // 创建弹窗的ViewModel
        var otherOptionsVm = new OtherOptionsViewModel(_windowService);
        
        // 监听弹窗关闭后的事件（比如恢复主窗口元素可见性）
        otherOptionsVm.WindowClosed += () => BankRectangleVisibility = Visibility.Collapsed;
        
        // 显示弹窗前设置主窗口元素可见性
        BankRectangleVisibility = Visibility.Visible;
        
        // 调用服务打开弹窗
        _windowService.ShowDialog(otherOptionsVm);
    }

    // INotifyPropertyChanged实现
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

4. 实现弹窗的ViewModel（OtherOptionsViewModel） #

弹窗ViewModel通过依赖的IWindowService来请求关闭窗口，同时定义一个事件通知主窗口弹窗已关闭：

public class OtherOptionsViewModel : INotifyPropertyChanged
{
    private readonly IWindowService _windowService;
    public event Action WindowClosed;

    public ICommand CloseCommand { get; }

    public OtherOptionsViewModel(IWindowService windowService)
    {
        _windowService = windowService;
        CloseCommand = new RelayCommand(ExecuteClose);
    }

    private void ExecuteClose(object parameter)
    {
        // 调用服务关闭当前窗口
        _windowService.CloseWindow(this);
        
        // 通知主窗口弹窗已关闭
        WindowClosed?.Invoke();
    }

    // INotifyPropertyChanged实现
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

5. 绑定主窗口的可见性 #

在MainWindow的XAML里，把bankRectangle的Visibility绑定到ViewModel的BankRectangleVisibility属性：

<Rectangle x:Name="bankRectangle" Visibility="{Binding BankRectangleVisibility}" ... />

6. 注入服务（依赖注入） #

最后，在应用启动时注册服务（这里以原生DI为例，用第三方容器也可以）：

public partial class App : Application
{
    protected override void OnStartup(StartupEventArgs e)
    {
        var serviceProvider = new ServiceCollection()
            .AddSingleton<IWindowService, WindowService>()
            .AddSingleton<MainWindowViewModel>()
            .BuildServiceProvider();

        var mainWindow = new MainWindow
        {
            DataContext = serviceProvider.GetService<MainWindowViewModel>()
        };
        mainWindow.Show();
        base.OnStartup(e);
    }
}

为什么这符合MVVM规范？ #

• ViewModel不依赖具体View：所有窗口操作都通过IWindowService接口完成，ViewModel不知道具体的窗口实现细节。
• 数据驱动UI：主窗口元素的可见性通过绑定ViewModel的属性实现，而非直接操作View元素。
• 低耦合：服务可以被替换（比如测试时用模拟服务），ViewModel的业务逻辑不受UI变化影响。

内容的提问来源于stack exchange，提问作者B.Mohm