Parallel Class and PLINQ — CPU-Bound Parallelism

Async/await is for I/O-bound operations — database queries, HTTP calls, file reads — where the bottleneck is waiting for an external resource. For CPU-bound work — image processing, encryption, data transformation, complex calculations — the bottleneck is the CPU itself, and async/await alone does not help (the CPU is busy, not waiting). The Task Parallel Library (TPL) provides Parallel.For, Parallel.ForEach, and PLINQ for distributing CPU work across multiple processor cores simultaneously. Understanding which tool to use for which workload is fundamental for correct performance optimisation.

Parallel.For and Parallel.ForEach #

// ── Parallel.For — index-based CPU-bound loop ─────────────────────────────
var results = new int[1000];

Parallel.For(0, 1000, i =>
{
    results[i] = ExpensiveComputation(i);   // runs on multiple threads concurrently
});

// ── Parallel.ForEach — collection-based CPU-bound loop ────────────────────
var posts = GetAllPosts();
var processedPosts = new ConcurrentBag<Post>();   // thread-safe collection

Parallel.ForEach(posts, post =>
{
    var processed = ProcessContent(post);   // CPU-intensive work
    processedPosts.Add(processed);
});

// ── With options — control degree of parallelism ──────────────────────────
var options = new ParallelOptions
{
    MaxDegreeOfParallelism = Environment.ProcessorCount,  // use all cores
    CancellationToken      = cancellationToken,
};
Parallel.ForEach(posts, options, post => ProcessContent(post));

// ── .NET 6+ Parallel.ForEachAsync — async work with parallelism control ───
await Parallel.ForEachAsync(posts,
    new ParallelOptions { MaxDegreeOfParallelism = 10 },
    async (post, ct) =>
    {
        await _imageService.ResizeAsync(post.CoverImagePath, ct);
    });

PLINQ — Parallel LINQ #

// Regular LINQ — sequential, single-threaded
var result = posts
    .Where(p => p.IsPublished)
    .Select(p => ExpensiveTransform(p))
    .ToList();

// PLINQ — parallel, uses multiple CPU cores
var parallelResult = posts
    .AsParallel()                            // switch to parallel execution
    .WithDegreeOfParallelism(4)             // use up to 4 cores
    .WithCancellation(cancellationToken)    // support cancellation
    .Where(p => p.IsPublished)
    .Select(p => ExpensiveTransform(p))
    .ToList();

// AsOrdered — preserves original sequence order (reduces parallelism benefit)
var ordered = posts
    .AsParallel()
    .AsOrdered()   // results maintain original order (with overhead)
    .Select(p => ExpensiveTransform(p))
    .ToList();

I/O-Bound vs CPU-Bound — Choosing the Right Tool #

Common Mistakes #

Mistake 1 — Using Parallel.ForEach with async delegates (fire-and-forget) #

❌ Wrong — async void lambda in Parallel.ForEach; exceptions are swallowed:

Parallel.ForEach(posts, async post => await _service.ProcessAsync(post));
// The async delegate returns void from Parallel's perspective — not awaited!

✅ Correct — use Parallel.ForEachAsync (.NET 6+) for async work.

Mistake 2 — Using Task.Run for I/O-bound work in ASP.NET Core #

❌ Wrong — queues to thread pool, gains nothing for I/O operations.

✅ Correct — use genuinely async I/O methods (await File.ReadAllTextAsync(), await httpClient.GetAsync()).