How to dynamically add a controller in a ASP.NET Core 6 MVC application

I need to dynamically creates controllers in a ASP.NET Core 6 MVC application.

I found some way to somewhat achieve this but not quite.

I'm able to dynamically add my controller but somehow it reflects only on the second request.

So here is what I do: first I initialize my console app as follows:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Mvc.ApplicationParts;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Mvc.Infrastructure;

namespace DynamicControllerServer
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            builder.Services.AddControllers();

            ApplicationPartManager partManager = builder.Services.AddMvc().PartManager;

            // Store thePartManager in my Middleware to be able to add controlelr after initialization is done
            MyMiddleware._partManager = partManager;

            // Register controller change event
            builder.Services.AddSingleton<IActionDescriptorChangeProvider>(MyActionDescriptorChangeProvider.Instance);
            builder.Services.AddSingleton(MyActionDescriptorChangeProvider.Instance);

            var app = builder.Build();

            app.UseAuthorization();
            app.MapControllers();

            // Add Middleware which is responsible to cactn the request and dynamically add the missing controller
            app.UseMiddleware<MyMiddleware>();

            app.RunAsync();

            Console.WriteLine("Server has been started successfully ...");

            Console.ReadLine();
        }
    }
}

Then my middleware looks like this: it basically detects that there is the "dynamic" keyword in the url. If so, it will load the assembly containing the DynamicController:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.ApplicationParts;
using System;
using System.Reflection;

namespace DynamicControllerServer
{
    public class MyMiddleware
    {
        public RequestDelegate _next { get; }
        private string dllName = "DynamicController1.dll";
        static public ApplicationPartManager _partManager = null;

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

        public async Task Invoke(HttpContext httpContext)
        {

            if (httpContext.Request.Path.HasValue)
            {
                var queryParams = httpContext.Request.Path.Value;
                if(httpContext.Request.Path.Value.Contains("api/dynamic"))
                {
                    // Dynamically load assembly 
                    Assembly assembly = assembly = Assembly.LoadFrom(@"C:\Temp\" + dllName);

                    // Add controller to the application
                    AssemblyPart _part = new AssemblyPart(assembly);
                    _partManager.ApplicationParts.Add(_part);

                    // Notify change
                    MyActionDescriptorChangeProvider.Instance.HasChanged = true;
                    MyActionDescriptorChangeProvider.Instance.TokenSource.Cancel();
                }
            }

            await _next(httpContext); // calling next middleware

        }
    }
}

The ActionDescriptorChange provider looks like this:

using Microsoft.AspNetCore.Mvc.Infrastructure;
using Microsoft.Extensions.Primitives;

namespace DynamicControllerServer
{
    public class MyActionDescriptorChangeProvider : IActionDescriptorChangeProvider
    {
        public static MyActionDescriptorChangeProvider Instance { get; } = new MyActionDescriptorChangeProvider();

        public CancellationTokenSource TokenSource { get; private set; }

        public bool HasChanged { get; set; }

        public IChangeToken GetChangeToken()
        {
            TokenSource = new CancellationTokenSource();
            return new CancellationChangeToken(TokenSource.Token);
        }
    }
}

Dynamic controller is in separate dll and is very simple:

using Microsoft.AspNetCore.Mvc;

namespace DotNotSelfHostedOwin
{
    [Route("api/[controller]")]
    [ApiController]
    public class DynamicController : ControllerBase
    {
        public string[] Get()
        {
            return new string[] { "dynamic1", "dynamic1", DateTime.Now.ToString() };
        }
    }
}

Here are the packages used in that project:

<PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
<PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />

This works "almost" fine ... when first request is made to:

https://localhost:5001/api/dynamic

then it goes in the middleware and load the assembly, but returns a 404 error.

Then second request will actually work as expected:

Second request returns the expected result:

I must doing it wrong and probably my middleware is executed too late in the flow to reflect the dynamic controller right away.

Question is: what should be the proper way to achieve this?

Second question I have is say now the external dll holding our dynamic controller is updated.

How can I reload that controller to get the new definition?

Any help would be appreciated

Thanks in advance

Nick