17 March 2017
In .NET Core, middleware plays a crucial role in the request processing pipeline. Middleware is essentially a piece of code that is executed on each HTTP request in the pipeline before it reaches the endpoint (controller or action). It can be used to handle various tasks like logging, authentication, error handling, or even modifying the request or response. In this post, we’ll explore what middleware is, how it works in .NET Core, and how to create custom middleware for tasks like logging and error handling.
1. What Is Middleware in .NET Core?
Middleware is a concept borrowed from web application development frameworks that helps manage the HTTP request-response lifecycle. In .NET Core, middleware components are added to the request pipeline to handle requests before they reach your application’s endpoints, and to process the responses before they are returned to the client.
Each middleware component has access to the HTTP request and response, and it can choose to either:
- Process the request and pass it along the pipeline to the next middleware.
- Modify the request/response.
- End the request-response cycle (e.g., by returning a response directly without passing it to the next middleware).
Here’s a simple diagram to visualize how middleware works:
Request -> Middleware 1 -> Middleware 2 -> Middleware 3 -> Endpoint (Controller Action)
-> Response Middleware 3 -> Response Middleware 2 -> Response Middleware 1 -> Response
In .NET Core, middleware is executed in the order in which it’s added to the pipeline in the Configure method in the Startup.cs file.
2. Built-in Middleware in .NET Core
.NET Core comes with several built-in middleware components that handle common tasks:
- Routing Middleware: Directs requests to the appropriate controller or action.
- Static File Middleware: Serves static files (images, CSS, JavaScript).
- Authentication Middleware: Manages user authentication (e.g., cookie authentication, JWT).
- Authorization Middleware: Handles user authorization, enforcing access control.
- Exception Handling Middleware: Catches and handles errors that occur during request processing.
- Cors Middleware: Manages Cross-Origin Resource Sharing (CORS) to allow requests from different domains.
You can add these built-in middleware components to the pipeline using the Use methods in the Configure method of Startup.cs.
Example of adding built-in middleware:
public class Startup
{
public void Configure(IApplicationBuilder app)
{
// Use static files middleware to serve static content
app.UseStaticFiles();
// Use routing middleware to direct requests
app.UseRouting();
// Use authentication middleware
app.UseAuthentication();
// Use authorization middleware
app.UseAuthorization();
// Map controller actions to the routes
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
}
3. Creating Custom Middleware in .NET Core
Now, let’s look at how you can create custom middleware in .NET Core. Custom middleware can be created to handle things like logging, error handling, and other cross-cutting concerns. A custom middleware component is simply a class with a Invoke or InvokeAsync method that takes an HTTP context and calls the next middleware in the pipeline.
Here’s a step-by-step guide to creating custom middleware for logging requests in your .NET Core application:
Example: Creating a Custom Logging Middleware
- Create the custom middleware class:
public class RequestLoggingMiddleware
{
private readonly RequestDelegate _next;
// Constructor that accepts the next middleware in the pipeline
public RequestLoggingMiddleware(RequestDelegate next)
{
_next = next;
}
// Invoke method that will be called during the request processing
public async Task InvokeAsync(HttpContext context)
{
// Log request details (method and path)
Console.WriteLine($"Request Method: {context.Request.Method}, Request Path: {context.Request.Path}");
// Call the next middleware in the pipeline
await _next(context);
}
}
- Register the custom middleware in Startup.cs:
In the Configure method of Startup.cs, you can add your custom middleware to the pipeline using the Use method:
public class Startup
{
public void Configure(IApplicationBuilder app)
{
// Add the custom request logging middleware
app.UseMiddleware<RequestLoggingMiddleware>();
// Other built-in middleware
app.UseRouting();
// Map controller actions to the routes
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
}
This middleware logs the HTTP method (GET, POST, etc.) and the request path (URL) for every incoming request.
4. Error Handling Middleware
Custom middleware can also be used for error handling in .NET Core. For example, you can create middleware to handle unexpected exceptions and return a clean error response to the client.
Example: Creating Error Handling Middleware
public class ErrorHandlingMiddleware
{
private readonly RequestDelegate _next;
public ErrorHandlingMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
try
{
// Call the next middleware in the pipeline
await _next(context);
}
catch (Exception ex)
{
// Handle the error and return a custom error response
context.Response.StatusCode = 500;
await context.Response.WriteAsync($"Something went wrong: {ex.Message}");
}
}
}
In Startup.cs, register the custom error handling middleware like this:
public class Startup
{
public void Configure(IApplicationBuilder app)
{
// Add error handling middleware
app.UseMiddleware<ErrorHandlingMiddleware>();
// Other middleware
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
}
This middleware will catch any exceptions thrown during the request pipeline and return a 500 Internal Server Error response with a message.
5. Conclusion
In this post, we’ve covered middleware in .NET Core. You’ve learned:
- The concept of middleware and its role in the HTTP request pipeline.
- How to create custom middleware for tasks like logging and error handling.
- How to add and configure middleware in your .NET Core application.
Middleware is a powerful tool in .NET Core that allows you to handle various concerns in a modular way. As you continue developing your .NET Core applications, you’ll find middleware to be an essential component for building robust, maintainable, and scalable systems.
Happy coding!
