Order of a Parallell Loop not being respected

Question

I am copying large amounts of files from one server to several other servers.

I have a list of copy operations which have an Order so The files to Server a are first in the list and the files to server b come at the end of the list.

I am using a AsParallel.AsOrdered() on the list to make sure that files are copied to the first server first then only when threads are free to the second server.

It Doesn't seem to be working as it will copy files to both servers at the same time, am I missing something, is there a better way of writing this code. I checked with large files to really see the order and it seems to not relect the list order

var dotheCopy = copy.ToArray().OrderBy(a => a.GroupId);

var copyList = new List<CopyOps>();

foreach (var x in dotheCopy)
{
    ... some validation code 
    copyList.Add(x);
}

copyList.AsParallel().AsOrdered().WithDegreeOfParallelism(5)
    .ForAll(x => this.DoTheCopy(x));

Answer 1

AsOrdered doesn't guarantee execution order. It guarantees that the results will be ordered.

Enumerable.Range(0, 3).AsParallel().Select(x => x); // 3,1,2,

Enumerable.Range(0, 3).AsParallel().AsOrdered().Select(x => x); // 1,2,3

Since ForAll doesn't return anything, then combining it with AsOrdered is useless.

It seems like your actual goal it to process your items in order, but in batches of 5, correct? In other words, you need throttling. If so, you can use ActionBlock<T> from TPL Dataflow

var block = new ActionBlock<CopyOps>(DoTheCopy, 
        new ExecutionDataflowBlockOptions
         {
            MaxDegreeOfParallelism = 5
         });

var tasks = copyList.Select(item => block.SendAsync(item));

await Task.WhenAll(tasks);

Or, a simpler approach, if blocking the main thread is not an issue

Parallel.ForEach(copyList,
                 new ParallelOptions { MaxDegreeOfParallelism = 5 },
                 DoTheCopy);

Answer 2

Here is some documentation from MSDN -

Order Preservation in PLINQ

"ForAll<TSource> - Result when the source sequence is ordered - Executes nondeterministically in parallel"

So seems like ForAll doesn't honor the order.