Async Programming

Asynchronous Programming in ASP.NET Core (.NET 10)

👤 Rohan Kumawat⏱️ 12 min read

Asynchronous Programming in ASP.NET Core

Asynchronous programming allows your application to handle more requests, avoid blocking threads, and improve performance and scalability. ASP.NET Core is built from the ground up to support async/await, making it easier to build high-performance web applications and APIs.

Why Asynchronous Programming?

ASP.NET Core applications run on a limited number of thread pool threads. When a thread is blocked due to operations like database queries or API calls, it reduces the application's ability to handle more requests. Using async/await releases the thread until the work is completed, leading to better throughput and responsiveness.

When Should You Use Async?

Async should be used for I/O-bound tasks such as database calls, external API calls, file operations, and network communication. It should not be used for CPU-bound tasks such as heavy computations, where synchronous operations are sufficient or background services are recommended.

How Async Works in ASP.NET Core

ASP.NET Core natively supports async programming in controllers, middleware, services, EF Core, HttpClient, SignalR, and minimal APIs. The async/await keywords help free the server thread while waiting for I/O operations.

public async Task<IActionResult> GetUser(int id)
{
    var user = await _db.Users.FindAsync(id);
    return Ok(user);
}

Async Controller Example

This example demonstrates how to use async/await in a controller action when fetching data using Entity Framework Core.

[HttpGet("{id}")]
public async Task<IActionResult> GetProduct(int id)
{
    var product = await _context.Products
                                .FirstOrDefaultAsync(p => p.Id == id);

    if (product == null)
        return NotFound();

    return Ok(product);
}

Async in Services

Services should also follow the async pattern to avoid blocking calls and ensure end-to-end async flows across the application layers.

public class UserService : IUserService
{
    private readonly AppDbContext _context;

    public UserService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<List<User>> GetAllUsersAsync()
    {
        return await _context.Users.ToListAsync();
    }
}

Async with HttpClient

HttpClient is fully asynchronous and should always be used with await to avoid blocking the thread while waiting for a response from external services.

public async Task<string> CallApiAsync()
{
    using var client = new HttpClient();
    var response = await client.GetAsync("https://api.github.com");
    return await response.Content.ReadAsStringAsync();
}

Async Middleware in ASP.NET Core

You can create asynchronous middleware by defining an InvokeAsync method that awaits the next middleware component in the pipeline.

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;

    public LoggingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine("Request Started");
        await _next(context);
        Console.WriteLine("Request Ended");
    }
}

Async in Minimal APIs

Minimal APIs introduced in .NET 6 and improved in later versions support full async/await for high-performance API development.

app.MapGet("/users", async (AppDbContext db) =>
{
    var users = await db.Users.ToListAsync();
    return Results.Ok(users);
});

Important Rules for Async Programming

To avoid performance issues and deadlocks, avoid using .Result or .Wait(), use async all the way down from controllers to repositories, do not wrap synchronous code inside Task.Run(), and only use ConfigureAwait(false) when building libraries.

Performance Benefits

Using asynchronous programming significantly improves the scalability and responsiveness of your ASP.NET Core application. It allows more requests to be processed simultaneously, eliminates thread blocking, and is essential for building modern microservices and APIs.

Conclusion

Asynchronous programming in ASP.NET Core is crucial for building high-performance, scalable, and responsive APIs and web applications. Using async/await correctly helps improve throughput, minimize latency, and boost overall system performance.