Parallel or async ASP.NET Core C#

Question

I've googled this plenty but I'm afraid I don't fully understand the consequences of concurrency and parallelism.

I have about 3000 rows of database objects that each have an average of 2-4 logical data attached to them that need to be validated as a part of a search query, meaning the validation service needs to execute approx. 3*3000 times. E.g. the user has filtered on color then each row needs to validate the color and return the result. The loop cannot break when a match has been found, meaning all logical objects will always need to be evaluated (this is due to calculations of relevance and just not a match).

This is done on-demand when the user selects various properties, meaning performance is key here.

I'm currently doing this by using Parallel.ForEach but wonder if it is smarter to use async behavior instead?

Current way

var validatorService = new LogicalGroupValidatorService();
ConcurrentBag<StandardSearchResult> results = new ConcurrentBag<StandardSearchResult>();
Parallel.ForEach(searchGroups, (group) =>
{
    var searchGroupResult = validatorService.ValidateLogicGroupRecursivly(
        propertySearchQuery, group.StandardPropertyLogicalGroup);
    result.Add(new StandardSearchResult(searchGroupResult));
});

Async example code

var validatorService = new LogicalGroupValidatorService();
List<StandardSearchResult> results = new List<StandardSearchResult>();
var tasks = new List<Task<StandardPropertyLogicalGroupSearchResult>>();

foreach (var group in searchGroups)
{
    tasks.Add(validatorService.ValidateLogicGroupRecursivlyAsync(
        propertySearchQuery, group.StandardPropertyLogicalGroup));
}

await Task.WhenAll(tasks);

results = tasks.Select(logicalGroupResultTask => 
    new StandardSearchResult(logicalGroupResultTask.Result)).ToList();

Answer 1

The difference between parallel and async is this:

• Parallel: Spin up multiple threads and divide the work over each thread
• Async: Do the work in a non-blocking manner.

Whether this makes a difference depends on what it is that is blocking in the async-way. If you're doing work on the CPU, it's the CPU that is blocking you and therefore you will still end up with multiple threads. In case it's IO (or anything else besides the CPU, you will reuse the same thread)

For your particular example that means the following:

Parallel.ForEach => Spin up new threads for each item in the list (the nr of threads that are spun up is managed by the CLR) and execute each item on a different thread

async/await => Do this bit of work, but let me continue execution. Since you have many items, that means saying this multiple times. It depends now what the results:

• If this bit of workis on the CPU, the effect is the same
• Otherwise, you'll just use a single thread while the work is being done somewhere else