Cheap Windows Hosting Review

ASP.NET Tutorial: What is Middleware and Why Does it Matter?

Posted on by Pablo Francesco

In one line, I would sum up the necessity of middleware in.NET development as follows: By centralizing and standardizing cross-cutting issues, middleware eliminates the need to duplicate them in each controller or endpoint.

The ASP.NET middleware mental model This is how the core appears:

where middleware runs BEFORE and also AFTER the controller.

This allows us to centralize and standardize logic instead of repeating it in every controller.

Imagine life before middleware. I would need to perform the following actions inside my controller logic:

  • Log the request
  • Perform authentication checks
  • Add security headers to the response

The code in the controller would look like this:

public IActionResult GetUser()
{
    try
    {
        LogRequest();//log method

        if (!IsAuthenticated()) //authentication method
            return Unauthorized();

        var result = _service.GetUser();

        AddSecurityHeaders(); //add security header in response

        return Ok(result);
    }
    catch(Exception ex)
    {
        LogError(ex);
        return StatusCode(500);
    }
}

Now imagine we have many other controllers that also need to implement the same logic as previous controller

  • UserController
  • ProductController
  • OrderController
  • PaymentController
  • InvoiceController

This can lead to duplicated code, maintenance issues, and even missed logic in some controllers, such as forgetting a security check or logging.

To make it worse, as the system grows, we may need to add more features like traffic monitoring, IP blocking, caching, audit logging, and so on. Adding these changes to every controller would make maintenance extremely expensive and error-prone.

We can solve this problem by centralizing the code using middleware.

Instead of repeating logic in every controller, we create separate middleware components for each concern, such as logging, authentication, and adding security headers.

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;

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

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

        await _next(context);
    }
}
public class AuthenticationMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        if (!IsAuthenticated(context))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync(
                "Unauthorized");

            return;
        }

        await _next(context);
    }
}
public class SecurityHeaderMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task InvokeAsync(HttpContext context)
    {
        await _next(context);

        context.Response.Headers.Add(
            "X-Frame-Options",
            "DENY");
    }
}

And now, we can register our customized middleware in the program.cs

app.UseMiddleware<LoggingMiddleware>();

app.UseMiddleware<AuthenticationMiddleware>();

app.UseMiddleware<SecurityHeaderMiddleware>();

With this approach, we can centralize and standardize our logic. Logging and authentication are performed before the controller is called, and security headers can be added before the response is returned from the controller.

Another point I want to emphasize is built-in middleware. In my previous example, I created custom middleware for authentication, but in reality, .NET already provides built-in middleware for common concerns like this. We don’t need to reinvent the wheel — we can simply use the standard components provided by the framework.

So the pipeline should look like this:

app.UseAuthentication();
app.UseHttpLogging(); //this is for http logging,
//but for application logging we need to write a customize one

Middleware gives us a clean way to centralize and standardize cross-cutting logic, making our applications easier to maintain and scale. By moving shared concerns out of controllers, we keep our codebase simpler, more consistent, and less error-prone.

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 HostForLIFE.eu, 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 HostForLIFE.eu 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.

hostforlifebanner