有一种简单的方法可以使用非交换操作进行并行聚合吗？

Question

.NET Framework makes it easy to do parallel aggregation, but according to the documentation , it works for commutative operations only, that is an operation where f ( x , y ) = f ( y , x ):

The .NET implementation of the Parallel Aggregation pattern also expects the operations to be commutative.

I want to aggregate string values using a concatenation, that is a non-commutative operation. A sequential approach looks like this:

var result = string.Concat(sequence.Select(this.LongOperation));

so if this.LongOperation returns successively Hello , World and ! , the final result is HelloWorld! .

If I use parallel aggregation, the result could be HelloWorld , but also World!Hello , !HelloWorld , etc.

A workaround would be to do something similar to:

var result = sequence
    .AsParallel()
    .Select((v, i) => new { Index = i, Value = v })
    .Select(c => new { Index = c.Index, Value = this.LongOperation(c.Value))
    .OrderBy(c => c.Index)
    .Aggregate(seed: string.Empty, func: (prev, current) => prev + current);

with the (unimportant, in my particular case) drawback that the entire sequence will be evaluated at OrderBy step anyway, without waiting until the aggregation. Another way to write this is:

var parts = sequence
    .AsParallel()
    .Select((v, i) => new { Index = i, Value = v })
    .Select(c => new { Index = c.Index, Value = this.LongOperation(c.Value))
    .OrderBy(c => c.Index)
    .Select(c => c.Value);

var result = string.Concat(parts);

Am I expected to do that, or is there a simpler way to do the thing?

Answer 1

You're looking for ParallelEnumerable.AsOrdered :

var result = sequence
    .AsParallel()
    .AsOrdered()
    .Aggregate(seed: string.Empty, func: (prev, current) => prev + current);

The fact that you need to preserve ordering will have a performance hit on your query. As the results need to be aggregated in order, you won't be enjoying the maximum benefit of parallelism, and may sometimes lead to degraded performance over sequential iteration. Having said that, this will do what you're after.

For example, the following code will produce "[7][35][22][6][14]" consistently:

var result = new [] { 35, 14, 22, 6, 7 }
    .AsParallel()
    .AsOrdered()
    .Select(c => "[" + c + "]")
    .Aggregate(seed: string.Empty, func: (prev, current) => prev + current);

Console.WriteLine(result);

There is a good post about PLINQ Ordering by the Parallel Programming Team.