使用任务循环异步WCF调用

Question

I'm writing a WPF application that needs to make numerous calls to a WCF services based on items in a list.

foreach(var item in items)
{
    var dataAboutItem = MethodThatCallsWCFService(item);

    //  Do work to update UI
    .
    .
    .
}

Is there a smart way to do this using Tasks/Parallel.ForEach or some construct in the TPL that will let me make all the service calls on background threads and then update the UI accordingly as results come in for each call?

Answer 1

If you can use C# 5.0, then async - await can help you with this. The code generator for WCF services supports async - await , so it can generate async versions of your methods, which will be useful.

What you would do is to start all of the requests asynchronously, and store the Task s they return in a collection. Then, process the Task s as they complete. .Net doesn't support that out of the box, but you can use Stephen Toub's Interleaved() method :

var tasks = new List<Task<DataAboutItem>>();

foreach (var item in items)
{
    // don't await here yet
    Task<DataAboutItem> dataAboutItemTask = MethodThatCallsWCFServiceAsync(item);

    tasks.Add(dataAboutItemTask);
}

foreach (var bucket in Interleaved(tasks))
{
    var dataAboutItemTask = await bucket;
    DataAboutItem dataAboutItem = await dataAboutItemTask;

    //  Do work to update UI
}

If you wanted to throttle calling the WCF service (for example, only make 10 requests at a time), you could instead use TPL Dataflow, specifying MaxDegreeOfParallelism .

Answer 2

Task Parallel Library

Parallel.ForEach

Last sample has UI

Potential Pitfalls in Data and Task Parallelism

Or update a public property the UI is bound to rather than the UI directly.

If this is not going to load CPU you may want to use MaxDegreeOfParallelism to keep too many thread from spinning up.

ParallelOptions.MaxDegreeOfParallelism