Creating Custom Middleware Extensions in ASP.NET Core: Keep Your Program.cs Clean

As an ASP.NET Core application grows, Program.cs can quickly become cluttered with middleware registrations.

For example:

app.UseMiddleware<RequestLoggingMiddleware>();
app.UseMiddleware<ApiKeyMiddleware>();
app.UseMiddleware<TenantMiddleware>();
app.UseMiddleware<RequestValidationMiddleware>();
app.UseMiddleware<MaintenanceModeMiddleware>();

While this works, it’s not the cleanest approach.

A better practice is to create extension methods that encapsulate middleware registration.

---

Step 1: Create Your Middleware

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        Console.WriteLine($"Request: {context.Request.Path}");

        await _next(context);

        Console.WriteLine($"Response: {context.Response.StatusCode}");
    }
}

---

Step 2: Create an Extension Method

Create a static extension class:

public static class RequestLoggingMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestLogging(
        this IApplicationBuilder app)
    {
        return app.UseMiddleware<RequestLoggingMiddleware>();
    }
}

Now your middleware has a meaningful and reusable registration method.

---

Step 3: Register It

Instead of:

app.UseMiddleware<RequestLoggingMiddleware>();

Use:

app.UseRequestLogging();

This makes Program.cs much cleaner and easier to read.

---

Why Use Extension Methods?

✅ Improved Readability

Instead of exposing implementation details, your pipeline reads like documentation.

app.UseRequestLogging();
app.UseApiKeyValidation();
app.UseTenantValidation();
app.UseMaintenanceMode();

---

✅ Better Maintainability

If the middleware implementation changes, the registration code remains the same.

---

✅ Reusability

The extension method can be shared across multiple projects or packaged into a reusable library.

---

✅ Encapsulation

Consumers don’t need to know whether you’re using:

• UseMiddleware<T>()
• Multiple middleware components
• Additional configuration

Everything is hidden behind a simple method.

---

Real-World Example

Many built-in ASP.NET Core middleware components follow this pattern:

app.UseAuthentication();

app.UseAuthorization();

app.UseCors();

app.UseSession();

app.UseSwagger();

These are all extension methods internally.

Following the same pattern makes your custom middleware feel like a natural part of ASP.NET Core.

---

Best Practices

✔ Keep each middleware focused on a single responsibility.

✔ Give extension methods meaningful names.

✔ Place extensions in a dedicated Extensions folder.

✔ Use XML comments if the middleware is part of a shared library.

---

Final Thoughts

Creating extension methods for custom middleware is a small change that greatly improves the readability and maintainability of your application.

A clean Program.cs makes it easier for new developers to understand the request pipeline and keeps your startup configuration organized.

When building professional ASP.NET Core applications, aim for code that is not only functional but also easy to read and maintain.