WPF应用多任务并行执行时如何避免UI阻塞？

在WPF应用中异步向URL提交数据时（无论是否更新UI），应用UI会停止拖动和调整大小；若为每个Task设置较大延迟（如i*100），UI操作会更流畅。推测WPF仍在频繁切换至UI线程，请求验证该推测，并询问在WPF中运行大量长任务（如200+城市的时间显示定时器）的正确实现方式。测试代码在控制台程序中运行正常，测试代码如下：

private async Task DoWorkAsync()
{
    var tasks = new List<Task>();
    for (int i = 1; i <= 500; i++)
    {
        string message = $"Message id - {i}";
        int taskId = i;
        var delay = i * 10;
        var task = Task.Run(async () =>
        {
            var threadId = Thread.CurrentThread.ManagedThreadId;
            await Task.Delay(delay);

            using var client = new HttpClient();
            var data = new Dictionary<string, string>
            {
                {"taskId", taskId.ToString()},
                {"message", message},
                {"threadID", threadId.ToString()}
            };

            var response = await client.PostAsync("https://jsonplaceholder.typicode.com/todos", new FormUrlEncodedContent(data));
            var content = await response.Content.ReadAsStringAsync();

            await Dispatcher.InvokeAsync(() => MyLabel.Text += content);
        });

        tasks.Add(task);
    }

    await Task.WhenAll(tasks).ConfigureAwait(false);
}

按钮点击事件代码：

private async void RightWayToRunAsyncInWPF_OnClick(object sender, RoutedEventArgs e)
{
    MyLabel.Text = "Start doing work...";
    await DoShitsAsync();
    MyLabel.Text += "Awesome workdone!!!";
}

你的推测完全正确，核心问题出在两点：

1. 大量并发任务集中触发UI更新：一次性启动500个任务，它们会在相近时间点完成网络请求，随后通过Dispatcher.InvokeAsync向UI线程发送大量更新请求。UI线程被这些请求占满，根本腾不出时间处理窗口拖动、调整大小这类用户输入事件。
2. HttpClient实例滥用：每个任务都新建HttpClient，会导致大量Socket资源占用，间接加剧线程池负载，进一步拖慢UI线程响应。

一、批量异步网络请求优化 #

针对当前的网络请求场景，优化要点如下：

• 复用HttpClient：HttpClient是线程安全的，全局复用一个实例即可，避免频繁创建销毁的资源开销。
• 限制并发数：用SemaphoreSlim控制同时运行的任务数量，避免线程池和网络资源过载，同时分散UI更新的压力。
• 合并UI更新：不要每个任务单独更新UI，收集所有结果后一次性或分批更新，减少UI线程切换次数。

优化后的代码示例：

// 全局复用HttpClient实例
private static readonly HttpClient _httpClient = new HttpClient();
// 限制同时运行的任务数为10，可根据实际情况调整
private readonly SemaphoreSlim _concurrencySemaphore = new SemaphoreSlim(10);

private async Task DoWorkAsync()
{
    var tasks = new List<Task<string>>();
    for (int i = 1; i <= 500; i++)
    {
        string message = $"Message id - {i}";
        int taskId = i;
        var delay = i * 10;
        tasks.Add(ProcessSingleTaskAsync(taskId, message, delay));
    }

    // 等待所有任务完成，统一收集结果
    var allResults = await Task.WhenAll(tasks).ConfigureAwait(false);
    // 一次性更新UI，减少Dispatcher调用次数
    await Dispatcher.InvokeAsync(() =>
    {
        foreach (var result in allResults)
        {
            MyLabel.Text += result;
        }
    });
}

private async Task<string> ProcessSingleTaskAsync(int taskId, string message, int delay)
{
    await _concurrencySemaphore.WaitAsync();
    try
    {
        var threadId = Thread.CurrentThread.ManagedThreadId;
        await Task.Delay(delay);

        var data = new Dictionary<string, string>
        {
            {"taskId", taskId.ToString()},
            {"message", message},
            {"threadID", threadId.ToString()}
        };

        var response = await _httpClient.PostAsync("https://jsonplaceholder.typicode.com/todos", new FormUrlEncodedContent(data));
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
    finally
    {
        _concurrencySemaphore.Release();
    }
}

修正后的按钮点击事件：

private async void RightWayToRunAsyncInWPF_OnClick(object sender, RoutedEventArgs e)
{
    MyLabel.Text = "Start doing work...";
    await DoWorkAsync();
    MyLabel.Text += "Awesome workdone!!!";
}

二、大量长时定时器任务（如200+城市时间显示） #

这类场景不能给每个城市单独开定时器，否则会导致资源浪费和UI更新过载，正确做法是：

• 统一调度定时器：用单个System.Threading.Timer（后台定时器）或DispatcherTimer（UI线程定时器），每隔固定时间一次性计算所有城市的时间。
• MVVM数据绑定：将城市时间数据封装到ViewModel的ObservableCollection中，通过数据绑定自动更新UI，避免手动调用Dispatcher。
• 后台计算分离：把时间计算逻辑放到后台线程完成，计算后再更新ViewModel属性，利用数据绑定自动同步UI。

示例思路代码：

// ViewModel示例代码
public class CityTimeViewModel : INotifyPropertyChanged
{
    public ObservableCollection<CityTimeModel> CityTimes { get; } = new ObservableCollection<CityTimeModel>();
    private readonly System.Threading.Timer _updateTimer;

    public CityTimeViewModel()
    {
        // 初始化200+城市数据
        InitializeCities();
        // 每1秒触发一次时间更新
        _updateTimer = new System.Threading.Timer(UpdateAllCityTimes, null, TimeSpan.Zero, TimeSpan.FromSeconds(1));
    }

    private void UpdateAllCityTimes(object state)
    {
        // 后台线程计算所有城市当前时间
        var updatedTimes = CityTimes.Select(city => new CityTimeModel
        {
            CityName = city.CityName,
            TimeZoneId = city.TimeZoneId,
            CurrentTime = GetCurrentTimeInTimeZone(city.TimeZoneId)
        }).ToList();

        // 切换到UI线程更新集合
        Application.Current.Dispatcher.Invoke(() =>
        {
            for (int i = 0; i < CityTimes.Count; i++)
            {
                CityTimes[i] = updatedTimes[i];
            }
        });
    }

    // 模拟根据时区获取当前时间
    private DateTime GetCurrentTimeInTimeZone(string timeZoneId)
    {
        var timeZone = TimeZoneInfo.FindSystemTimeZoneById(timeZoneId);
        return TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, timeZone);
    }

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

// 城市时间实体类
public class CityTimeModel
{
    public string CityName { get; set; }
    public string TimeZoneId { get; set; }
    public DateTime CurrentTime { get; set; }
}

内容的提问来源于stack exchange，提问作者H. Ivanov