WPF无框架MVVM场景：带所有者ShowDialog与后台任务处理

这个问题绝对是无框架WPF MVVM新手的典型痛点——一边要恪守ViewModel与视图完全解耦的原则，一边又要处理进度对话框这种必须依赖视图上下文（比如设置所有者窗口）的交互场景。我给你分享两个最实用的无框架实现方案，都能完美解决你的问题：

方案一：抽象对话框服务（最常用、最直观） #

核心思路是用依赖倒置：定义一个抽象的对话框服务接口，ViewModel只依赖这个接口，具体的对话框显示逻辑（包括设置所有者窗口）放到视图层的服务实现里，完全隔离ViewModel和视图的直接依赖。

1. 定义对话框服务接口 #

首先在你的ViewModel项目（或核心项目）里定义接口，只暴露必要的功能，不要涉及任何视图类型：

public interface IProgressDialogService
{
    // 参数包含进度对象、取消令牌源，以及对话框标题/提示文本
    void ShowProgressDialog(string title, string message, IProgress<int> progress, CancellationTokenSource cancellationTokenSource);
}

2. 实现具体的对话框服务（视图层） #

在你的WPF项目（视图层）里实现这个接口，这里可以直接操作Window类型，因为这是视图层的代码，ViewModel完全看不到：

public class ProgressDialogService : IProgressDialogService
{
    public void ShowProgressDialog(string title, string message, IProgress<int> progress, CancellationTokenSource cts)
    {
        // 实例化你的进度对话框视图
        var progressDialog = new ProgressDialog();
        
        // 设置对话框所有者为当前主窗口（或者你可以根据需求调整，比如获取激活窗口）
        progressDialog.Owner = Application.Current.MainWindow;
        progressDialog.Title = title;
        
        // 给对话框绑定对应的ViewModel（专门为对话框做的小型ViewModel）
        progressDialog.DataContext = new ProgressDialogViewModel(message, progress, cts);
        
        // 显示模态对话框
        progressDialog.ShowDialog();
    }
}

3. 对话框的ViewModel #

给进度对话框写一个小型ViewModel，负责绑定进度条和取消按钮的命令：

public class ProgressDialogViewModel : INotifyPropertyChanged
{
    private readonly CancellationTokenSource _cts;
    private readonly IProgress<int> _progress;
    private int _currentProgress;

    // 绑定到对话框的提示文本
    public string Message { get; }
    
    // 绑定到取消按钮的命令
    public ICommand CancelCommand { get; }

    // 绑定到进度条的Value属性
    public int CurrentProgress
    {
        get => _currentProgress;
        set
        {
            _currentProgress = value;
            OnPropertyChanged();
        }
    }

    public ProgressDialogViewModel(string message, IProgress<int> progress, CancellationTokenSource cts)
    {
        Message = message;
        _cts = cts;
        _progress = progress;
        
        // 取消按钮触发时，调用令牌源的Cancel方法
        CancelCommand = new RelayCommand(() => _cts.Cancel());
        
        // 订阅进度更新，自动同步到CurrentProgress属性（IProgress<T>会自动切换到UI线程）
        _progress.ProgressChanged += (sender, value) => CurrentProgress = value;
    }

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

4. 基础命令类（无框架必备） #

因为你不用MVVM框架，得自己实现一个最简单的RelayCommand：

public class RelayCommand : ICommand
{
    private readonly Action _execute;
    private readonly Func<bool> _canExecute;

    public RelayCommand(Action execute, Func<bool> canExecute = null)
    {
        _execute = execute ?? throw new ArgumentNullException(nameof(execute));
        _canExecute = canExecute;
    }

    public event EventHandler CanExecuteChanged
    {
        add => CommandManager.RequerySuggested += value;
        remove => CommandManager.RequerySuggested -= value;
    }

    public bool CanExecute(object parameter) => _canExecute?.Invoke() ?? true;
    public void Execute(object parameter) => _execute();
}

5. 主ViewModel的实现 #

主ViewModel只依赖IProgressDialogService接口，完全不知道具体的对话框视图：

public class MainViewModel : INotifyPropertyChanged
{
    private readonly IProgressDialogService _dialogService;
    
    // 绑定到主窗口的「开始工作」按钮
    public ICommand StartWorkCommand { get; }

    public MainViewModel(IProgressDialogService dialogService)
    {
        _dialogService = dialogService;
        StartWorkCommand = new RelayCommand(StartWork);
    }

    private async void StartWork()
    {
        var cancellationTokenSource = new CancellationTokenSource();
        var progress = new Progress<int>();

        // 调用服务显示对话框，ViewModel完全不接触视图细节
        _dialogService.ShowProgressDialog("工作中", "正在处理任务，请稍候...", progress, cancellationTokenSource);

        try
        {
            // 启动后台工作，传入取消令牌和进度对象
            await Task.Run(() => DoBackgroundWork(cancellationTokenSource.Token, progress), cancellationTokenSource.Token);
        }
        catch (OperationCanceledException)
        {
            // 处理用户取消的逻辑，比如提示任务已取消
        }
    }

    // 模拟后台工作
    private void DoBackgroundWork(CancellationToken token, IProgress<int> progress)
    {
        for (int i = 0; i <= 100; i++)
        {
            // 检查是否取消，如果是则抛出异常终止任务
            token.ThrowIfCancellationRequested();
            
            // 模拟耗时操作
            Thread.Sleep(50);
            
            // 报告进度
            progress.Report(i);
        }
    }

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

6. 视图层注入服务 #

在主窗口的构造函数里，手动创建服务实例并注入到主ViewModel（无框架下不用DI容器，手动注入即可）：

public MainWindow()
{
    InitializeComponent();
    
    var dialogService = new ProgressDialogService();
    DataContext = new MainViewModel(dialogService);
}

方案二：事件聚合器（更松散耦合） #

如果你的项目比较复杂，需要多个视图和ViewModel交互，可以用事件聚合器的方式：ViewModel发布一个「显示进度对话框」的事件，视图订阅这个事件并负责显示对话框。

1. 定义事件类 #

public class ShowProgressDialogEvent
{
    public string Title { get; set; }
    public string Message { get; set; }
    public IProgress<int> Progress { get; set; }
    public CancellationTokenSource CancellationTokenSource { get; set; }
}

2. 定义事件聚合器接口 #

public interface IEventAggregator
{
    void Publish<TEvent>(TEvent eventInstance);
    void Subscribe<TEvent>(Action<TEvent> handler);
}

3. 实现事件聚合器 #

public class EventAggregator : IEventAggregator
{
    private readonly Dictionary<Type, List<Delegate>> _eventHandlers = new();

    public void Publish<TEvent>(TEvent eventInstance)
    {
        if (_eventHandlers.TryGetValue(typeof(TEvent), out var handlers))
        {
            foreach (var handler in handlers.ToList())
            {
                ((Action<TEvent>)handler).Invoke(eventInstance);
            }
        }
    }

    public void Subscribe<TEvent>(Action<TEvent> handler)
    {
        var eventType = typeof(TEvent);
        if (!_eventHandlers.ContainsKey(eventType))
        {
            _eventHandlers[eventType] = new List<Delegate>();
        }
        _eventHandlers[eventType].Add(handler);
    }
}

4. 主ViewModel发布事件 #

public class MainViewModel : INotifyPropertyChanged
{
    private readonly IEventAggregator _eventAggregator;
    public ICommand StartWorkCommand { get; }

    public MainViewModel(IEventAggregator eventAggregator)
    {
        _eventAggregator = eventAggregator;
        StartWorkCommand = new RelayCommand(StartWork);
    }

    private async void StartWork()
    {
        var cts = new CancellationTokenSource();
        var progress = new Progress<int>();

        // 发布显示对话框的事件
        _eventAggregator.Publish(new ShowProgressDialogEvent
        {
            Title = "工作中",
            Message = "正在处理任务...",
            Progress = progress,
            CancellationTokenSource = cts
        });

        try
        {
            await Task.Run(() => DoBackgroundWork(cts.Token, progress), cts.Token);
        }
        catch (OperationCanceledException)
        {
            // 处理取消逻辑
        }
    }

    // ... 其他代码和方案一一致
}

5. 主窗口订阅事件 #

public MainWindow()
{
    InitializeComponent();
    
    var eventAggregator = new EventAggregator();
    DataContext = new MainViewModel(eventAggregator);
    
    // 订阅显示进度对话框的事件
    eventAggregator.Subscribe<ShowProgressDialogEvent>(e =>
    {
        var dialog = new ProgressDialog();
        dialog.Owner = this; // 直接设置当前窗口为所有者
        dialog.DataContext = new ProgressDialogViewModel(e.Message, e.Progress, e.CancellationTokenSource);
        dialog.ShowDialog();
    });
}

关键注意点 #

• 永远不要让ViewModel直接实例化或引用视图类型：所有视图相关的操作都通过抽象接口或事件委托给视图层处理
• 用CancellationToken处理取消逻辑：取消按钮只是触发令牌的取消，后台任务通过检查令牌来终止，逻辑完全在ViewModel层，视图只负责触发命令
• IProgress是线程安全的：它会自动把进度更新切换到UI线程，不用手动调用Dispatcher

内容的提问来源于stack exchange，提问作者Konrad