Explain the ASP.NET Core middleware pipeline — how does request order actually affect behavior?

ASP.NET Core Middleware – Complete Explanation

Middleware is a software component that is executed as part of the HTTP Request-Response Pipeline in ASP.NET Core. Every HTTP request passes through a sequence of middleware components.

1. How Middleware Works

When a client sends a request, it passes through middleware components in the order they are registered.

Client Request
↓
Middleware 1
↓
Middleware 2
↓
Middleware 3
↓
Controller / Endpoint

---

HTTP Response travels backward
↑ Middleware 3
↑ Middleware 2
↑ Middleware 1
↑ Client

2. Understanding await next()

The await next() statement calls the next middleware component in the pipeline. After the next middleware completes, execution returns to the current middleware.

app.Use(async (context, next) =>

{

    Console.WriteLine("Middleware 1 - Before");



    await next();



    Console.WriteLine("Middleware 1 - After");

});



app.Use(async (context, next) =>

{

    Console.WriteLine("Middleware 2 - Before");



    await next();



    Console.WriteLine("Middleware 2 - After");

});



app.Run(async context =>

{

    Console.WriteLine("Endpoint Executed");



    await context.Response.WriteAsync("Hello from ASP.NET Core");

});

Expected Output:

Middleware 1 - Before

Middleware 2 - Before

Endpoint Executed

Middleware 2 - After

Middleware 1 - After

3. Types of Middleware Methods

Method	Purpose
Use()	Executes middleware and can call the next middleware.
Run()	Creates a terminal middleware. It does not call the next middleware.
Map()	Creates a separate pipeline based on the request path.
UseWhen()	Creates a conditional middleware branch that can rejoin the main pipeline.
MapWhen()	Creates a separate branch based on a condition.

4. Difference Between Use() and Run()

Use() Example:

app.Use(async (context, next) =>

{

    Console.WriteLine("Before");

    await next();

    Console.WriteLine("After");

});

Run() Example:

app.Run(async context =>

{

    await context.Response.WriteAsync("Request Completed");

});

Remember: Run() is terminal middleware. Middleware registered after it will not execute for requests that reach it.

5. Why Middleware Order Is Important

Middleware registration order directly affects application behavior.

• Exception Handling: Generally register early to catch downstream exceptions.
• HTTPS Redirection: Redirect HTTP requests to HTTPS.
• Routing: Identifies the endpoint for the request.
• CORS: Handles cross-origin requests.
• Authentication: Identifies the logged-in user.
• Authorization: Checks whether the user has permission.

6. Practical Middleware Order in ASP.NET Core

var builder = WebApplication.CreateBuilder(args);



builder.Services.AddControllers();

builder.Services.AddAuthentication();

builder.Services.AddAuthorization();



var app = builder.Build();



if (!app.Environment.IsDevelopment())

{

    app.UseExceptionHandler("/Error");

    app.UseHsts();

}



app.UseHttpsRedirection();



app.UseStaticFiles();



app.UseRouting();



app.UseCors();



app.UseAuthentication();



app.UseAuthorization();



app.MapControllers();



app.Run();

Important: Configure authentication schemes and CORS policies in the service registration. The example shows the middleware sequence; production applications may require additional configuration.

7. Important Interview Questions

1. What is middleware in ASP.NET Core?
2. What is the difference between Use(), Run(), and Map()?
3. What happens when we don't call await next()?
4. Why should UseAuthentication() come before UseAuthorization()?
5. Why is middleware execution order important?

8. Important Points to Remember

• Middleware executes in registration order for incoming requests.
• Response execution generally happens in reverse order.
• await next() passes control to the next middleware.
• Not calling next() short-circuits the pipeline.
• Run() is used for terminal middleware.
• Authentication must execute before Authorization.
• Static files served directly by Static File Middleware are generally public.

Conclusion

Middleware is one of the most important concepts in ASP.NET Core. Understanding the request-response pipeline, middleware execution order, and the difference between Use(), Run(), and Map() helps developers build secure, scalable, and maintainable Web API applications.