Concurrent calls to external services

Question

I am currently working on a project to build an integration between an existing ASP.Net MVC website and a file hosting service my company is using. The typical use case is:

1. A user requests one or more files
2. The controller makes one call per file to the file host API
3. The file host returns the file data to the controller
4. The controller returns a file result

The hosting service can handle concurrent calls, and I've found that executing each API call within a task (see example below) leads to fairly drastic improvements.

private void RetrieveDocuments(DocumentIdentifier[] identifiers, List<FileHostResult> results)
{
    var tasks = identifiers.Select(x => RetrieveDocument(results, x)).ToArray();
    Task.WaitAll(tasks);
}

private Task RetrieveDocument(List<FileHostResult> results, DocumentIdentifier x)
{
    return Task.Run(() =>
    {
        var result = GetFileHostResultFromFileHost(x.ExternalIdentifier);
        lock (results)
        {
            results.Add(result);
        }
    });
}

My question is whether or not there is a better way of doing this, or if there are any potential pitfalls I might run into? (eg. locking server resources, etc).

EDIT 1: I didn't post the code for GetFileHostResultFromFileHost because I don't really have any access to change it. Its basically a method call implemented in a library I cant change.

EDIT 2: To clarify. My main concern is to avoid harming the current user experience on the site. To that end I want to make sure that running tasks concurrently out of an ASP.net mvc isn't going to lock up the site.

Answer 1

You should use Microsoft's Reactive Framework for this. It is ideally suited to this kind of processing.

Here's the code:

IObservable<FileHostResult> query =
    from i in identifiers.ToObservable()
    from r in Observable.Start(() => GetFileHostResultFromFileHost(i.ExternalIdentifier))
    select r;

IList<FileHostResult> results = query.ToList().Wait();

That's it. It properly schedules the code on the optimum number of threads.

If you want awaitable code then you can do this:

IObservable<FileHostResult> query =
    from i in identifiers.ToObservable()
    from r in Observable.Start(() => GetFileHostResultFromFileHost(i.ExternalIdentifier))
    select r;

IList<FileHostResult> results = await query.ToList();

It's really very simple and easy to code.

NuGet "System.Reactive" and then add using System.Reactive.Linq; to your code.

Answer 2

It is hard to give great advice without seeing the rest of the source code. But based on what I can see I'd suggest an approach like:

private void RetrieveDocuments(DocumentIdentifier[] identifiers, List<FileHostResult> results)
{
    results.AddRange(identifiers.AsParallel().Select(x => RetrieveDocument(x)));
}

private FileHostResult RetrieveDocument(DocumentIdentifier x)
{
    var result = GetFileHostResultFromFileHost(x.ExternalIdentifier);
    return result;
}

The advantages of this approach:

• No explicit use of Task.Run - let AsParallel take care of that for you.
• No need for locking the results list - let AsParallel and Select take care of that for you

You may also wish to increase the maximum number of connections you have access to.

Being honest though, I think you should look at approaches that don't require new Tasks at all - likely by using Async http download calls which you can run in parallel without the overhead of a thread.