ASP.NET Core MVC from scratch to achieve plug-in development (c) - how to enable components at runtime

Title: (c) plug-in from scratch to achieve the development of ASP.NET Core MVC - how to enable components at runtime
Author: Lamond Lu
Address: https://www.cnblogs.com/lwqlun/p/11260750.html
source code : https://github.com/lamondlu/DynamicPlugins

Antecedent Review Review

• ASP.NET Core MVC from scratch to achieve the development of plug-in (a) - Use Application Part dynamic load controllers and views
• ASP.NET Core MVC from scratch to achieve the development of plug-in (two) - How to create a project template

In the previous two, I showed you how to use Application Part dynamic load controllers and views, as well as how to create a plug-in templates to simplify operation.
After the previous finish, I suddenly thought of a problem, if the plug-in to build a system that is designed like the first two, there will be a very serious problem, namely,

When you add a plug-in, the entire program can not immediately enable the plugin, restart only after the entire ASP.NET Core application, in order to correct load plugins. Because all plugins are loaded at program startup ConfigureServiceconfiguration method.

Plug-in system in this way will be difficult, we expect the effect of the dynamic enable and disable plug-ins at run time, then there is no solution? The answer is yes. Below it, step by step I will explain their ideas, problems encountered in coding, as well as solutions to these problems.

To accomplish this function, I take a lot of detours, the current program may not be the best, but really a viable option, if you have a better solution, we can discuss it.

Activation component in the Action

When confronted with this question, my first idea is to ApplicationPartManagerload the code to move to a plug-in library of the Action. So I created a primary site PluginsController, and enable added a program called EnableAction method.

public class PluginsController : Controller
{
    public IActionResult Enable()
    {
        var assembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "DemoPlugin1\\DemoPlugin1.dll");
        var viewAssembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "DemoPlugin1\\DemoPlugin1.Views.dll");
        var viewAssemblyPart = new CompiledRazorAssemblyPart(viewAssembly);

        var controllerAssemblyPart = new AssemblyPart(assembly);
        _partManager.ApplicationParts.Add(controllerAssemblyPart);
        _partManager.ApplicationParts.Add(viewAssemblyPart);

        return Content("Enabled");
    }
}

After modifying the code, run the program, where we first call /Plugins/Enableafter to try to activate components, active, we once again call/Plugin1/HelloWorld

Here you will find the program returns to 404, i.e., the view and the controller is not properly activated.

Here you may have a question, why would fail to activate it?

The reason here is that only when the ASP.NET Core application starts, will go to the assembly load controller and a view of ApplicationPart manager, although it is added to the new controller assembly at run-time ApplicationPartmanager, but ASP.NET Core will not automatically update, so here we need to find a way to let ASP.NET Core reload the controller method.

By querying all kinds of information, I finally found a starting point, there is in ASP.NET Core 2.2 is in a class ActionDescriptorCollectionProvider, its subclasses DefaultActionDescriptorCollectionProviderare used to configure the Controller and Action.

Source:

    internal class DefaultActionDescriptorCollectionProvider : ActionDescriptorCollectionProvider
    {
        private readonly IActionDescriptorProvider[] _actionDescriptorProviders;
        private readonly IActionDescriptorChangeProvider[] _actionDescriptorChangeProviders;
        private readonly object _lock;
        private ActionDescriptorCollection _collection;
        private IChangeToken _changeToken;
        private CancellationTokenSource _cancellationTokenSource;
        private int _version = 0;

        public DefaultActionDescriptorCollectionProvider(
            IEnumerable<IActionDescriptorProvider> actionDescriptorProviders,
            IEnumerable<IActionDescriptorChangeProvider> actionDescriptorChangeProviders)
        {
            ...
            ChangeToken.OnChange(
                GetCompositeChangeToken,
                UpdateCollection);
        }
       
        public override ActionDescriptorCollection ActionDescriptors
        {
            get
            {
                Initialize();

                return _collection;
            }
        }

        ...

        private IChangeToken GetCompositeChangeToken()
        {
            if (_actionDescriptorChangeProviders.Length == 1)
            {
                return _actionDescriptorChangeProviders[0].GetChangeToken();
            }

            var changeTokens = new IChangeToken[_actionDescriptorChangeProviders.Length];
            for (var i = 0; i < _actionDescriptorChangeProviders.Length; i++)
            {
                changeTokens[i] = _actionDescriptorChangeProviders[i].GetChangeToken();
            }

            return new CompositeChangeToken(changeTokens);
        }

        ...

        private void UpdateCollection()
        {
            lock (_lock)
            {
                var context = new ActionDescriptorProviderContext();

                for (var i = 0; i < _actionDescriptorProviders.Length; i++)
                {
                    _actionDescriptorProviders[i].OnProvidersExecuting(context);
                }

                for (var i = _actionDescriptorProviders.Length - 1; i >= 0; i--)
                {
                    _actionDescriptorProviders[i].OnProvidersExecuted(context);
                }
                
                var oldCancellationTokenSource = _cancellationTokenSource;
           
                _collection = new ActionDescriptorCollection(
                    new ReadOnlyCollection<ActionDescriptor>(context.Results),
                    _version++);

                _cancellationTokenSource = new CancellationTokenSource();
                _changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);

                oldCancellationTokenSource?.Cancel();
            }
        }
    }

• This ActionDescriptorsproperty is recorded when ASP.NET Core program starts, all matched to the Controller / Action set.
• UpdateCollection method to update the ActionDescriptorscollection.
• In the constructor we designed a trigger ChangeToken.OnChange(GetCompositeChangeToken,UpdateCollection). Here the program will monitor a Token object when the Token object is changed automatically trigger UpdateCollectionmethod.
• Here Token is a group IActionDescriptorChangeProvidercomposition obtained by the interface objects.

所以这里我们就可以通过自定义一个IActionDescriptorChangeProvider接口对象，并在组件激活方法Enable中修改这个接口Token的方式，使DefaultActionDescriptorCollectionProvider中的CompositeChangeToken发生变化，从而实现控制器的重新装载。

使用IActionDescriptorChangeProvider在运行时激活控制器

这里我们首先创建一个MyActionDescriptorChangeProvider类，并让它实现IActionDescriptorChangeProvider接口

    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);
        }
    }

然后我们需要在Startup.cs的ConfigureServices方法中，将MyActionDescriptorChangeProvider.Instance属性以单例的方式注册到依赖注入容器中。

    public void ConfigureServices(IServiceCollection services)
    {
        ...

        services.AddSingleton<IActionDescriptorChangeProvider>(MyActionDescriptorChangeProvider.Instance);
        services.AddSingleton(MyActionDescriptorChangeProvider.Instance);
        
        ...
    }

最后我们在Enable方法中通过两行代码来修改当前MyActionDescriptorChangeProvider对象的Token。

    public class PluginsController : Controller
    {
        public IActionResult Enable()
        {
            var assembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "DemoPlugin1\\DemoPlugin1.dll");
            var viewAssembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "DemoPlugin1\\DemoPlugin1.Views.dll");
            var viewAssemblyPart = new CompiledRazorAssemblyPart(viewAssembly);

            var controllerAssemblyPart = new AssemblyPart(assembly);
            _partManager.ApplicationParts.Add(controllerAssemblyPart);
            _partManager.ApplicationParts.Add(viewAssemblyPart);
            
            MyActionDescriptorChangeProvider.Instance.HasChanged = true;
            MyActionDescriptorChangeProvider.Instance.TokenSource.Cancel();

            return Content("Enabled");
        }
    }

修改代码之后重新运行程序，这里我们依然首先调用/Plugins/Enable，然后再次调用/Plugin1/Helloworld, 这时候你会发现Action被触发了，只是没有找到对应的Views。

如何解决插件的预编译Razor视图不能重新加载的问题？

通过以上的方式，我们终于获得了在运行时加载插件控制器程序集的能力，但是插件的预编译Razor视图程序集没有被正确加载，这就说明IActionDescriptorChangeProvider只会触发控制器的重新加载，不会触发预编译Razor视图的重新加载。ASP.NET Core只会在整个应用启动时，才会加载插件的预编译Razor程序集，所以我们并没有获得在运行时重新加载预编译Razor视图的能力。

针对这一点，我也查阅了好多资料，最终也没有一个可行的解决方案，也许使用ASP.NET Core 3.0的Razor Runtime Compilation可以实现，但是在ASP.NET Core 2.2版本，我们还没有获得这种能力。

为了越过这个难点，最终我还是选择了放弃预编译Razor视图，改用原始的Razor视图。

因为在ASP.NET Core启动时，我们可以在Startup.cs的ConfigureServices方法中配置Razor视图引擎检索视图的规则。

这里我们可以把每个插件组织成ASP.NET Core MVC中一个Area, Area的名称即插件的名称， 这样我们就可以将为Razor视图引擎的添加一个检索视图的规则，代码如下

    services.Configure<RazorViewEngineOptions>(o =>
    {
        o.AreaViewLocationFormats.Add("/Modules/{2}/{1}/Views/{0}" + RazorViewEngine.ViewExtension);
    });

这里{2}代表Area名称, {1}代表Controller名称, {0}代表Action名称。

这里Modules是我重新创建的一个目录，后续所有的插件都会放置在这个目录中。

同样的，我们还需要在Configure方法中为Area注册路由。

    app.UseMvc(routes =>
    {
        routes.MapRoute(
        name: "default",
        template: "{controller=Home}/{action=Index}/{id?}");

        routes.MapRoute(
        name: "default",
        template: "Modules/{area}/{controller=Home}/{action=Index}/{id?}");
    });

因为我们已经不需要使用Razor的预编译视图，所以Enable方法我们的最终代码如下

    public IActionResult Enable()
    {
        var assembly = Assembly.LoadFile(AppDomain.CurrentDomain.BaseDirectory + "Modules\\DemoPlugin1\\DemoPlugin1.dll");

        var controllerAssemblyPart = new AssemblyPart(assembly);
        _partManager.ApplicationParts.Add(controllerAssemblyPart);

        MyActionDescriptorChangeProvider.Instance.HasChanged = true;
        MyActionDescriptorChangeProvider.Instance.TokenSource.Cancel();

        return Content("Enabled");
    }

以上就是针对主站点的修改，下面我们再来修改一下插件项目。

首先我们需要将整个项目的Sdk类型改为由之前的Microsoft.Net.Sdk.Razor改为Microsoft.Net.Sdk.Web， 由于之前我们使用了预编译的Razor视图，所以我们使用了Microsoft.Net.Sdk.Razor，它会将视图编译为一个dll文件。但是现在我们需要使用原始的Razor视图，所以我们需要将其改为Microsoft.Net.Sdk.Web， 使用这个Sdk, 最终的Views文件夹中的文件会以原始的形式发布出来。

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>netcoreapp2.2</TargetFramework>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
    <OutputPath></OutputPath>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.App" Version="2.2.0" />
    <PackageReference Include="Microsoft.AspNetCore.Razor" Version="2.2.0" />
    <PackageReference Include="Microsoft.AspNetCore.Razor.Design" Version="2.2.0" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\DynamicPlugins.Core\DynamicPlugins.Core.csproj" />
  </ItemGroup>



</Project>

最后我们需要在Plugin1Controller上添加Area配置, 并将编译之后的程序集以及Views目录放置到主站点项目的Modules目录中

    [Area("DemoPlugin1")]
    public class Plugin1Controller : Controller
    {
        public IActionResult HelloWorld()
        {
            return View();
        }
    }

最终主站点项目目录结构

The files tree is:
=================

  |__ DynamicPlugins.Core.dll
  |__ DynamicPlugins.Core.pdb
  |__ DynamicPluginsDemoSite.deps.json
  |__ DynamicPluginsDemoSite.dll
  |__ DynamicPluginsDemoSite.pdb
  |__ DynamicPluginsDemoSite.runtimeconfig.dev.json
  |__ DynamicPluginsDemoSite.runtimeconfig.json
  |__ DynamicPluginsDemoSite.Views.dll
  |__ DynamicPluginsDemoSite.Views.pdb
  |__ Modules
    |__ DemoPlugin1
      |__ DemoPlugin1.dll
      |__ Views
        |__ Plugin1
          |__ HelloWorld.cshtml
        |__ _ViewStart.cshtml

现在我们重新启动项目，重新按照之前的顺序，先激活插件，再访问新的插件路由/Modules/DemoPlugin1/plugin1/helloworld， 页面正常显示了。

总结

本篇中，我为大家演示了如何在运行时启用一个插件，这里我们借助IActionDescriptorChangeProvider, 让ASP.NET Core在运行时重新加载了控制器，虽然不支持预编译Razor视图的加载，但是我们通过配置原始Razor视图加载的目录规则，同样实现了动态读取视图的功能。

下一篇我将继续将这个项目重构，编写业务模型，并尝试编写插件的安装以及升降级版本的代码。