Learn .NET - Asynchronous Programming & Concurrency

#Introduction

I/O operations — reading files, calling APIs, querying databases — take up the largest part of an application's execution time. Episode 14 teaches you how to run these operations without blocking threads: the async/await pattern, Task, cancellation, and parallel programming.

The importance cannot be understated: a web server that blocks a thread while waiting on a database will run out of threads quickly. With async, the thread is released to serve other requests while the I/O operation waits. This is the difference between a slow API and an API serving thousands of concurrent requests.

#The Task-Based Async Pattern

#Async and await Basics

The async keyword marks a method that can be suspended, and await waits for an async operation without blocking the thread:

public async Task<List<Produk>> GetProdukAsync()
{
    using var db = new AppDbContext();
    return await db.Produk
        .Where(p => p.Stok > 0)
        .ToListAsync();
}

await db.Produk...ToListAsync() releases the thread while the database query runs and resumes it when the results are available. ToListAsync is the async version of ToList. Methods that use await must be marked async and return Task or Task<T>.

#Execution Flow

When await runs, control returns to the caller and the thread is free to do other work. When the operation finishes, execution resumes — usually on the same thread pool. This is why async makes applications more scalable, not merely faster.

#Task, ValueTask, and Cancellation Tokens

#Task and ValueTask

A Task is the representation of an operation in progress. For operations that frequently complete synchronously (for example, from a cache), ValueTask reduces allocations:

public ValueTask<Produk> GetCachedAsync(int id)
{
    if (_cache.TryGetValue(id, out var produk))
    {
        return ValueTask.FromResult(produk);
    }
    return LoadFromDbAsync(id);
}

ValueTask.FromResult returns a value directly without allocating a Task. Use ValueTask only when profiling shows allocation pressure; Task remains the safe default.

#Cancellation Tokens

Long-running operations must be cancellable. A CancellationToken propagates the cancellation signal:

public async Task<string> CallApiAsync(CancellationToken token)
{
    using var http = new HttpClient();
    return await http.GetStringAsync("https://api.example.com", token);
}

The CancellationToken is passed to HttpClient and the database. When a client disconnects, the framework signals the token and the operation stops early — saving server resources. Always accept and forward the CancellationToken from the parameter all the way to the I/O operation.

#Parallel Programming

#Parallel.For for CPU-Bound Work

For heavy independent CPU work, Parallel.For splits the work across many threads:

var hasil = new int[1_000_000];
 
Parallel.For(0, hasil.Length, i =>
{
    hasil[i] = Compute(i);
});

Parallel.For(0, hasil.Length, ...) executes the lambda on many threads at once. It suits large, independent data transformations. Don't use it for I/O — for that, async is the better choice.

#Channels for Producer-Consumer

A Channel implements a thread-safe queue for the producer-consumer pattern:

var channel = Channel.CreateUnbounded<string>();
 
await channel.Writer.WriteAsync("pesan 1");
await channel.Reader.ReadAsync();

Channel.CreateUnbounded<string>() creates a queue; Writer puts items in and Reader takes them out. This pattern is the basis of processing pipelines — many workers read from a single channel and process items in parallel.

#Thread Safety and Synchronization Primitives

#Race Conditions and Lock

When many threads write the same data, results can be inconsistent. lock restricts access to a single thread:

private readonly object _lock = new();
private int _penghitung;
 
public void Tambah()
{
    lock (_lock)
    {
        _penghitung++;
    }
}

lock (_lock) ensures only one thread enters the block at a time. For concurrent collections, consider ConcurrentDictionary and ConcurrentQueue, which are designed to be thread-safe from the start — faster and less error-prone than manual locks.

#Choosing the Right Tool

A guide:

• lock: protects small mutations of shared state.
• ConcurrentDictionary: a thread-safe key-value collection.
• Channel: producer-consumer pipelines with backpressure.
• SemaphoreSlim: limits concurrent access, for example to a limited resource.
• Interlocked: simple atomic operations such as increment.

#Concurrency Practice Summary

• Use async/await for I/O; the thread pool handles the rest.
• Forward the CancellationToken from the request down to I/O operations.
• Use Parallel.For for independent CPU-bound work.
• Use Channels to separate message production and consumption.
• Prefer concurrent collections over manual locks when possible.

#Closing

Key takeaways:

• async/await keeps I/O operations from blocking threads.
• Task represents an async operation; ValueTask saves allocations on fast paths.
• CancellationToken enables clean cancellation.
• Parallel.For speeds up independent CPU-bound work.
• Channels connect producers and consumers thread-safely.
• lock, ConcurrentDictionary, and SemaphoreSlim maintain thread safety.

In the next episode 15 we will discuss performance and diagnostics — profiling with dotnet-trace and dotnet-counters, memory diagnostics and GC tuning, Span and Memory for minimal allocations, and hot reload, tiered compilation, and AOT considerations.