Custom Middleware Development in ASP.NET Core

Custom Middleware Development in ASP.NET Core is an important skill for developers who need to implement application-specific request processing logic. While ASP.NET Core provides many built-in middleware components, there are situations where custom behavior is required, such as request logging, API key validation, performance monitoring, auditing, custom authentication, request filtering, and response modification.

Understanding Custom Middleware Development in ASP.NET Core helps developers build reusable, maintainable, and scalable solutions that integrate seamlessly into the ASP.NET Core request processing pipeline.

What is Custom Middleware?

Custom Middleware is developer-created middleware that executes custom logic during request processing.

Example:

Request

↓

Custom Middleware

↓

Response

The middleware can inspect, modify, or terminate requests and responses.

Why Create Custom Middleware?

Built-in middleware may not always satisfy business requirements.

Examples:

Custom Logging

API Key Validation

Request Tracking

Auditing

Performance Monitoring

Custom middleware solves application-specific problems.

Middleware Pipeline Review

Client

↓

Middleware

↓

Middleware

↓

Controller

↓

Response

Custom middleware becomes part of this pipeline.

Real-World Example

E-Commerce Website:

Customer Request

↓

Custom Logging Middleware

↓

Authentication

↓

Product API

↓

Response

Every request can be logged automatically.

Structure of Custom Middleware

A middleware class typically contains:

Constructor

Invoke Method

Business Logic

These components work together to process requests.

Creating a Middleware Class

Example:

public class
RequestLoggingMiddleware
{
}

This class will contain middleware logic.

Middleware Constructor

Example:

private readonly
RequestDelegate next;

public
RequestLoggingMiddleware(
RequestDelegate next)
{
    this.next = next;
}

The constructor receives the next middleware in the pipeline.

What is RequestDelegate?

RequestDelegate represents:

Next Middleware

Purpose:

Continue Request Processing

It controls pipeline flow.

Understanding InvokeAsync()

Every middleware requires:

public async Task
InvokeAsync(
HttpContext context)
{
}

This method processes requests.

What is HttpContext?

HttpContext contains:

Request

Response

Headers

Cookies

User Information

It represents the current HTTP transaction.

Simple Custom Middleware Example

public async Task
InvokeAsync(
HttpContext context)
{
    Console.WriteLine(
    "Request Started");

    await next(context);

    Console.WriteLine(
    "Request Completed");
}

The middleware executes before and after the next component.

Request Flow Example

Request Started

↓

Controller

↓

Request Completed

The middleware surrounds endpoint execution.

Registering Custom Middleware

Program.cs:

app.UseMiddleware<
RequestLoggingMiddleware>();

The middleware becomes part of the pipeline.

Middleware Execution Order

Example:

app.UseMiddleware<
RequestLoggingMiddleware>();

app.UseAuthentication();

app.UseAuthorization();

Execution follows registration order.

Logging Request Information

Example:

var path =
context.Request.Path;

Purpose:

Capture Requested URL

Useful for monitoring.

Logging HTTP Methods

Example:

var method =
context.Request.Method;

Results:

GET

POST

PUT

DELETE

Request information can be recorded.

Logging Response Status Codes

Example:

var statusCode =
context.Response
.StatusCode;

Purpose:

Track API Responses

Useful for analytics and troubleshooting.

Middleware Before and After Execution

Example:

Console.WriteLine(
"Before");

await next(context);

Console.WriteLine(
"After");

Output:

Before

↓

Controller

↓

After

This demonstrates middleware flow.

Short-Circuiting the Pipeline

Middleware can stop request processing.

Example:

await context.Response
.WriteAsync(
"Access Denied");

Result:

Pipeline Stops

Subsequent middleware does not execute.

API Key Validation Middleware

Example Workflow:

Request

↓

Check API Key

↓

Valid?

↓

Continue

Or

Reject

Common in API security.

Custom Header Middleware

Example:

context.Response
.Headers.Add(
"App-Version",
"1.0");

Purpose:

Add Custom Response Headers

Useful for metadata.

Performance Monitoring Middleware

Workflow:

Start Timer

↓

Execute Request

↓

Stop Timer

↓

Calculate Duration

Helps identify slow requests.

Measuring Request Time

Example:

var stopwatch =
Stopwatch
.StartNew();

After execution:

stopwatch.Stop();

Request duration can be recorded.

Exception Logging Middleware

Purpose:

Capture Errors

Log Exceptions

Improve Monitoring

Custom middleware often handles error tracking.

Accessing Query Parameters

Example:

context.Request
.Query

Provides access to query string values.

Accessing Request Headers

Example:

context.Request
.Headers

Useful for authentication and auditing.

Accessing User Information

Example:

context.User

Provides authenticated user details.

Middleware Extension Methods

Instead of:

app.UseMiddleware<
RequestLoggingMiddleware>();

Create an extension method.

Example:

public static class
MiddlewareExtensions
{
}

This improves readability.

Extension Method Example

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

Registration becomes cleaner.

Using Extension Methods

Program.cs:

app.UseRequestLogging();

This is the preferred enterprise approach.

Dependency Injection in Middleware

Middleware can use:

Logging Services

Repositories

Configuration

Database Services

ASP.NET Core injects dependencies automatically.

Middleware and Services

Example:

ILogger

Configuration

DbContext

Services enhance middleware capabilities.

Real-World Example

Banking Application:

Middleware:

Audit Logging

Authentication

Fraud Detection

Authorization

Each component contributes to security.

Hospital Management System Example

Middleware:

Request Tracking

Role Validation

Patient Access Monitoring

Sensitive operations are monitored.

E-Commerce Application Example

Middleware:

Cart Tracking

Analytics

Authentication

Order Validation

Custom middleware supports business requirements.

Advantages of Custom Middleware Development in ASP.NET Core

Reusability

Middleware can be reused across projects.

Maintainability

Logic remains centralized.

Scalability

Supports large applications.

Separation of Concerns

Keeps responsibilities isolated.

Flexibility

Supports custom business requirements.

These benefits make custom middleware extremely powerful.

Common Mistakes to Avoid

Forgetting to Call next()

May stop pipeline execution unexpectedly.

Heavy Processing in Middleware

Can reduce performance.

Incorrect Middleware Order

May create functionality issues.

Logging Sensitive Data

Creates security risks.

Duplicating Existing Middleware Features

Increases maintenance effort.

Best Practices for Custom Middleware Development in ASP.NET Core

• Keep middleware focused on a single responsibility.
• Use dependency injection.
• Log meaningful information only.
• Avoid expensive operations.
• Create extension methods for registration.
• Handle exceptions properly.
• Test middleware independently.
• Follow clean architecture principles.

Interview Questions

What is Custom Middleware?

Custom Middleware is developer-created middleware that processes requests and responses.

What is RequestDelegate?

RequestDelegate represents the next middleware in the pipeline.

What is HttpContext?

HttpContext contains request and response information.

Why is next() important?

It forwards requests to the next middleware component.

What is Middleware Short-Circuiting?

Stopping pipeline execution before reaching subsequent middleware.

Why is Custom Middleware important?

It enables implementation of application-specific request processing logic.

Key Takeaways

• Custom Middleware extends ASP.NET Core request processing.
• Middleware contains constructors and InvokeAsync methods.
• RequestDelegate controls pipeline execution.
• HttpContext provides request and response access.
• Middleware can modify requests and responses.
• Extension methods simplify middleware registration.
• Custom Middleware Development in ASP.NET Core is essential for implementing reusable application-specific functionality.

Frequently Asked Questions (FAQs)

What is Custom Middleware in ASP.NET Core?

Custom Middleware is a developer-created component that processes HTTP requests and responses.

What is RequestDelegate?

RequestDelegate represents the next middleware in the request pipeline.

What is HttpContext?

HttpContext contains all information related to the current HTTP request and response.

What happens if next() is not called?

The middleware pipeline stops and subsequent middleware does not execute.

Why create custom middleware?

Custom middleware allows developers to implement custom business logic, logging, security, monitoring, and request processing features.

Why is Custom Middleware Development in ASP.NET Core important?

It provides flexibility, reusability, maintainability, and support for custom application requirements.

Internal Link

Click here for more free courses