Chris Straw

Proper Ordering of Middleware Components in ASP.NET Core

Middleware components in an ASP.NET Core application play a crucial role in handling HTTP requests and responses. Their positioning in your application defines the order of their operation, impacting the flow and function of the app. Middleware should typically be ordered from the most specific to the most general. Let’s take a deep dive into the common middleware components and how they should be ordered.

Exception Handling

  1. UseExceptionHandler / UseDeveloperExceptionPage: As the first line of defense, these middleware handle exceptions. By registering them first, you ensure that any exceptions occurring further down the pipeline are efficiently caught and handled, thus improving the robustness of your application.

Secure Redirection

  1. UseHttpsRedirection: This middleware serves an essential role in enhancing your application’s security. It ensures that all HTTP requests are redirected to HTTPS, safeguarding data in transit. Placing it near the top of the middleware pipeline ensures that all subsequent middleware are dealing with secure HTTPS requests.

Serving Static Files

  1. UseStaticFiles: The role of this middleware is to serve static files such as CSS, JavaScript, and images. It’s usually placed before other middleware components that generate responses to ensure these static files are readily available when needed.


  1. UseRouting: This middleware component’s task is to match incoming HTTP requests and dispatch those requests to the right endpoint. By effectively handling routing, it guides the user’s request through the application’s flow.

Authentication and Authorization

  1. UseAuthentication: As the name suggests, this middleware is responsible for authenticating the user. It verifies the user’s identity before the request can proceed to the next stage.
  2. UseAuthorization: Following successful authentication, this middleware handles authorization. It ensures the authenticated user has the correct permissions to access the requested resource.

Custom Middleware

  1. When adding custom middleware to an ASP.NET Core application, the placement really depends on what the middleware is designed to do.If your middleware should apply to every request, such as logging or error handling middleware, it should be added at the top of the middleware pipeline, before other middleware. This way, it can act on all requests and responses.

  2. On the other hand, if your middleware is only needed for certain routes or actions, it should be placed after the UseRouting middleware and before the UseEndpoints middleware.

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        // Place your custom middleware here, after UseRouting
        app.UseEndpoints(endpoints =>

    In this example, YourCustomMiddleware will apply to all requests after they have been routed. It will run before the matched endpoint is executed.

    However, the rule of thumb is to always analyze what the custom middleware does, then decide its position in the pipeline accordingly. Remember, the middleware components are invoked in the order they’re added (top to bottom), and the subsequent middleware components will not run until the previous ones have completed processing.


  1. UseEndpoints: Finally, this middleware maps the incoming request to the endpoint. As it invokes the execution action, it should generally be the last middleware in the pipeline.

The middleware pipeline order might seem straightforward, but keep in mind that it needs to be adapted to the specific needs of your application. Each middleware’s order could change depending on its function, and your pipeline may include additional middleware components not mentioned here.

Remember, your middleware pipeline’s proper configuration plays a significant role in creating efficient, secure, and robust ASP.NET Core applications. Invest time in understanding each middleware’s role and ordering them correctly to reap these benefits.

Written by

Chris Straw