ASP.NET Core Middleware With Examples

Last updated on December 28th, 2022 at 07:26 pm

In ASP.NET Core, middleware is a component that can be plugged into the request processing pipeline to perform some action for each request. It sits between the server and the application and is responsible for handling requests and responses.

What is the middleware in ASP.NET Core?

In ASP.NET Core, middleware is a piece of code that is assembled into an application pipeline to handle HTTP requests and responses.

Middleware can be thought of as a series of “pipes” through which a request flows, with each piece of middleware performing some action on the request and then passing it along to the next piece of middleware in the pipeline. This allows developers to modify the request and response objects at various points in the pipeline to add custom behavior to the application.

Usually, an application may contain multiple middleware components that can perform the following tasks:

• In ASP.NET Core, middleware determines whether or not the HTTP request should be forwarded to the next component in the pipeline by calling the next() method.
• Middleware processes incoming or outgoing HTTP requests or responses, modifies them as needed, and then either passes them on to other middleware or the ASP.NET Core web server.
• We can have multiple middleware components in an ASP.NET Core application, each with a specific function such as authenticating users, handling exceptions, routing requests, and serving static files like JavaScript, CSS, and images. These middleware components work together to process incoming requests and produce appropriate responses.
• HTTP requests in the middleware pipeline are managed by Request Delegates, which can be configured using the Use, Run, and Map extension methods.

Middleware Ordering in ASP.NET Core

In an ASP.NET Core web application, the correct sequence of middleware layers is represented in the diagram below. It is important to add the middleware in the correct sequence, or the application may not work as planned. It’s crucial to know where each request delegate belongs in the pipeline.

Configure Middleware

In ASP.NET Core, the Configure method is a method in the Startup class that is used to configure the request processing pipeline for an application. It is called by the host when the application starts up and is passed an IApplicationBuilder object and an IWebHostEnvironment object as arguments.

The Configure method is where you can add middleware to the request processing pipeline and configure other aspects of the application, such as routing, dependency injection, authentication, and other hosting options.

• The Configure method is an important part of the ASP.NET Core request processing pipeline and is where you can add and configure middleware and other application components.
• The Configure method in ASP.NET Core uses the IApplicationBuilder instance to handle all HTTP requests. You can register multiple middleware components in the Configure method, but the order in which they are registered is important as it determines the order in which they will be executed for each request.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseCookiePolicy();

    app.UseRouting();
    app.UseCors();

    app.UseAuthentication();
    app.UseAuthorization();
    app.UseSession();
    app.UseResponseCaching();

    // Custom middleware components
	// app.UseMiddleware<MiddlewareName>(); 

    app.UseEndpoints(endpoints =>    
    {    
      //  endpoints.MapRazorPages();  
            endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");                
    }); 
}

Use() method in Middleware

In ASP.NET Core, the Use method is used to add middleware to the request processing pipeline. It is called on the IApplicationBuilder object and takes a middleware delegate as an argument. The middleware delegate is a function that receives an HttpContext object as an argument and returns a Task.

Example:

Here’s an example of how you might use the Use method to add multiple middlewares to the pipeline:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.Use(async (context, next) =>
            {
               await context.Response.WriteAsync("Middleware 1 \n");
                await next();
            });
            app.Use(async (context, next) =>
            {
              await  context.Response.WriteAsync("Middleware 2");
                await next();
            });
        }

In the above example, the Use method is being used to add a piece of middleware to the pipeline that will be executed for every request. The middleware delegate is passed an HttpContext object, which represents the current request and response, and a next delegate, which can be used to pass the request on to the next piece of middleware in the pipeline.

The Use method can be called multiple times to add multiple pieces of middleware to the pipeline. The middleware will be executed in the order it was added to the pipeline.

It’s important to note that the Use method is non-terminating, meaning that it will not short-circuit the request pipeline. This means that after the middleware delegate has been executed, the request will be passed on to the next piece of middleware in the pipeline unless the response has already been completed.

Run() method in Middleware

In ASP.NET Core, the Run method is used to add middleware to the request processing pipeline that will terminate the request pipeline. It is called on the IApplicationBuilder object and takes a middleware delegate as an argument. The middleware delegate is a function that receives an HttpContext object as an argument and returns a Task.

The Run method is terminating, meaning that it will short-circuit the request pipeline and prevent any further middleware from being executed. This is useful when you want to handle a request and immediately complete the response, without allowing any further middleware to modify the request or response.

It’s important to note that the Run method should generally be placed at the end of the middleware pipeline, as it will terminate the pipeline and prevent any further middleware from being executed.

Example:

Following is an example of how you might use the Run method to add middleware to the pipeline:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.Use(async (context, next) =>
            {
               await context.Response.WriteAsync("Middleware 1 \n");
                await next();
            });
            app.Use(async (context, next) =>
            {
              await  context.Response.WriteAsync("Middleware 2 \n");
                await next();
            });

            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Middleware 3 \n");
            });

            // The below middleware will never execute as we already used app.Run()
            // method in the above statement.
            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Middleware 4 \n");
            });
        }

In the example above, only the first Run method will be called and the request processing pipeline will be terminated after that, so the request will never reach the second Run method.

Map() method in Middleware

In ASP.NET Core, the Map method is used to add middleware to the request processing pipeline that will only be executed for requests that match a specified pattern. It is called on the IApplicationBuilder object and takes a request path pattern and a middleware delegate as arguments. The middleware delegate is a function that receives an IApplicationBuilder object as an argument and returns void.

The Map method is useful when you want to add middleware that should only be executed for requests that match a specific pattern. It allows you to create separate branches in the request processing pipeline for different request paths.

The Map method in ASP.NET Core is used to match request delegates to requests based on the request’s path. It allows you to create branches in the request processing pipeline based on the request path. If the request path starts with the specified URL path, the corresponding branch of middleware will be executed.

Example:

Following is an example of how we can use the Map method to add middleware to the pipeline:

 public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.Use(async (context, next) =>
            {
               await context.Response.WriteAsync("Middleware 1 \n");
                await next();
            });

            app.Map("/Map1", HandleMapRequest);

            app.Run(async (context) =>
            {
                await context.Response.WriteAsync("Middleware 3 \n");
            });          

        }
        private static void HandleMapRequest(IApplicationBuilder app)
        {
            app.Run(async context =>
            {
                await context.Response.WriteAsync(" Middleware 2 from app.Map() \n");
            });
        }

What is a Request delegate in ASP.NET Core?

In ASP.NET Core, a request delegate is a function that handles an incoming HTTP request and produces a response. It is passed an HttpContext object as an argument, which represents the current request and response, and returns a Task.

Request delegates are used to define the behavior of middleware in the request processing pipeline. They are typically passed to the Use, Run, or Map extension methods on the IApplicationBuilder object to add middleware to the pipeline.

Example:

Following is an example of a simple request delegate:

public async Task MyCustomMiddleware(HttpContext context)
{
    // Do something with the request and response
    await context.Response.WriteAsync("Hello, World!");
}

In the above code example, the request delegate MyCustomMiddleware is a simple function that writes “Hello, World!” to the response. It can be added to the request processing pipeline by calling the Use or Run extension method on the IApplicationBuilder object and passing the delegate as an argument.

Request delegates are an important part of the ASP.NET Core request processing pipeline and allow developers to add custom behavior to their applications.

References: MSDN ASP.NET Core Middleware

FAQ

Here are some common questions and answers about ASP.NET Core middleware:

If you enjoyed reading this blog, please consider liking, commenting on, and sharing it with others.

Articles to Check Out:

• C# Abstract class Vs Interface
• WCF vs Web API
• Top 50 C# Interview Questions And Answers
• Collections in C# .NET
• C# 10 new features
• C# Array vs List: When should you use an array or a List?
• Generic Delegates in C# With Examples
• IEnumerable Interface in C# with examples
• Constructors in C# with Examples
• C# Enum | How to Use enumeration type in C#?
• Properties In C# with examples
• Multithreading in C#

• Author
• Recent Posts

Shekh Ali

Meet Sheikh Ali, a skilled Software engineer and passionate a blogger. He enjoys sharing his expertise in C#, Java, SQL, Design Patterns, and other related topics through his writing. When he's not coding, Sheikh Ali can often indulge in his passions for reading books and fitness training.

Latest posts by Shekh Ali (see all)

• Difference Between Array And ArrayList In C#: Choosing the Right Collection - May 28, 2024
• C# Program to Capitalize the First Character of Each Word in a String - February 21, 2024
• C# Program to Find the Longest Word in a String - February 19, 2024