What is PLINQ, when does AsParallel help, and when does it make things worse?

1. Cost model

speed-up ≤ 1 / ((1 - p) + p / n)            Amdahl: p = parallel fraction, n = cores
real speed-up = Amdahl − partitioning cost − merge cost − contention − GC

For tiny per-item work, partitioning and merging dominate and PLINQ is slower than sequential LINQ. Rule of thumb: if the whole sequential query takes only a few milliseconds, stay sequential. Benchmark with BenchmarkDotNet on production-like hardware.

2. Partitioning strategies

3. Ordering

AsOrdered() makes each partition keep indices and the merge reorders. Operators like Take(10) with AsOrdered() return the first ten in source order; without it, any ten. Use AsUnordered() after the order-sensitive part to regain throughput.

4. Thread-safe aggregation

// WRONG: shared List<T> mutated from many threads
var results = new List<int>();
numbers.AsParallel().ForAll(n => { if (IsPrime(n)) results.Add(n); });   // lost items / exceptions

// RIGHT: let the query produce results
int[] primes = numbers.AsParallel().Where(IsPrime).ToArray();

// RIGHT: per-partition aggregation
long sum = numbers.AsParallel().Aggregate(
    seed: 0L,
    updateAccumulatorFunc: (acc, n) => acc + n,
    combineAccumulatorsFunc: (a, b) => a + b,
    resultSelector: total => total);

5. Why not in ASP.NET Core requests

Under load, every core already runs request work. PLINQ in one request:

• takes extra pool threads, competing with other requests;
• increases context switching and cache misses;
• can trigger thread injection.

Result: one request gets faster in isolation, and everyone's p99 gets worse under load. Move heavy CPU work to background jobs or precompute.

6. Version notes

7. Try it yourself

1. Run the code example and compare timings; then reduce to 1..1,000 and see PLINQ lose.
2. Use ForAll with a shared List<int> and observe exceptions or missing items; fix with ToArray().
3. Compare AsOrdered().Take(10) with unordered Take(10).
4. Add Thread.Sleep(1) (simulated I/O) inside the lambda and watch thread count climb with dotnet-counters.
5. Benchmark range vs load-balanced partitioning (Partitioner.Create(array, true)) for uneven work.
6. Load-test an endpoint with and without PLINQ and compare p99.

using System.Diagnostics;

int[] numbers = Enumerable.Range(1, 3_000_000).ToArray();

var sw = Stopwatch.StartNew();
int sequential = numbers.Count(IsPrime);
Console.WriteLine($"Sequential: {sequential} primes in {sw.ElapsedMilliseconds} ms");

using var cts = new CancellationTokenSource();
sw.Restart();
int parallel = numbers
    .AsParallel()
    .WithDegreeOfParallelism(Math.Max(1, Environment.ProcessorCount - 1))
    .WithCancellation(cts.Token)
    .Count(IsPrime);
Console.WriteLine($"PLINQ: {parallel} primes in {sw.ElapsedMilliseconds} ms");

// Ordered output when order matters.
var firstTen = numbers.AsParallel().AsOrdered().Where(IsPrime).Take(10).ToArray();
Console.WriteLine(string.Join(", ", firstTen));

// Exceptions arrive as AggregateException.
try
{
    _ = numbers.AsParallel().Select(n => n == 1_234_567 ? throw new InvalidDataException("bad") : n).ToArray();
}
catch (AggregateException ex)
{
    Console.WriteLine($"Failed: {ex.InnerExceptions[0].Message}");
}

static bool IsPrime(int n)
{
    if (n < 2) return false;
    for (int d = 2; d * d <= n; d++)
        if (n % d == 0) return false;
    return true;
}