WPF 多线程与 Dispatcher

简介

WPF 的 UI 元素只允许创建它们的线程访问（UI 线程）。Dispatcher 是 WPF 提供的线程调度器，用于从后台线程安全地更新 UI。理解 Dispatcher 和多线程模型是编写响应式 WPF 应用的基础。

特点

• 1.UI 线程亲和性 — 只有 UI 线程能操作 UI 元素
• 2.Dispatcher 调度 — 后台线程通过 Dispatcher 更新 UI
• 3.优先级队列 — 按优先级执行 UI 操作
• 4.同步/异步 — 支持同步和异步调度

基本概念

UI 线程亲和性

/// <summary>
/// WPF 的 UI 线程亲和性 — 只有 UI 线程能操作 UI 元素
/// </summary>
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        // 错误！后台线程不能直接修改 UI
        Task.Run(() =>
        {
            // MyTextBlock.Text = "更新文本"; // 抛出 InvalidOperationException
        });

        // 正确！通过 Dispatcher
        Task.Run(() =>
        {
            Dispatcher.Invoke(() =>
            {
                MyTextBlock.Text = "更新文本";
            });
        });
    }
}

Dispatcher 使用

Invoke vs BeginInvoke

/// <summary>
/// Dispatcher 的同步和异步调用
/// </summary>
public class DispatcherExamples
{
    // Invoke — 同步调用（阻塞当前线程直到执行完毕）
    public void SyncUpdate(Window window)
    {
        Task.Run(() =>
        {
            // 阻塞后台线程，等待 UI 线程执行完毕
            window.Dispatcher.Invoke(() =>
            {
                window.Title = $"更新于 {DateTime.Now}";
            });
        });
    }

    // BeginInvoke — 异步调用（不阻塞）
    public void AsyncUpdate(Window window)
    {
        Task.Run(() =>
        {
            // 不阻塞后台线程，将操作放入 UI 线程队列
            window.Dispatcher.BeginInvoke(() =>
            {
                window.Title = $"更新于 {DateTime.Now}";
            });
        });
    }

    // 带优先级的调用
    public void PriorityUpdate(Window window)
    {
        window.Dispatcher.BeginInvoke(() =>
        {
            // 低优先级 — 不阻塞用户输入
            UpdateStatusText("处理中...");
        }, DispatcherPriority.Background);

        window.Dispatcher.BeginInvoke(() =>
        {
            // 正常优先级
            UpdateStatusText("处理完成");
        }, DispatcherPriority.Normal);
    }
}

Dispatcher 优先级

优先级	说明	适用场景
SystemIdle	系统空闲	极低优先级后台任务
ApplicationIdle	应用空闲	低优先级
Background	后台	不影响用户的操作
Normal	正常（默认）	一般 UI 更新
Input	输入	处理用户输入
Loaded	加载	布局加载
Render	渲染	渲染相关
Send	最高	立即执行

async/await 与 Dispatcher

在 WPF 中使用 async/await

/// <summary>
/// WPF 中 async/await 自动处理 Dispatcher
/// await 后会自动回到 UI 线程（SynchronizationContext）
/// </summary>
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    // 正确方式 — async/await 自动回到 UI 线程
    private async void LoadData_Click(object sender, RoutedEventArgs e)
    {
        LoadingIndicator.Visibility = Visibility.Visible; // UI 线程

        // await 会释放 UI 线程，不阻塞
        var data = await Task.Run(() => FetchDataFromDatabase());

        // await 之后自动回到 UI 线程，可直接更新 UI
        DataGrid.ItemsSource = data;
        LoadingIndicator.Visibility = Visibility.Collapsed;
    }

    // 配置不要回到 UI 线程
    private async void BackgroundWork_Click(object sender, RoutedEventArgs e)
    {
        // ConfigureAwait(false) — 不需要回到 UI 线程
        await Task.Run(() => DoHeavyComputation()).ConfigureAwait(false);

        // 这里不在 UI 线程，不能直接更新 UI！
        // MyTextBlock.Text = "完成"; // 错误！

        // 需要手动切换
        await Dispatcher.InvokeAsync(() =>
        {
            MyTextBlock.Text = "完成";
        });
    }

    // 进度报告 — IProgress<T> 自动回到 UI 线程
    private async void ProcessWithProgress_Click(object sender, RoutedEventArgs e)
    {
        var progress = new Progress<int>(percent =>
        {
            // 自动在 UI 线程执行
            ProgressBar.Value = percent;
            StatusText.Text = $"处理中... {percent}%";
        });

        await Task.Run(() => ProcessData(progress));

        StatusText.Text = "处理完成";
    }

    private void ProcessData(IProgress<int> progress)
    {
        for (int i = 0; i <= 100; i += 10)
        {
            Thread.Sleep(500); // 模拟处理
            progress?.Report(i);
        }
    }
}

BackgroundWorker — 传统方式

适用于 .NET Framework 兼容场景

/// <summary>
/// BackgroundWorker — 兼容老项目的后台任务方式
/// </summary>
public partial class MainWindow : Window
{
    private readonly BackgroundWorker _worker = new();

    public MainWindow()
    {
        InitializeComponent();

        _worker.WorkerReportsProgress = true;
        _worker.WorkerSupportsCancellation = true;

        _worker.DoWork += Worker_DoWork;
        _worker.ProgressChanged += Worker_ProgressChanged;
        _worker.RunWorkerCompleted += Worker_Completed;
    }

    private void StartButton_Click(object sender, RoutedEventArgs e)
    {
        _worker.RunWorkerAsync();
    }

    private void Worker_DoWork(object? sender, DoWorkEventArgs e)
    {
        // 在后台线程执行
        for (int i = 0; i <= 100; i += 5)
        {
            if (_worker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }

            Thread.Sleep(200);
            _worker.ReportProgress(i);
        }
    }

    private void Worker_ProgressChanged(object? sender, ProgressChangedEventArgs e)
    {
        // 自动在 UI 线程执行
        ProgressBar.Value = e.ProgressPercentage;
    }

    private void Worker_Completed(object? sender, RunWorkerCompletedEventArgs e)
    {
        // 自动在 UI 线程执行
        if (e.Cancelled)
            StatusText.Text = "已取消";
        else if (e.Error != null)
            StatusText.Text = $"错误：{e.Error.Message}";
        else
            StatusText.Text = "完成";
    }
}

实际应用场景

1. 实时数据监控

/// <summary>
/// 实时数据更新 — 后台线程采集，UI 线程显示
/// </summary>
public class RealTimeMonitorViewModel : ObservableObject, IDisposable
{
    private CancellationTokenSource _cts = new();
    private readonly IDeviceService _deviceService;

    private double _temperature;
    public double Temperature
    {
        get => _temperature;
        set => SetProperty(ref _temperature, value);
    }

    private double _pressure;
    public double Pressure
    {
        get => _pressure;
        set => SetProperty(ref _pressure, value);
    }

    public ICommand StartCommand { get; }
    public ICommand StopCommand { get; }

    public RealTimeMonitorViewModel(IDeviceService deviceService)
    {
        _deviceService = deviceService;
        StartCommand = new RelayCommand(StartMonitoring);
        StopCommand = new RelayCommand(StopMonitoring);
    }

    private async void StartMonitoring()
    {
        _cts = new CancellationTokenSource();

        await Task.Run(async () =>
        {
            while (!_cts.Token.IsCancellationRequested)
            {
                var data = _deviceService.ReadCurrentData();

                // 通过 Dispatcher 更新 UI
                Application.Current.Dispatcher.BeginInvoke(() =>
                {
                    Temperature = data.Temperature;
                    Pressure = data.Pressure;
                });

                await Task.Delay(500, _cts.Token);
            }
        }, _cts.Token);
    }

    private void StopMonitoring()
    {
        _cts.Cancel();
    }

    public void Dispose()
    {
        _cts.Cancel();
        _cts.Dispose();
    }
}

2. 防止 UI 冻结

/// <summary>
/// 防止 UI 冻结 — 所有耗时操作放到后台线程
/// </summary>
public partial class MainWindow : Window
{
    // 错误 — UI 冻结
    private void BadButton_Click(object sender, RoutedEventArgs e)
    {
        // 在 UI 线程上执行耗时操作 — UI 完全无响应
        var result = HeavyComputation();
        ResultText.Text = result;
    }

    // 正确 — 使用 async/await
    private async void GoodButton_Click(object sender, RoutedEventArgs e)
    {
        LoadingBar.IsIndeterminate = true;
        StatusText.Text = "计算中...";

        try
        {
            var result = await Task.Run(() => HeavyComputation());
            ResultText.Text = result;
            StatusText.Text = "完成";
        }
        catch (Exception ex)
        {
            StatusText.Text = $"错误：{ex.Message}";
        }
        finally
        {
            LoadingBar.IsIndeterminate = false;
        }
    }

    private string HeavyComputation()
    {
        Thread.Sleep(5000);
        return "计算结果";
    }
}

3. DispatcherTimer — UI 线程定时器

/// <summary>
/// DispatcherTimer — 在 UI 线程上定时执行
/// </summary>
public partial class MainWindow : Window
{
    private DispatcherTimer _timer = null!;
    private int _count;

    public MainWindow()
    {
        InitializeComponent();

        _timer = new DispatcherTimer
        {
            Interval = TimeSpan.FromSeconds(1)
        };
        _timer.Tick += Timer_Tick;
    }

    private void Timer_Tick(object? sender, EventArgs e)
    {
        // 在 UI 线程上执行，可以直接更新 UI
        _count++;
        TimerText.Text = $"已运行 {_count} 秒";
    }

    private void StartTimer_Click(object sender, RoutedEventArgs e)
    {
        _timer.Start();
    }

    private void StopTimer_Click(object sender, RoutedEventArgs e)
    {
        _timer.Stop();
    }
}

线程安全最佳实践

场景	建议
耗时操作	使用 async/await
更新 UI	Dispatcher.Invoke 或 await
定时 UI 更新	DispatcherTimer
进度报告	IProgress<T>
后台持续任务	Task.Run + CancellationToken
集合跨线程	BindingOperations.EnableCollectionSynchronization

高级场景

集合跨线程访问

/// <summary>
/// ObservableCollection 跨线程安全更新
/// </summary>
public class ThreadSafeObservableCollection<T> : ObservableCollection<T>
{
    private readonly Dispatcher _dispatcher;
    private readonly object _lock = new();

    public ThreadSafeObservableCollection()
    {
        _dispatcher = Application.Current.Dispatcher;
    }

    protected override void InsertItem(int index, T item)
    {
        if (_dispatcher.CheckAccess())
        {
            lock (_lock) { base.InsertItem(index, item); }
        }
        else
        {
            _dispatcher.BeginInvoke(() =>
            {
                lock (_lock) { base.InsertItem(index, item); }
            });
        }
    }

    protected override void RemoveItem(int index)
    {
        if (_dispatcher.CheckAccess())
        {
            lock (_lock) { base.RemoveItem(index); }
        }
        else
        {
            _dispatcher.BeginInvoke(() =>
            {
                lock (_lock) { base.RemoveItem(index); }
            });
        }
    }

    protected override void ClearItems()
    {
        if (_dispatcher.CheckAccess())
        {
            lock (_lock) { base.ClearItems(); }
        }
        else
        {
            _dispatcher.BeginInvoke(() =>
            {
                lock (_lock) { base.ClearItems(); }
            });
        }
    }
}

// 使用 BindingOperations（WPF 内置方式）
public class DeviceListViewModel : ObservableObject
{
    public ObservableCollection<DeviceDto> Devices { get; }

    public DeviceListViewModel()
    {
        Devices = new ObservableCollection<DeviceDto>();

        // 启用跨线程集合同步
        BindingOperations.EnableCollectionSynchronization(
            Devices,
            new object(),  // 锁对象
            (collection, context) =>
            {
                // 在 UI 线程执行集合操作
                Application.Current.Dispatcher.Invoke(() =>
                {
                    ((ICollection)collection).GetEnumerator();
                });
            });
    }
}

避免死锁的实践

/// <summary>
/// 常见死锁场景和解决方案
/// </summary>
public class DeadlockExamples
{
    // 死锁场景 1：在 UI 线程同步等待
    public void Bad_WaitOnUIThread()
    {
        // 错误！UI 线程被 Task.Run 阻塞，
        // Task 内的 Dispatcher.Invoke 需要 UI 线程 — 死锁！
        var result = Task.Run(() =>
        {
            // 这个操作需要 UI 线程
            Application.Current.Dispatcher.Invoke(() => "结果");
            return "完成";
        }).Result; // .Result 在 UI 线程上阻塞
    }

    // 解决方案：全部使用 async/await
    public async Task<string> Good_AsyncAllTheWay()
    {
        var result = await Task.Run(() =>
        {
            return DoBackgroundWork(); // 后台线程不做 UI 操作
        });

        // 回到 UI 线程再更新
        ResultText.Text = result;
        return result;
    }

    // 死锁场景 2：嵌套 Dispatcher.Invoke
    public void Bad_NestedInvoke()
    {
        Dispatcher.Invoke(() =>
        {
            // 外层已占用 UI 线程
            Dispatcher.Invoke(() =>
            {
                // 同步等待 UI 线程 — 死锁！
                StatusText.Text = "嵌套";
            });
        });
    }

    // 解决方案：避免嵌套同步调用
    public void Good_NoNestedInvoke()
    {
        Dispatcher.Invoke(() =>
        {
            StatusText.Text = "直接设置";
            // 已经在 UI 线程上，不需要再调用 Dispatcher
        });
    }

    private string DoBackgroundWork() => "后台计算结果";
}

批量更新与性能优化

/// <summary>
/// 大量 UI 更新的性能优化技巧
/// </summary>
public class BulkUpdateExample
{
    // 技巧 1：使用 DispatcherPriority 降低更新优先级
    public void LowPriorityUpdate(ObservableCollection<string> collection, List<string> items)
    {
        Task.Run(() =>
        {
            foreach (var item in items)
            {
                Application.Current.Dispatcher.BeginInvoke(() =>
                {
                    collection.Add(item);
                }, DispatcherPriority.Background); // 低优先级，不阻塞用户输入
            }
        });
    }

    // 技巧 2：批量更新使用单次 Invoke
    public void BatchUpdate(ObservableCollection<string> collection, List<string> items)
    {
        Task.Run(() =>
        {
            Application.Current.Dispatcher.Invoke(() =>
            {
                // 一次性添加所有项，只触发一次 CollectionChanged
                foreach (var item in items)
                {
                    collection.Add(item);
                }
            });
        });
    }

    // 技巧 3：虚拟化 + 延迟加载
    // 在 XAML 中启用虚拟化
    // <ListBox VirtualizingPanel.IsVirtualizing="True"
    //          VirtualizingPanel.VirtualizationMode="Recycling"
    //          ScrollViewer.CanContentScroll="True" />
}

优点

• 1.Dispatcher 简单 — 一行代码解决跨线程问题
• 2.async/await 原生支持 — 自动处理线程切换
• 3.优先级控制 — 可控制 UI 操作的优先级
• 4.DispatcherTimer — 简单的 UI 定时器

缺点

• 1.线程亲和性 — 增加了编程复杂度
• 2.死锁风险 — Dispatcher.Invoke 可能死锁
• 3.性能瓶颈 — 大量 Invoke 调用影响 UI 响应
• 4.调试困难 — 多线程 Bug 不易复现

总结

WPF 的 UI 线程亲和性要求所有 UI 操作在 UI 线程上执行。后台线程通过 Dispatcher 更新 UI，现代 C# 推荐使用 async/await 自动处理线程切换。核心原则：耗时操作放到后台线程，UI 更新用 Dispatcher 或 await 回到 UI 线程。

关键知识点

• 先分清主题属于界面层、ViewModel 层、线程模型还是设备接入层。
• WPF 文章真正的价值在于把 UI、数据、命令、线程和资源关系讲清楚。
• 上位机场景里，稳定性和异常恢复常常比界面花哨更重要。
• WPF 主题往往要同时理解依赖属性、绑定、可视树和命令系统。

项目落地视角

• 优先明确 DataContext、绑定路径、命令源和线程切换位置。
• 涉及设备时，补齐超时、重连、日志、告警和资源释放策略。
• 复杂控件最好提供最小可运行页面，便于后续复用和排障。
• 优先确认 DataContext、绑定路径、命令触发点和资源引用来源。

常见误区

• 把大量逻辑堆进 code-behind，导致页面难测难维护。
• 在后台线程直接操作 UI，或忽略 Dispatcher 切换。
• 只验证正常路径，不验证设备掉线、权限缺失和资源泄漏。
• 在 code-behind 塞太多状态与业务逻辑。

进阶路线

• 继续向 MVVM 工具链、控件可复用性、性能优化和视觉树诊断深入。
• 把主题放回真实设备流程，思考启动、连接、采集、显示、告警和恢复。
• 沉淀成控件库、通信层和诊断工具，提高整套客户端的复用度。
• 继续补齐控件库、主题系统、诊断工具和启动性能优化。

适用场景

• 当你准备把《WPF 多线程与 Dispatcher》真正落到项目里时，最适合先在一个独立模块或最小样例里验证关键路径。
• 适合桌面业务系统、监控看板、工控上位机和设备交互界面。
• 当系统需要同时处理复杂 UI、后台任务和硬件通信时，这类主题尤为关键。

落地建议

• 优先明确 View、ViewModel、服务层和设备层边界，避免代码隐藏过重。
• 涉及实时刷新时，提前设计 UI 线程切换、节流和资源释放。
• 对硬件通信、日志、告警和异常恢复建立标准流程。

排错清单

• 先检查 DataContext、绑定路径、INotifyPropertyChanged 和命令状态是否正常。
• 排查 Dispatcher 调用、死锁、后台线程直接操作 UI 的问题。
• 出现内存增长时，优先检查事件订阅、图像资源和窗口生命周期。

复盘问题

• 如果把《WPF 多线程与 Dispatcher》放进你的当前项目，最先要验证的输入、输出和失败路径分别是什么？
• 《WPF 多线程与 Dispatcher》最容易在什么规模、什么边界条件下暴露问题？你会用什么指标或日志去确认？
• 相比默认实现或替代方案，采用《WPF 多线程与 Dispatcher》最大的收益和代价分别是什么？

延伸阅读

• 主题切换与暗色模式
• TreeView 虚拟化与懒加载
• 配方管理（MES 场景）
• 设备心跳监控看板