Mastering Middleware in ASP.NET Core: The Complete Guide to Request Pipeline

app.Use – Middleware with next delegate

Adds middleware to the pipeline that will run for every request.

It doesn’t end the request instead, it passes control to the next middleware using await next.Invoke().

// Use Middleware: This runs for all requests
app.Use(async (context, next) =>
{
    // Do something before
    await next.Invoke(); // Call the next middleware
    // Do something after
});

app.Map – Branching middleware

Used to branch the pipeline based on request paths.

This middleware will only be executed if the request path matches the specified path.

app.Map("/about", appBuilder =>
{
    appBuilder.Run(async context =>
    {
        await context.Response.WriteAsync("About Page");
    });
});

app.Run – Terminal middleware

This middleware will always execute if no previous middleware short-circuits the pipeline and does not call any next middleware.

It is typically used at the end of the pipeline to generate a final response and stop further processing.

app.Run(async context =>
{
    await context.Response.WriteAsync("Hello from app.Run!");
});

Built-in middleware components in Asp.NET Core

Middleware components are pieces of code that are assembled into an application pipeline to handle requests and responses. ASP.NET Core provides several built-in middleware components to support common scenarios such as serving static files, handling authentication, routing requests, and more.

Middleware Pipeline in Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add services
builder.Services.AddRouting();
builder.Services.AddAuthentication();
builder.Services.AddAuthorization();
builder.Services.AddControllersWithViews();

var app = builder.Build();

// Middleware pipeline
app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication();
app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

app.Run();

Key Points

The order in which middleware components are added is critical. For example:

• UseRouting() → before UseAuthorization()

• UseAuthentication() → before UseAuthorization()

• UseStaticFiles() → before routing so static content is served without hitting the MVC pipeline.

Custom Middleware

Creating custom middleware in ASP.NET Core allows you to insert your own logic into the HTTP request pipeline. This is useful for tasks like logging, custom authentication, modifying responses, or intercepting requests.

Step-by-step

1. Create the Middleware Class

2. Create an Extension Method

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;
using System;

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;

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

    // Middleware logic
    public async Task InvokeAsync(HttpContext context)
    {
        // Log the incoming request
        Console.WriteLine($"[Request] {context.Request.Method} {context.Request.Path}");

        await _next(context); // Call the next middleware

        // Log the outgoing response
        Console.WriteLine($"[Response] {context.Response.StatusCode}");
    }
}

// Extension method for clean registration
public static class RequestLoggingMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestLogging(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestLoggingMiddleware>();
    }
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.UseHttpsRedirection();

// Register your custom middleware
app.UseMiddleware<RequestLoggingMiddleware>();

app.UseRouting();
app.UseAuthorization();

app.MapControllers();

app.Run();

Here are common interview questions and answers based on the topic “Mastering Middleware in ASP.NET Core: The Complete Guide to Request Pipeline”, suitable for .NET developer interviews:

🔹1. What is middleware in ASP.NET Core?

Answer

Middleware is software that's assembled into an application pipeline to handle requests and responses. Each component in the pipeline can either:

• Handle the request completely, or

• Pass it to the next middleware using await next().

🔹 2. How is middleware registered in the request pipeline?

Answer

Middleware is registered in the Program.cs or Startup.cs using extension methods like app.Use, app.Run, and app.Map.

Example

app.UseMiddleware<CustomMiddleware>();

🔹 3. What's the difference between app.Use, app.Run, and app.Map?

Common interview questions and answers

1. What is middleware in ASP.NET Core?

Answer

Middleware is software that's assembled into an application pipeline to handle requests and responses. Each component in the pipeline can either:

• Handle the request completely, or

• Pass it to the next middleware using await next().

2. How is middleware registered in the request pipeline?

Answer

Middleware is registered in the Program.cs or Startup.cs using extension methods like app.Use, app.Run, and app.Map.

app.UseMiddleware<CustomMiddleware>();

3. What's the difference between app.Use, app.Run, and app.Map?

public class CustomMiddleware
{
    private readonly RequestDelegate _next;
    public CustomMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)
    {
        // Pre-processing logic
        await _next(context); // Call next middleware
        // Post-processing logic
    }
}

app.UseMiddleware<CustomMiddleware>();

await _next(context);

public class ExceptionMiddleware
{
    private readonly RequestDelegate _next;
    public ExceptionMiddleware(RequestDelegate next) => _next = next;

    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            // Log and handle error
            context.Response.StatusCode = 500;
            await context.Response.WriteAsync("Internal Server Error");
        }
    }
}

public class LoggingMiddleware
{
    private readonly ILogger<LoggingMiddleware> _logger;
    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger)
    {
        _logger = logger;
    }
}