Is there any reason to choose Parallel.ForEach instead of await ForEachAsync in any situation (or vice-versa)? or they are virtually the same?
await collection.ForEachAsync( m => { m.DoSomething(); } );
VS
Parallel.ForEach( collection, m => { m.DoSomething(); } );
They are not 'virtually the same' at all.
When you use functions from the Parallel class such as Parallel.ForEach() you are invoking some action, in which that action is broken up into multiple smaller actions, each carried out on different threads (aka multi-threaded).
ForEachAsync on the other hand is not necessarily multi-threaded. It is asynchronous and asynchronous operations are not multi-threaded ones (well they can be, but don't have to be, that depends on the implementation).
I strongly suggest reading the following post which goes into far more detail on the topic.
As for you question of
Is there any reason to choose Parallel.ForEach instead of await ForEachAsync in any situation
The answer is most definitely that there are reasons to do so, but in order to determine what kind of scenarios you would use one or the other, you have to understand them both.
Here's a simple example:
You have a collection of objects and you want to iterate over them and perform some kind of action. Do you care about the order in which those actions occur? If so do not use Parallel.ForEach() as there is no guarantee of the order in which they are invoked (due to its multi-threaded nature).
EDIT:
In your example, it all depends on how many items are in collection and how process-heavy DoSomething() is.
The reason for that is because Parallel.ForEach() is not free. There are trade-offs to be made. Setting up a multi-threaded environment takes time and if collection is small and/or DoSomething() doesn't take too long, then the time spent setting up those threads would be better (and usually faster) spent with a single-threaded async operation.
On the other hand, if collection is large and/or DoSomething() is a process-heavy task then Parallel.ForEach() will most definitely be the most performant option.
it is all depend on the threads let's say you have the following class
public class person
{
public int ID { get; set; }
public string Name { get; set; }
}
and here is your main Class
List<person> persons = new List<person>()
{
new person{ ID = 1,Name="Ali"}
,new person{ ID = 2,Name="Gorge"}
,new person{ ID = 3,Name="Alex"}
,new person{ ID = 4,Name="Liz"}
,new person{ ID = 5,Name="Scott"}
,new person{ ID = 6,Name="Abby"}
,new person{ ID = 7,Name="Sarah"}
};
Parallel.ForEach(persons, (p) =>
{
Console.WriteLine($"Id : {p.ID} ,Name : {p.Name}");
});
When you run this code the list items will be splits over diff threads and the code won't be running in order as you see in the following output I get the print in diff order than my original List
and here I am running the same code one more time, but I get diff results
The reason for that because of the threads, the compiler divide to number of threads and every list run the items assigned to it the following pic show the diff threads
but when you run the following code
List<person> persons = new List<person>()
{
new person{ ID = 1,Name="Ali"}
,new person{ ID = 2,Name="Gorge"}
,new person{ ID = 3,Name="Alex"}
,new person{ ID = 4,Name="Liz"}
,new person{ ID = 5,Name="Scott"}
,new person{ ID = 6,Name="Abby"}
,new person{ ID = 7,Name="Sarah"}
};
await persons.ForEachAsync(async p => Console.WriteLine($"Id : {p.ID} ,Name : {p.Name}"));
you only get one thread as showing here
plus the data print will always be running in the same order of your list
I hope this answer explains the difference !
Is there any reason to choose Parallel.ForEach instead of await ForEachAsync in any situation (or vice-versa)?
Parallel.ForEach is for synchronous code. Its delegate must be synchronous, and it is invoked synchronously.
ForEachAsync is not a standard algorithm. There are several different implementations, but generally they attempt to do a mixture of asynchrony and parallelism. They have to give up some of the self-balancing aspects of Parallel.ForEach. The vast majority of code does not need ForEachAsync; most code is either asynchronous or parallel.
