Follow up - Making Redirects with more performant code

After yesterday's blog, I've had some really useful feedback from colleagues and Umbraco Community members and I thought I'd post the new improved code.

The first suggestion was to just use the generic ILogger rather than having the middleware dependent on Serilog logging. I had used Serilog because I thought, for some reason, the generic ILogger didn't save in to the logs in Umbraco. I was wrong and I've updated the code to reflect that.

Next up was about performance. It was suggested that I look at using a Lazy Property and I'll be honest, I've never heard of this before, so I asked Github Copilot to make my code more performant and here is what it suggested :

• Lazy Loading with Asynchronous Initialization

• Lazy<Task<ConcurrentDictionary<string, string>>> ensures that the redirects are loaded asynchronously and only when first needed.

• Concurrent Dictionary:

• ConcurrentDictionary<string, string> is used to ensure thread-safe access to the redirects.

• Asynchronous File I/O:

• await File.ReadAllLinesAsync(filePath) reads the file asynchronously to avoid blocking threads.

• Minimize Logging:

• Logging is kept to a minimum, and you can adjust the logging level based on the environment (e.g., more verbose in development, less in production).

Here is what the code now looks like :

using System.Collections.Concurrent;

namespace MySite.Web.Infrastructure.Middleware
{
	public class RedirectMiddleware
	{
		private readonly RequestDelegate _next;
		private readonly ILogger<RedirectMiddleware> _logger;
		private readonly Lazy<Task<ConcurrentDictionary<string, string>>> _redirects;

		public RedirectMiddleware(RequestDelegate next, ILogger<RedirectMiddleware> logger)
		{
			_next = next;
			_logger = logger;
			_redirects = new Lazy<Task<ConcurrentDictionary<string, string>>>(LoadRedirectsAsync);
		}

		public async Task InvokeAsync(HttpContext context)
		{
			var redirects = await _redirects.Value;

			if (redirects.TryGetValue(context.Request.Path.Value, out var targetUrl))
			{
				var queryString = context.Request.QueryString.ToString();
				if (!string.IsNullOrEmpty(queryString))
				{
					targetUrl = $"{targetUrl}{queryString}";
				}

				_logger.LogInformation($"Redirecting from {context.Request.Path} to {targetUrl}");
				context.Response.Redirect(targetUrl, true);
				return;
			}

			await _next(context);
		}

		private async Task<ConcurrentDictionary<string, string>> LoadRedirectsAsync()
		{
			var redirects = new ConcurrentDictionary<string, string>();
			var filePath = Path.Combine(Directory.GetCurrentDirectory(), "redirects.csv");

			if (File.Exists(filePath))
			{
				var lines = await File.ReadAllLinesAsync(filePath);
				foreach (var line in lines)
				{
					var parts = line.Split(',');
					if (parts.Length == 2)
					{
						redirects.TryAdd(parts[0].Trim(), parts[1].Trim());
					}
				}
			}

			return redirects;
		}
	}
}