如何在循环中创建异步HTTP请求？

Question

Yesterday I've found out how to create several async http requests without async/await. But today I need to do it in a loop: if some of responses don't satisfy some condition - I need to change a request for them and send these requests again. It may be repeated several times. I've tried this code:

do
{
    var loadingCoordinatesTasks = new List<Task<Terminal>>();
    var totalCountOfTerminals = terminalPresetNode.ChildNodes.Count;
    var uiTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();

    foreach (var terminal in terminals.Except(_terminalsWithCoordinates))
    {
        var address = terminal.GetNextAddress();
        var webRequest = (HttpWebRequest)WebRequest.Create(GeoCoder.GeoCodeUrl + address);
        var webRequestTask = Task.Factory.FromAsync<WebResponse>(webRequest.BeginGetResponse,
                                                                 webRequest.EndGetResponse,
                                                                 terminal);
        var parsingTask = webRequestTask.ContinueWith(antecedent =>
        {
            // Parse the response
        });
        loadingCoordinatesTasks.Add(parsingTask);
    }

    Task.Factory.ContinueWhenAll(loadingCoordinatesTasks.ToArray(), antecedents =>
    {
        foreach (var antecedent in antecedents)
        {
            var terminalWithCoordinates = antecedent.Result;
            if (antecedent.Status == TaskStatus.RanToCompletion &&
                !terminalWithCoordinates.Coordinates.AreUnknown)
            {
                _terminalsWithCoordinates.Add(terminalWithCoordinates);
                _countOfProcessedTerminals++;
            }
        }
    });
} while (_countOfProcessedTerminals < totalCountOfTerminals);

but is it possible to check the condition in while just after every single set of requests executed?

Answer 1

You can perform the check after increasing the count:

_countOfProcessedTerminals++;
if (_countOfProcessedTerminals >= totalCountOfTerminals)
{
    break;
}

Is _countOfProcessedTerminals thread-safe though?

Answer 2

I manage to do it using recursion:

public void RunAgainFailedTasks(IEnumerable<Task<Terminal>> tasks)
    {
        Task.Factory.ContinueWhenAll(tasks.ToArray(), antecedents =>
        {
            var failedTasks = new List<Task<Terminal>>();
            foreach (var antecedent in antecedents)
            {
                var terminal = antecedent.Result;
                // Previous request was failed
                if (terminal.Coordinates.AreUnknown)
                {
                    string address;
                    try
                    {
                        address = terminal.GetNextAddress();
                    }
                    catch (FormatException) // No versions more
                    {
                        continue;
                    }
                    var getCoordinatesTask = CreateGetCoordinatesTask(terminal, address);
                    failedTasks.Add(getCoordinatesTask);
                }
                else
                {
                    _terminalsWithCoordinates.Add(terminal);
                }
            }
            if (failedTasks.Any())
            {
                RunAgainFailedTasks(failedTasks);
            }
            else
            {
                // Display a map
            }
    },  CancellationToken.None,
        TaskContinuationOptions.None,
        TaskScheduler.FromCurrentSynchronizationContext());
}

private Task<Terminal> CreateGetCoordinatesTask(Terminal terminal, string address)
    {
        var webRequest = (HttpWebRequest)WebRequest.Create(GeoCoder.GeoCodeUrl + address);
        webRequest.KeepAlive = false;
        webRequest.ProtocolVersion = HttpVersion.Version10; 
        var webRequestTask = Task.Factory.FromAsync<WebResponse>(webRequest.BeginGetResponse,
                                                                webRequest.EndGetResponse,
                                                                terminal);
        var parsingTask = webRequestTask.ContinueWith(webReqTask =>
        {
            // Parse the response
        });
        return parsingTask;
    }