异步URL请求批量处理：等待完成及结果匹配技术问询

我来帮你解决这两个异步请求的问题，都是C#里常见的异步编程场景，咱们一个个来理清楚：

如果你用的是旧的WebClient的OpenReadAsync（APM异步模式），可以把它转换成Task，然后用Task.WhenAll来等待所有任务执行完毕。这里有两种实现方式：

方式1：将WebClient的APM模式转为Task #

public async Task ProcessAllUrlsAsync(List<string> urls)
{
    var requestTasks = new List<Task<Stream>>();

    foreach (var url in urls)
    {
        var uri = new Uri(url);
        var webClient = new WebClient();
        
        // 把OpenReadAsync的异步操作包装成Task
        var streamTask = Task.Factory.FromAsync(
            (callback, state) => ((WebClient)state).OpenReadAsync(uri, callback),
            ar => ((WebClient)ar.AsyncState).OpenReadCompletedEventArgs.Result,
            webClient);
        
        requestTasks.Add(streamTask);
    }

    // 等待所有请求完成
    await Task.WhenAll(requestTasks);

    // 所有请求完成后，逐个处理结果
    for (int i = 0; i < urls.Count; i++)
    {
        var targetUrl = urls[i];
        var responseStream = requestTasks[i].Result;
        // 这里可以处理对应URL的响应流
    }
}

方式2：推荐使用HttpClient（更现代的异步HTTP客户端） #

WebClient是比较老旧的API，现在更推荐用HttpClient，它原生支持Task异步模型，代码更简洁：

public async Task ProcessAllUrlsAsync(List<string> urls)
{
    using var httpClient = new HttpClient();
    // 为每个URL创建GetStreamAsync任务
    var requestTasks = urls.Select(url => httpClient.GetStreamAsync(url)).ToList();

    // 等待所有任务完成
    await Task.WhenAll(requestTasks);

    // 按顺序匹配URL和结果
    for (int i = 0; i < urls.Count; i++)
    {
        var url = urls[i];
        var stream = requestTasks[i].Result;
        // 处理对应URL的响应
    }
}

核心思路是：把每个异步请求包装成Task，收集所有任务后用Task.WhenAll等待全部完成，这样就能确保所有请求都执行完毕后再继续后续操作。

你原来的代码存在两个关键问题：

1. 闭包捕获变量的陷阱：循环里的urlx是引用类型，异步回调执行时，循环可能已经结束，导致所有回调都引用最后一个URL；
2. 无法等待所有回调完成：没有机制判断所有请求都处理完毕，后续流程没法同步等待。

下面是重构后的解决方案，改用基于Task的异步编程模型，彻底解决这两个问题：

步骤1：重构GetResponse为Task返回型方法 #

先把原来的回调式方法改成返回Task<MyResponse>的异步方法，这样更容易控制和等待：

private async Task<MyResponse> GetResponseAsync(Uri uri)
{
    using var webClient = new WebClient();
    // 把OpenReadAsync包装成Task
    var responseStream = await Task.Factory.FromAsync(
        webClient.OpenReadAsync,
        webClient.OpenReadCompleted,
        uri,
        null);

    // 反序列化响应
    var serializer = new DataContractJsonSerializer(typeof(MyResponse));
    return (MyResponse)serializer.ReadObject(responseStream);
}

步骤2：重构FillResults为异步方法，确保URL与结果匹配 #

// 假设Urls是List<string>类型的类成员
public async Task<List<Result>> FillResultsAsync()
{
    var results = new List<Result>();
    var taskList = new List<Task<(Uri Url, MyResponse Response)>>();

    foreach (var url in Urls)
    {
        var currentUri = new Uri(url);
        // 每个任务捕获当前迭代的currentUri，避免闭包陷阱
        var task = GetResponseAsync(currentUri)
            .ContinueWith(t => (Url: currentUri, Response: t.Result));
        
        taskList.Add(task);
    }

    // 等待所有请求完成
    await Task.WhenAll(taskList);

    // 处理每个结果，确保URL和响应严格对应
    foreach (var completedTask in taskList)
    {
        var (targetUrl, response) = completedTask.Result;
        if (response != null && response.StatusCode == 200)
        {
            results.Add(new Result
            {
                Value = response.SomeValue,
                url = targetUrl.ToString() // 或者保留Uri类型，根据你的Result类定义调整
            });
        }
    }

    return results;
}

调用方式（等待结果填充完成） #

在需要使用结果的地方，用await等待方法完成：

// 调用示例
var fullyFilledResults = await FillResultsAsync();
// 这里可以放心执行后续操作，此时fullyFilledResults已经完全填充完毕

为什么这样改？ #

• 避免闭包陷阱：循环中创建currentUri局部变量，每个任务捕获的是当前迭代的URL，不会被后续循环覆盖；
• 明确等待所有请求：用Task.WhenAll确保所有异步请求都完成后再处理结果；
• 线程安全：因为所有结果处理都是在await之后的同一个线程（如果用的是同步上下文），不需要额外加锁；
• 代码更清晰：基于Task的异步模型比回调式代码更易读和维护。

如果你坚持要保留原来的回调模式（不推荐），可以用CountdownEvent和线程锁来实现，但代码会更繁琐：

public Task<List<Result>> FillResultsAsync()
{
    var results = new List<Result>();
    var countdown = new CountdownEvent(Urls.Count);
    var taskCompletionSource = new TaskCompletionSource<List<Result>>();

    foreach (var url in Urls)
    {
        // 捕获当前URL的局部变量
        var currentUrl = url;
        GetResponse(new Uri(currentUrl), (response) =>
        {
            try
            {
                if (response != null && response.StatusCode == 200)
                {
                    // 加锁确保多线程修改列表的安全性
                    lock (results)
                    {
                        results.Add(new Result
                        {
                            Value = response.SomeValue,
                            url = currentUrl
                        });
                    }
                }
            }
            finally
            {
                // 每个回调完成后计数减1，当计数为0时标记任务完成
                if (countdown.Signal())
                {
                    taskCompletionSource.SetResult(results);
                }
            }
        });
    }

    return taskCompletionSource.Task;
}

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