C# Async Patterns: Engineering Concurrency Without Compromise

vices | | Disposal | IAsyncDisposable if holding unmanaged resources | IHostedService lifecycle management |

Code Example: Production-Grade Async Pipeline

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;

public sealed class AsyncPipeline<TInput, TOutput> : IAsyncDisposable
{
    private readonly Channel<TInput> _channel;
    private readonly Func<TInput, CancellationToken, Task<TOutput>> _processor;
    private readonly ILogger _logger;
    private readonly CancellationTokenSource _cts;
    private readonly Task[] _workers;

    public AsyncPipeline(
        int boundedCapacity,
        int workerCount,
        Func<TInput, CancellationToken, Task<TOutput>> processor,
        ILogger logger)
    {
        _channel = Channel.CreateBounded<TInput>(new BoundedChannelOptions(boundedCapacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        });
        _processor = processor;
        _logger = logger;
        _cts = new CancellationTokenSource();
        _workers = new Task[workerCount];

        for (int i = 0; i < workerCount; i++)
        {
            _workers[i] = ConsumeAsync(_cts.Token);
        }
    }

    public async ValueTask EnqueueAsync(TInput item, CancellationToken ct = default)
    {
        await _channel.Writer.WriteAsync(item, ct);
    }

    public async Task CompleteAsync()
    {
        _channel.Writer.Complete();
        await Task.WhenAll(_workers);
    }

    private async Task ConsumeAsync(CancellationToken ct)
    {
        await foreach (var item in _channel.Reader.ReadAllAsync(ct))
        {
            try
            {
                await _processor(item, ct);
            }
            catch (OperationCanceledException)
            {
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Processing failed for item {Item}", item);
            }
        }
    }

    public async ValueTask DisposeAsync()
    {
        _cts.Cancel();
        await Task.WhenAll(_workers);
        _cts.Dispose();
    }
}

Why this works:

• Bounded channel enforces backpressure via Wait mode.
• CancellationToken flows through read/write and processor.
• Exceptions are logged, not swallowed. Pipeline continues.
• IAsyncDisposable ensures graceful shutdown.
• No Task.Run, no async void, no context capture.

Pitfall Guide

1. Blocking on Async (.Result / .Wait())

   • Why it happens: Synchronous wrappers around async APIs.
   • Impact: Thread pool starvation, deadlocks under synchronization context.
   • Fix: Propagate async to the root. Use await exclusively.

2. async void Outside Event Handlers

   • Why it happens: Convenience for fire-and-forget or middleware.
   • Impact: Exceptions bypass task observation, crash the process.
   • Fix: Return Task. Use BackgroundService or Channel for detached work.

3. Missing ConfigureAwait(false) in Libraries

   • Why it happens: Assumption that context doesn't matter.
   • Impact: Deadlocks in UI/ASP.NET Framework contexts; unnecessary continuation overhead.
   • Fix: Always use ConfigureAwait(false) in library code.

4. Swallowing Exceptions with Fire-and-Forget

   • Why it happens: _ = DoWorkAsync() without observation.
   • Impact: Silent failures, data corruption, untraceable bugs.
   • Fix: Wrap in try/catch, log, or use Task.Run with explicit error handling.

5. Ignoring CancellationToken Propagation

   • Why it happens: Forgetting to pass tokens through layers.
   • Impact: Graceful shutdown fails, resources leak, requests hang.
   • Fix: Token as last parameter in every async method. Check IsCancellationRequested in loops.

6. Overusing Task.Run for I/O-Bound Work

   • Why it happens: Misunderstanding async vs. parallelism.
   • Impact: Thread pool injection, increased latency, higher memory usage.
   • Fix: Use native async I/O APIs (HttpClient, SqlClient, FileStream). Reserve Task.Run for CPU-bound work.

7. Unbounded Async Queues

   • Why it happens: Using ConcurrentQueue or List with Task.WhenAll.
   • Impact: OOM exceptions, Gen 2 GC pressure, latency spikes.
   • Fix: Use Channel<T> with BoundedChannelOptions. Apply backpressure.

Production Bundle

Action Checklist

• Audit all async void usages; convert to Task or background service pattern.
• Verify ConfigureAwait(false) in all library-facing async methods.
• Replace .Result/.Wait() with await up to the composition root.
• Implement bounded channels or semaphore throttling for producer-consumer flows.
• Propagate CancellationToken through every async boundary.
• Add structured exception handling; never swallow async failures.
• Instrument async pipelines with ActivitySource and counters for observability.
• Validate graceful shutdown via IHostedService or IAsyncDisposable.

Decision Matrix

Configuration Template

// appsettings.json
{
  "AsyncPipeline": {
    "BoundedCapacity": 500,
    "WorkerCount": 4,
    "EnableBackpressure": true,
    "TelemetryEnabled": true
  }
}

// Startup / DI Registration
services.Configure<AsyncPipelineOptions>(configuration.GetSection("AsyncPipeline"));
services.AddSingleton<AsyncPipeline<string, ProcessingResult>>(sp =>
{
    var options = sp.GetRequiredService<IOptions<AsyncPipelineOptions>>().Value;
    var logger = sp.GetRequiredService<ILogger<AsyncPipeline<string, ProcessingResult>>>();
    
    return new AsyncPipeline<string, ProcessingResult>(
        options.BoundedCapacity,
        options.WorkerCount,
        async (input, ct) => await ProcessAsync(input, ct),
        logger
    );
});

services.AddHostedService<PipelineBackgroundService>();

Quick Start Guide

1. Map Boundaries: Identify I/O vs CPU operations. Replace Task.Run on I/O with native async APIs.
2. Inject Cancellation: Add CancellationToken to method signatures. Flow it through calls and loops.
3. Select Pattern: Use Channel<T> for pipelines, Parallel.ForEachAsync for parallel I/O, async/await for single operations.
4. Enforce Backpressure: Configure bounded channels. Reject or queue with wait semantics. Monitor queue depth.
5. Validate Shutdown: Implement IAsyncDisposable or BackgroundService. Test cancellation propagation under load.

Async patterns in C# are not about writing await everywhere. They are about designing execution boundaries, managing concurrency contracts, and ensuring deterministic behavior under pressure. The patterns that survive production are those that treat async as infrastructure, not syntax. Implement with discipline, observe relentlessly, and let backpressure dictate flow.