使用async / await来提高性能

Question

I currently have a service method that runs a set of "rules" on incoming data. Some of these rules perform simple checks like validating a Id number, and some go out to databases to lookup information. It looks pretty much like this:

public void RunRules(ValidationRequest request)
{
    // Each rule returns bool for this example
    var rules = GetRules();

    var results = List<bool>();

    Parallel.ForEach(rules, rule =>
    {
        var result = rule();

        lock(results)
            results.Add(result);
    });

    foreach(var result in results)
    {
        RecordResultInDatabase(result);
    }

    CallNextService(someNewRequest);
}

I think (but am not sure) that I could improve things using async/await . My idea is, when one rule finishes it could then call RecordResultInDatabase while other rules are still running.

As a requirement though, I wouldn't want a call to CallNextService to happen until all rules have ran and their results recorded in the database.

Problem is I'm an absolute noob to async/await and I think (but am not sure) that the Task.WaitAll might be what I'm looking for.

I'm very uncertain of how do this, but something like this I'm guessing:

List<Task<bool>> ruleTasks = GetRules();
Task.WaitAll(ruleTasks);

// Somehow get the results of the rules and record them in the db???

Answer 1

I don't think async - await will improve performance in your case. In short, async - await is useful in two cases:

1. To improve responsiveness of GUI applications.
2. To improve scalability of server applications.

Neither of those seems to be your case, so there is no reason to use async - await in your code.

If you want to call RecordResultInDatabase() while requests are being processed, instead of when all of them are done, you can use PLINQ instead of Parallel.ForEach() . As another benefit, it will also simplify your code:

var results = GetRules().AsParallel().Select(rule => rule());

foreach (var result in results)
{
    RecordResultInDatabase(result);
}

Answer 2

You're not after await/async: those are designed to suspend execution of a method in a GUI application while preventing the GUI from freezing, and to improve scalability in server scenarios because it can sometimes avoid using a "thread" for the "await". Since you don't seem to be waiting for asynchronous operations and this is not a GUI then neither of this applies to you.

The client calling your service might employ await/async, but that's a different problem.

What you could look into is Task (the parallel task library). But only if your tests truly can run in parallel and are substantial enough to be worth it ! For tiny, fast & simple tests running them in parallel will likely hurt performance, not improve.

Finally, since this runs on a server, you need to take into account concurrent activities: is the server only servicing this request? Unless that's true you shouldn't use threads at all, keep things single-threaded and clean. Since all CPU-threads would be tied up in servicing other concurrent requests, running multiple Tasks or a ParallelLoop will only hurt performance, and not just for this request but for every other request that runs at the same time. That's because there would be no "free" cores to take your threads yet you do request them. There's no extra CPU capacity to tap into. You just end up doing context-switching (and paying the penalty for that) without getting any benefit.

As always: test, test, test.

Task class on MSDN: http://msdn.microsoft.com/en-us/library/system.threading.tasks.task.aspx