寻求ViewModel中存储SynchronizationContext实现UI线程调度的平台无关模式

当然有这种成熟的「正确」模式！这在MVVM场景里是非常常见的需求，核心思路就是抽象平台差异，让ViewModel完全不依赖具体UI框架（比如WPF的Dispatcher、MAUI的MainThread这类），同时实现安全的UI线程调度与上下文检测。下面一步步拆解这个模式：

1. 定义平台无关的调度接口 #

首先要把UI线程调度的核心能力封装成抽象接口，这样ViewModel只依赖这个接口，完全不碰具体平台的实现细节：

public interface IDispatcher
{
    // 检测当前是否处于目标UI线程/同步上下文
    bool IsCurrentThread { get; }

    // 同步执行：如果在UI线程直接运行，否则调度到UI线程执行
    void Invoke(Action action);

    // 异步执行：调度到UI线程并返回Task，不阻塞调用线程
    Task InvokeAsync(Action action);

    // 带返回值的异步执行
    Task<T> InvokeAsync<T>(Func<T> func);
}

这个接口覆盖了绝大多数场景：上下文检测、同步/异步调度、带返回值的操作，足够灵活且通用。

2. 实现平台特定的Dispatcher实例 #

针对不同的UI平台（WPF、MAUI、WinForms等），实现这个接口。这里以WPF为例，用SynchronizationContext来实现：

public class WpfDispatcher : IDispatcher
{
    private readonly SynchronizationContext _uiSyncContext;

    public WpfDispatcher()
    {
        // 必须在UI线程初始化，才能捕获到正确的同步上下文
        _uiSyncContext = SynchronizationContext.Current 
            ?? throw new InvalidOperationException("请在UI线程初始化Dispatcher实例");
    }

    public bool IsCurrentThread => SynchronizationContext.Current == _uiSyncContext;

    public void Invoke(Action action)
    {
        if (IsCurrentThread)
        {
            action();
        }
        else
        {
            // Send是同步调度，会阻塞直到执行完成
            _uiSyncContext.Send(_ => action(), null);
        }
    }

    public Task InvokeAsync(Action action)
    {
        if (IsCurrentThread)
        {
            action();
            return Task.CompletedTask;
        }
        else
        {
            var tcs = new TaskCompletionSource();
            // Post是异步调度，不会阻塞调用线程
            _uiSyncContext.Post(_ => 
            {
                try
                {
                    action();
                    tcs.SetResult();
                }
                catch (Exception ex)
                {
                    tcs.SetException(ex);
                }
            }, null);
            return tcs.Task;
        }
    }

    public Task<T> InvokeAsync<T>(Func<T> func)
    {
        if (IsCurrentThread)
        {
            return Task.FromResult(func());
        }
        else
        {
            var tcs = new TaskCompletionSource<T>();
            _uiSyncContext.Post(_ => 
            {
                try
                {
                    tcs.SetResult(func());
                }
                catch (Exception ex)
                {
                    tcs.SetException(ex);
                }
            }, null);
            return tcs.Task;
        }
    }
}

其他平台的实现逻辑类似：比如MAUI可以用MainThread.IsMainThread判断上下文，用MainThread.InvokeOnMainThreadAsync实现调度；WinForms同样可以基于SynchronizationContext或者Control.Invoke来实现。

3. 在ViewModel基类中注入Dispatcher #

把IDispatcher注入到ViewModel基类里，让所有子ViewModel都能直接使用这个调度能力，同时封装PropertyChanged事件的触发逻辑，确保UI绑定安全：

using System.ComponentModel;
using System.Runtime.CompilerServices;

public abstract class ViewModelBase : INotifyPropertyChanged
{
    protected readonly IDispatcher Dispatcher;

    protected ViewModelBase(IDispatcher dispatcher)
    {
        Dispatcher = dispatcher ?? throw new ArgumentNullException(nameof(dispatcher));
    }

    // 封装PropertyChanged，确保在UI线程触发，避免跨线程绑定异常
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        Dispatcher.Invoke(() => 
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        });
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

4. ViewModel中的实际使用示例 #

现在ViewModel就可以安全处理来自任意线程的调用了，比如后台线程触发的UI更新：

public class MyViewModel : ViewModelBase
{
    private string _operationStatus;
    public string OperationStatus
    {
        get => _operationStatus;
        private set 
        {
            _operationStatus = value;
            OnPropertyChanged();
        }
    }

    public MyViewModel(IDispatcher dispatcher) : base(dispatcher) { }

    // 这个方法可能被任意线程调用（比如后台任务、第三方回调）
    public async Task ExecuteBackgroundOperation()
    {
        // 先检测是否在UI线程，避免不必要的调度开销
        if (Dispatcher.IsCurrentThread)
        {
            OperationStatus = "操作开始...";
        }
        else
        {
            await Dispatcher.InvokeAsync(() => OperationStatus = "操作开始...");
        }

        // 模拟耗时的后台操作
        await Task.Delay(3000);

        // 调度回UI线程更新状态
        await Dispatcher.InvokeAsync(() => OperationStatus = "操作完成！");
    }
}

或者更简洁的写法——直接调用InvokeAsync即可，因为它内部已经做了上下文检测：

public async Task ExecuteBackgroundOperation()
{
    await Dispatcher.InvokeAsync(() => OperationStatus = "操作开始...");
    await Task.Delay(3000);
    await Dispatcher.InvokeAsync(() => OperationStatus = "操作完成！");
}

5. 关键：确保Dispatcher在UI线程初始化 #

最后一步是在应用启动时，在UI线程初始化对应的IDispatcher实现，并通过依赖注入容器注册。比如WPF的App.xaml.cs中：

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);

    // 用依赖注入容器注册（这里以Microsoft.Extensions.DependencyInjection为例）
    var services = new ServiceCollection();
    // 确保在UI线程初始化WpfDispatcher，捕获正确的同步上下文
    services.AddSingleton<IDispatcher>(new WpfDispatcher());
    // 注册ViewModel
    services.AddTransient<MyViewModel>();

    // 初始化窗口并注入ViewModel
    var serviceProvider = services.BuildServiceProvider();
    var mainWindow = new MainWindow
    {
        DataContext = serviceProvider.GetRequiredService<MyViewModel>()
    };
    mainWindow.Show();
}

为什么这是「正确」的模式？ #

• 平台无关：ViewModel完全不依赖具体UI框架，切换平台只需要替换IDispatcher的实现，可移植性极强。
• 清晰可控：显式的上下文检测与调度逻辑，避免隐式跨线程问题，调试和维护更简单。
• 符合MVVM原则：ViewModel不持有任何UI相关对象（比如Dispatcher、Window实例），严格保持关注点分离。
• 覆盖全场景：同步/异步、带返回值的调度都支持，满足绝大多数业务需求。

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