Concurrency Patterns in .NET 10 — Efficient Parallel Processing

Posted on: 4/20/2026 7:10:47 PM

In the modern backend world, handling thousands of concurrent requests is a baseline requirement. .NET 10 ships with a powerful concurrency toolkit — from the familiar async/await to System.Threading.Channels and Parallel.ForEachAsync. However, misusing these tools can turn your application from "concurrent" to "deadlocked." This article dives deep into 7 production-tested concurrency patterns, with production-ready code and analysis of when (and when not) to use each.

Overview: Concurrency Model in .NET 10

.NET 10 uses a concurrency model based on the ThreadPool and Task. Unlike the traditional thread-per-request model, .NET fully exploits the thread pool by "releasing" threads when waiting for I/O and "borrowing" another thread when the result arrives. This allows an ASP.NET Core app to serve tens of thousands of concurrent requests with just a few dozen threads.

graph TB
    subgraph ThreadPool["🏊 .NET ThreadPool"]
        T1["Thread 1"]
        T2["Thread 2"]
        T3["Thread N"]
    end

    subgraph Tasks["📋 Task Queue"]
        TA["Task A
HTTP Request"]
        TB["Task B
DB Query"]
        TC["Task C
File I/O"]
        TD["Task D
API Call"]
    end

    TA --> T1
    TB --> T2
    TC --> T1
    TD --> T3

    style ThreadPool fill:#f8f9fa,stroke:#e94560,color:#2c3e50
    style Tasks fill:#f8f9fa,stroke:#2c3e50,color:#2c3e50
    style T1 fill:#e94560,stroke:#fff,color:#fff
    style T2 fill:#e94560,stroke:#fff,color:#fff
    style T3 fill:#e94560,stroke:#fff,color:#fff
    style TA fill:#fff,stroke:#2c3e50,color:#2c3e50
    style TB fill:#fff,stroke:#2c3e50,color:#2c3e50
    style TC fill:#fff,stroke:#2c3e50,color:#2c3e50
    style TD fill:#fff,stroke:#2c3e50,color:#2c3e50

Pattern 1: async/await — The Foundation of Everything

async/await doesn't create a new thread — it releases the current thread while waiting for I/O. It's the most fundamental pattern, and also the easiest to misuse.

// ✅ CORRECT: Run 3 HTTP calls concurrently
public async Task<DashboardData> GetDashboardAsync(int userId)
{
    var userTask = _userService.GetByIdAsync(userId);
    var ordersTask = _orderService.GetRecentAsync(userId);
    var statsTask = _analyticsService.GetStatsAsync(userId);

    await Task.WhenAll(userTask, ordersTask, statsTask);

    return new DashboardData
    {
        User = userTask.Result,
        Orders = ordersTask.Result,
        Stats = statsTask.Result
    };
}

// ❌ WRONG: Sequential — 3x slower
public async Task<DashboardData> GetDashboardSlowAsync(int userId)
{
    var user = await _userService.GetByIdAsync(userId);
    var orders = await _orderService.GetRecentAsync(userId);
    var stats = await _analyticsService.GetStatsAsync(userId);
    // Each await waits to finish before continuing → total = T1 + T2 + T3
    return new DashboardData { User = user, Orders = orders, Stats = stats };
}

// ❌ DANGEROUS — Deadlock in ASP.NET
public ActionResult GetData()
{
    var data = _service.GetDataAsync().Result; // Blocks a thread pool thread!
    return Ok(data);
}

// ✅ SAFE — Always go async end-to-end
public async Task<ActionResult> GetData()
{
    var data = await _service.GetDataAsync();
    return Ok(data);
}

Pattern 2: SemaphoreSlim — Controlling Concurrency Levels

When you need to limit how many tasks run in parallel (e.g., calling a third-party API with rate limits), SemaphoreSlim is the lightest and most efficient choice.

public class RateLimitedHttpClient
{
    private readonly HttpClient _http;
    private readonly SemaphoreSlim _semaphore;

    public RateLimitedHttpClient(HttpClient http, int maxConcurrency = 10)
    {
        _http = http;
        _semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
    }

    public async Task<List<ApiResult>> FetchAllAsync(IEnumerable<string> urls)
    {
        var tasks = urls.Select(async url =>
        {
            await _semaphore.WaitAsync();
            try
            {
                return await _http.GetFromJsonAsync<ApiResult>(url);
            }
            finally
            {
                _semaphore.Release();
            }
        });

        var results = await Task.WhenAll(tasks);
        return results.ToList();
    }
}

Pattern 3: System.Threading.Channels — Producer-Consumer Pipeline

Channel<T> is a thread-safe, lock-free data structure purpose-built for producer-consumer patterns in .NET. Compared to the older BlockingCollection<T>, Channels are 10x faster by avoiding kernel-mode synchronization and by supporting async natively.

graph LR
    P1["Producer 1
HTTP Receiver"] --> CH["Channel<T>
Bounded Buffer"]
    P2["Producer 2
File Watcher"] --> CH
    CH --> C1["Consumer 1
Processor"]
    CH --> C2["Consumer 2
Processor"]
    C1 --> DB["Database"]
    C2 --> DB

    style P1 fill:#4CAF50,stroke:#fff,color:#fff
    style P2 fill:#4CAF50,stroke:#fff,color:#fff
    style CH fill:#e94560,stroke:#fff,color:#fff
    style C1 fill:#2c3e50,stroke:#fff,color:#fff
    style C2 fill:#2c3e50,stroke:#fff,color:#fff
    style DB fill:#f8f9fa,stroke:#2c3e50,color:#2c3e50

public class OrderProcessingPipeline : BackgroundService
{
    private readonly Channel<Order> _channel;

    public OrderProcessingPipeline()
    {
        // Bounded channel: up to 1000 items,
        // producer will await when buffer is full (backpressure)
        _channel = Channel.CreateBounded<Order>(new BoundedChannelOptions(1000)
        {
            FullMode = BoundedChannelFullMode.Wait,
            SingleReader = false,
            SingleWriter = false
        });
    }

    public ChannelWriter<Order> Writer => _channel.Writer;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        // Run 4 consumers in parallel
        var consumers = Enumerable.Range(0, 4)
            .Select(_ => ConsumeAsync(ct));

        await Task.WhenAll(consumers);
    }

    private async Task ConsumeAsync(CancellationToken ct)
    {
        await foreach (var order in _channel.Reader.ReadAllAsync(ct))
        {
            await ProcessOrderAsync(order);
        }
    }

    private async Task ProcessOrderAsync(Order order)
    {
        // Validate → Calculate → Save → Notify
        await _validator.ValidateAsync(order);
        order.Total = await _calculator.CalculateAsync(order);
        await _repository.SaveAsync(order);
        await _notifier.NotifyAsync(order);
    }
}

Pattern 4: Parallel.ForEachAsync — Controlled Data Parallelism

When you need to process a large collection in parallel with a concurrency limit, Parallel.ForEachAsync (introduced in .NET 6) is a better choice than manually managing SemaphoreSlim + Task.WhenAll.

public async Task ResizeImagesAsync(List<string> imagePaths)
{
    var options = new ParallelOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount,
        CancellationToken = _cts.Token
    };

    await Parallel.ForEachAsync(imagePaths, options, async (path, ct) =>
    {
        using var image = await Image.LoadAsync(path, ct);
        image.Mutate(x => x.Resize(800, 600));

        var outputPath = Path.Combine(_outputDir, Path.GetFileName(path));
        await image.SaveAsync(outputPath, ct);
    });
}

// Comparison: the old approach is more complex
public async Task ResizeImagesOldWayAsync(List<string> imagePaths)
{
    var semaphore = new SemaphoreSlim(Environment.ProcessorCount);
    var tasks = imagePaths.Select(async path =>
    {
        await semaphore.WaitAsync();
        try { /* ... resize logic ... */ }
        finally { semaphore.Release(); }
    });
    await Task.WhenAll(tasks);
}

Pattern 5: Pipeline Pattern — Multi-Stage Processing

The pipeline pattern splits processing into multiple stages, each running concurrently and passing data through Channels. It's the ideal pattern for ETL, image processing, and data ingestion.

graph LR
    S1["Stage 1
Download"] --> |Channel| S2["Stage 2
Parse"]
    S2 --> |Channel| S3["Stage 3
Transform"]
    S3 --> |Channel| S4["Stage 4
Load to DB"]

    style S1 fill:#e94560,stroke:#fff,color:#fff
    style S2 fill:#2c3e50,stroke:#fff,color:#fff
    style S3 fill:#4CAF50,stroke:#fff,color:#fff
    style S4 fill:#16213e,stroke:#fff,color:#fff

public class DataIngestionPipeline
{
    public async Task RunAsync(IEnumerable<string> sourceUrls, CancellationToken ct)
    {
        var downloadChannel = Channel.CreateBounded<RawData>(100);
        var parseChannel = Channel.CreateBounded<ParsedData>(100);
        var transformChannel = Channel.CreateBounded<TransformedData>(100);

        var pipeline = Task.WhenAll(
            DownloadStageAsync(sourceUrls, downloadChannel.Writer, ct),
            ParseStageAsync(downloadChannel.Reader, parseChannel.Writer, ct),
            TransformStageAsync(parseChannel.Reader, transformChannel.Writer, ct),
            LoadStageAsync(transformChannel.Reader, ct)
        );

        await pipeline;
    }

    private async Task DownloadStageAsync(
        IEnumerable<string> urls,
        ChannelWriter<RawData> writer,
        CancellationToken ct)
    {
        try
        {
            await Parallel.ForEachAsync(urls,
                new ParallelOptions { MaxDegreeOfParallelism = 5, CancellationToken = ct },
                async (url, token) =>
                {
                    var data = await _http.GetByteArrayAsync(url, token);
                    await writer.WriteAsync(new RawData(url, data), token);
                });
        }
        finally
        {
            writer.Complete();
        }
    }

    private async Task ParseStageAsync(
        ChannelReader<RawData> reader,
        ChannelWriter<ParsedData> writer,
        CancellationToken ct)
    {
        try
        {
            await foreach (var raw in reader.ReadAllAsync(ct))
            {
                var parsed = JsonSerializer.Deserialize<ParsedData>(raw.Bytes);
                await writer.WriteAsync(parsed, ct);
            }
        }
        finally
        {
            writer.Complete();
        }
    }

    // TransformStage and LoadStage are similar...
}

Pattern 6: Periodic Background Processing

Instead of using the old Timer (which is prone to reentrancy — a callback fires again before the previous one completes), .NET 10 provides PeriodicTimer — async-friendly and guaranteed not to overlap.

public class MetricsCollector : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(30));

        while (await timer.WaitForNextTickAsync(ct))
        {
            try
            {
                var metrics = await CollectMetricsAsync(ct);
                await _metricsStore.PushAsync(metrics, ct);
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                _logger.LogError(ex, "Metrics collection failed");
                // Don't throw — timer keeps ticking
            }
        }
    }
}

// ❌ WRONG: System.Timers.Timer can overlap
var timer = new System.Timers.Timer(30000);
timer.Elapsed += async (s, e) =>
{
    // If CollectMetrics takes > 30s,
    // the second callback fires in parallel → race condition
    await CollectMetricsAsync();
};

Pattern 7: Cancellation Token Propagation

CancellationToken isn't just a parameter to "include for completeness" — it's the lifeline of graceful shutdown in production. When Kubernetes sends SIGTERM, your app needs to clean up within the grace period.

public class OrderService
{
    public async Task<OrderResult> ProcessWithTimeoutAsync(
        Order order,
        CancellationToken requestCt)
    {
        // Combined: cancel when the request is cancelled OR after a 30s timeout
        using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
        using var linkedCts = CancellationTokenSource
            .CreateLinkedTokenSource(requestCt, timeoutCts.Token);

        try
        {
            var result = await _processor.ProcessAsync(order, linkedCts.Token);
            return result;
        }
        catch (OperationCanceledException) when (timeoutCts.IsCancellationRequested)
        {
            _logger.LogWarning("Order {Id} processing timed out", order.Id);
            throw new TimeoutException($"Order {order.Id} exceeded 30s limit");
        }
        catch (OperationCanceledException) when (requestCt.IsCancellationRequested)
        {
            _logger.LogInformation("Order {Id} cancelled by client", order.Id);
            throw; // Re-throw — client disconnected
        }
    }
}

graph TD
    A["Request CancellationToken"] --> L["LinkedTokenSource"]
    B["Timeout CancellationToken
30 seconds"] --> L
    L --> C["ProcessAsync()"]
    C --> D{"Token cancelled?"}
    D -->|Timeout| E["TimeoutException"]
    D -->|Client disconnect| F["OperationCanceledException"]
    D -->|No| G["✅ Success"]

    style A fill:#4CAF50,stroke:#fff,color:#fff
    style B fill:#ff9800,stroke:#fff,color:#fff
    style L fill:#e94560,stroke:#fff,color:#fff
    style G fill:#4CAF50,stroke:#fff,color:#fff
    style E fill:#ff9800,stroke:#fff,color:#fff
    style F fill:#f8f9fa,stroke:#2c3e50,color:#2c3e50
    style C fill:#2c3e50,stroke:#fff,color:#fff
    style D fill:#f8f9fa,stroke:#e94560,color:#2c3e50

Summary: Which Pattern Should I Use?

Benchmark: Channel vs BlockingCollection vs ConcurrentQueue

The benchmark below runs on .NET 10, 1 million items, 4 producers + 4 consumers:

Real-world: Building an Image Processing Service

Combining all the patterns into a real image processing service:

public class ImageProcessingService : BackgroundService
{
    private readonly Channel<ImageJob> _jobs;
    private readonly ILogger<ImageProcessingService> _logger;

    public ImageProcessingService(ILogger<ImageProcessingService> logger)
    {
        _logger = logger;
        _jobs = Channel.CreateBounded<ImageJob>(new BoundedChannelOptions(500)
        {
            FullMode = BoundedChannelFullMode.Wait
        });
    }

    // An API controller calls this method
    public async ValueTask EnqueueAsync(ImageJob job, CancellationToken ct)
        => await _jobs.Writer.WriteAsync(job, ct);

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        _logger.LogInformation("Image processing started with {Count} workers",
            Environment.ProcessorCount);

        var workers = Enumerable.Range(0, Environment.ProcessorCount)
            .Select(id => ProcessWorkerAsync(id, ct));

        await Task.WhenAll(workers);
    }

    private async Task ProcessWorkerAsync(int workerId, CancellationToken ct)
    {
        await foreach (var job in _jobs.Reader.ReadAllAsync(ct))
        {
            using var timeoutCts = new CancellationTokenSource(TimeSpan.FromMinutes(2));
            using var linked = CancellationTokenSource
                .CreateLinkedTokenSource(ct, timeoutCts.Token);

            try
            {
                await ProcessJobAsync(job, linked.Token);
                _logger.LogDebug("Worker {Id}: processed {File}", workerId, job.FileName);
            }
            catch (OperationCanceledException) when (timeoutCts.IsCancellationRequested)
            {
                _logger.LogWarning("Worker {Id}: {File} timed out", workerId, job.FileName);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Worker {Id}: failed {File}", workerId, job.FileName);
            }
        }
    }

    private static async Task ProcessJobAsync(ImageJob job, CancellationToken ct)
    {
        using var image = await Image.LoadAsync(job.SourcePath, ct);

        foreach (var size in job.TargetSizes)
        {
            ct.ThrowIfCancellationRequested();
            var clone = image.Clone(x => x.Resize(size.Width, size.Height));
            var path = Path.Combine(job.OutputDir, $"{size.Name}_{job.FileName}");
            await clone.SaveAsync(path, ct);
        }
    }
}

Common Pitfalls

// ❌ Exception gets swallowed, no one knows the task failed
_ = ProcessAsync(data);

// ✅ Use a Channel or IHostedService to track work
await _channel.Writer.WriteAsync(data);

// ❌ Exceptions crash the whole process
async void OnButtonClicked() { await DoWorkAsync(); }

// ✅ Always return a Task
async Task OnButtonClickedAsync() { await DoWorkAsync(); }

// ❌ Parallel.ForEach does NOT properly support async delegates
Parallel.ForEach(urls, async url =>
{
    await _http.GetAsync(url); // implicit async void!
});

// ✅ Use Parallel.ForEachAsync
await Parallel.ForEachAsync(urls, async (url, ct) =>
{
    await _http.GetAsync(url, ct);
});

Conclusion

Concurrency in .NET 10 isn't about "adding async to every method" — it's about picking the right pattern for the problem at hand. Channel<T> for producer-consumer, SemaphoreSlim for throttling, Parallel.ForEachAsync for data parallelism, and CancellationToken everywhere. Master these 7 patterns and you have the toolbox to build systems that process millions of requests per second without a single thread sitting idle or wasted.

References

• Task-based Asynchronous Programming — Microsoft Learn
• 12 Production-Ready Async & Parallel Patterns — Mahesh Kumar Yadav
• Advanced C# Concurrency: Channels, Pipelines, and Parallel Processing — DEV Community
• Task Parallel Library (TPL) — Microsoft Learn
• Handling High-Concurrency Scenarios in C# — Or Ben Shmueli