A practical guide to understanding the request pipeline, middleware execution order, and how ASP.NET Core processes HTTP requests behind the scenes.

Have you ever wondered what happens when you send a request to an ASP.NET Core API?

Does it go directly to the controller? Not exactly!

Before reaching the controller, your request passes through several components called middleware. These components handle tasks like authentication, logging, error handling, and routing.

Let’s understand how it works with a simple example.

1. What Is Middleware?

Middleware is a component that processes HTTP requests and responses in an ASP.NET Core application.

Think of middleware as security checkpoints. Each checkpoint checks something before allowing you to move forward.

For example, middleware can:

• Handle exceptions
• Redirect HTTP to HTTPS
• Authenticate users
• Check user permissions
• Log requests and responses

2. How Does a Request Flow?

Imagine you’re calling this API:

GET /api/products

The request typically passes through a pipeline like this:

Client / Postman
       |
       v
Exception Handling
       |
       v
HTTPS Redirection
       |
       v
Routing
       |
       v
Authentication
       |
       v
Authorization
       |
       v
Controller
       |
       v
HTTP Response

Each middleware performs its task before passing control to the next component.

If authentication fails or middleware stops the pipeline, the controller might never execute.

3. How Does Middleware Execute?

Let’s create simple middleware:

app.Use(async (context, next) =>
{
    Console.WriteLine("Before");
    await next();
    Console.WriteLine("After");
});
app.Run(async context =>
{
    Console.WriteLine("Controller logic");
    await context.Response.WriteAsync("Hello World!");
});

Output:

Before
Controller logic
After

Why?

• Before executes first.
• await next() passes control to the next component.
• The terminal delegate executes.
• Execution returns, and After runs.

This is how middleware can process both requests and responses.

4. Why Does Middleware Order Matter?

Middleware must be registered in the correct order.

For example:

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

Authentication identifies the user, while authorization checks whether that user has permission to access the resource.

Incorrect ordering can cause unexpected behavior.

Remember: In ASP.NET Core, middleware order matters!

5. What Is Custom Middleware?

You can create your own middleware for tasks such as request logging or measuring API response time.

For example:

app.Use(async (context, next) =>
{
    var start = DateTime.UtcNow;
    await next();
    var duration = DateTime.UtcNow - start;
    Console.WriteLine(
        $"Request took {duration.TotalMilliseconds} ms");
});

This helps you measure how long a request takes to complete.

Conclusion

Middleware is one of the most important concepts in ASP.NET Core.

It helps you handle requests, manage authentication, catch errors, and improve application performance.

The key things to remember are:

• Middleware processes requests and responses.
• Use() can pass control to the next component.
• Run() registers terminal middleware.
• Middleware order matters.
• Custom middleware lets you implement your own logic.

Once you understand middleware, understanding the ASP.NET Core request pipeline becomes much easier.

Tags: ASP.NET Core · C# · .NET ·

Middleware in ASP.NET Core: What Really Happens to Your Request? was originally published in Dot Net, API & SQL Learning on Medium, where people are continuing the conversation by highlighting and responding to this story.