ASP. Net 6 middleware series - conditional Middleware

This article is ASP.NET 6 Middleware family The second part of the article is 4 part .

up to now , We've already introduced it ASP.NET 6 The basics of middleware , Shows how to create a custom middleware class , The importance of middleware execution sequence is discussed .

In the last part of this series , We will show two ways to conditionally execute Middleware in a pipeline ：

1. use AppSettings.json Settings in file , To determine whether to add middleware to the pipeline ;

2. By using the data of the incoming request , Conditionally execute the middleware already in the pipeline .

be based on AppSettings Conditional Middleware

Let's review , In the last article TimeLoggingMiddleware class ：

using MiddlewareNET6Demo.Logging;
using System.Diagnostics;

namespace  MiddlewareNET6Demo.Middleware
{
    public  class  TimeLoggingMiddleware
    {
        private  readonly RequestDelegate _next;
        private  readonly ILoggingService _logger;

        public TimeLoggingMiddleware(RequestDelegate next, 
                                     ILoggingService logger)
        {
            _next = next;
            _logger = logger;
        }

        public async Task InvokeAsync(HttpContext context)
        {
            Stopwatch watch = new Stopwatch();
            watch.Start();

            await _next(context);

            watch.Stop();
            _logger.Log(LogLevel.Information, "Time to execute: " + watch.ElapsedMilliseconds + " milliseconds.");
        }
    }
}

Now? , We only hope that under certain conditions （ such as , When we're tracking a BUG, Or the application runs slowly ） Lower bound TimeLoggingMiddleware Add to application pipeline .

In order to conditionally add middleware to the pipeline , We can do it in AppSettings.json Set one in the file, which can be in Program.cs Fields read in .

stay AppSettings.json Add a file named MiddlewareSettings Configuration fields for , And one called UseTimeLoggingMiddleware Configuration item for ：

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "MiddlewareSettings": {
    "UseTimeLoggingMiddleware": "true",
  }
}

We also need a class to hold the values of these settings . As agreed , The class name should be the same as the configuration field name MiddlewareSettings matching , The attribute name should be the same as the configuration item name UseTimeLoggingMiddleware matching ：

namespace  MiddlewareNET6Demo
{
    public  class  MiddlewareSettings
    {
        public  bool UseTimeLoggingMiddleware { get; set; }
    }
}

then , stay Program.cs In file , We can read AppSettings.json That part of , And map it to MiddlewareSettings Class ：

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddRazorPages();
builder.Services.AddTransient<ILoggingService, LoggingService>();

var app = builder.Build();

var middlewareSettings = builder.Configuration.GetSection("MiddlewareSettings").Get<MiddlewareSettings>();

Only when middlewareSettings Example of UseTimeLoggingMiddleware The property value is true when , Only in this way can we TimeLoggingMiddleware Add to pipe ：

//...

if(middlewareSettings.UseTimeLoggingMiddleware)
    app.UseTimeLoggingMiddleware();
    
//...

In this way , According to the settings of the application , To control which middleware is active in the pipeline .

Based on the request URL Conditional Middleware

Another method may be deceptive , Because middleware is always added to the pipeline , But in addition to passing execution to the next middleware , Won't do anything else .

Suppose we have a new middleware class called CultureMiddleware:

using System.Globalization;

namespace  MiddlewareNET6Demo.Middleware
{
    public  class  CultureMiddleware
    {
        private  readonly RequestDelegate _next;

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

        public async Task InvokeAsync(HttpContext context)
        {
            var cultureQuery = context.Request.Query["culture"];
            if (!string.IsNullOrWhiteSpace(cultureQuery))
            {
                var culture = new CultureInfo(cultureQuery);

                CultureInfo.CurrentCulture = culture;
                CultureInfo.CurrentUICulture = culture;
            }
            await _next(context);
        }
    }
}

Please note that , The middleware exists only in incoming requests culture When requesting parameters , Will perform some practical work .

If this parameter exists , The middleware sets the current region of the application to the value of the incoming parameter .

for example , If we submit the following request ：

http://codeman.tech/post/123?culture=zh-CN

CultureMiddleware The region of the application is set to zh-CN, Then carry out other normal treatment .

If the incoming request is ：

http://codeman.tech/post/123

that , Middleware will do nothing , The area of the application is still the default .

This method of conditionally executing middleware , Than AppSettings.json The solution provides finer grained execution control , But the potential cost is always the need to add middleware to the pipeline .

With TimeLoggingMiddleware For example ：

If the incoming request contains a specific value , To perform TimeLoggingMiddleware Code for ;

stay MVC Applications , Maybe we just want to record the execution of a single controller ;

stay Razor Application , Maybe you just want to record the page with the problem ;

stay Web API in , Just one of the endpoints is a little slow .

In these cases , We can all use this method to TimeLoggingMiddleware Locate what we want to record .