ASP.NET Core Custom Middleware Creation: A Comprehensive Guide with Practical Examples

The modular pipeline of ASP.NET Core is well-known, and middleware components are essential to managing HTTP requests and responses. Request logging, authentication, routing, response modification, error handling, and other functions are all possible with middleware. UseRouting, UseAuthorization, and other middleware are built into ASP.NET Core, but in many situations, you’ll want to make your own.

In this article, we’ll explore:

• What middleware is
• Why and when to use custom middleware
• How to create and register custom middleware
• Real-world examples
• Best practices

What is Middleware?

Middleware in ASP.NET Core is software that’s assembled into the HTTP request pipeline. Each piece of middleware:

• Processes an incoming request
• Can optionally pass the request to the next component
• Optionally processes the response on the way back

Conceptually, it looks like a chain:

Request --> Middleware 1 --> Middleware 2 --> Middleware 3 --> ... --> Response

Why Create Custom Middleware?

You should consider writing custom middleware when:

• You want reusable, centralized behavior (like logging or metrics)
• You need to intercept or transform requests or responses
• Built-in middleware doesn’t meet your specific need

Project Setup

Let’s build a simple ASP.NET Core Web API project to demonstrate.

dotnet new webapi -n CustomMiddlewareDemo
cd CustomMiddlewareDemo

Example 1: Logging Request Duration
Purpose:

Log how long each HTTP request takes.

Step 1. Create the Middleware

File: Middleware/RequestTimingMiddleware.cs

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

namespace CustomMiddlewareDemo.Middleware
{
    public class RequestTimingMiddleware
    {
        private readonly RequestDelegate _next;

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

        public async Task InvokeAsync(HttpContext context)
        {
            var stopwatch = Stopwatch.StartNew();

            await _next(context); // Call next middleware

            stopwatch.Stop();

            var elapsedMs = stopwatch.ElapsedMilliseconds;
            Console.WriteLine($"⏱️ [{DateTime.Now}] Request {context.Request.Method} {context.Request.Path} took {elapsedMs}ms");
        }
    }
}

Step 2. Create an Extension Method

File: Middleware/RequestTimingMiddlewareExtensions.cs

using Microsoft.AspNetCore.Builder;

namespace CustomMiddlewareDemo.Middleware
{
    public static class RequestTimingMiddlewareExtensions
    {
        public static IApplicationBuilder UseRequestTiming(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<RequestTimingMiddleware>();
        }
    }
}

using CustomMiddlewareDemo.Middleware;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();

var app = builder.Build();

app.UseRequestTiming(); // Our custom middleware

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Step 4. Add a Test Endpoint

File: Controllers/TestController.cs

using Microsoft.AspNetCore.Mvc;
using System.Threading;

namespace CustomMiddlewareDemo.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class TestController : ControllerBase
    {
        [HttpGet]
        public IActionResult Get()
        {
            Thread.Sleep(200); // Simulate processing delay
            return Ok("Middleware test successful!");
        }
    }
}

Output Example (Console)

When you visit /api/test, the console logs:

[7/28/2025 12:34:56 PM] Request GET /api/test took 201ms

Example 2: Inject a Custom Header into Every Response
Purpose:

Add a custom header to every outgoing HTTP response.

Middleware/CustomHeaderMiddleware.cs

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

namespace CustomMiddlewareDemo.Middleware
{
    public class CustomHeaderMiddleware
    {
        private readonly RequestDelegate _next;

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

        public async Task InvokeAsync(HttpContext context)
        {
            context.Response.OnStarting(() =>
            {
                context.Response.Headers.Add("X-Powered-By", "ASP.NET Core Custom Middleware");
                return Task.CompletedTask;
            });

            await _next(context);
        }
    }
}

Register it in Program.cs:

app.UseMiddleware<CustomHeaderMiddleware>();

Now every HTTP response will include:

X-Powered-By: ASP.NET Core Custom Middleware

Best Practices

Best ASP.NET Core 10.0 Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core 10.0 hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core 10.0 version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFEASP.NET, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFEASP.NET guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.