Adding DbContext for list of context types at runtime-CodePudding

To implement a plug-in system in a AspNet Core Mvc app, I would like a non-generic method to add a data context from a list of assemblies loaded dynamically at runtime, taking a Type parameter like this:

    foreach(Type tp in pluginContexts)
    {
        services.AddDbContext(tp, options => ...);
    }

instead of the usual

    services.AddDbContext<PluginDataContext>(options => ...);

That's because for dynamically loaded assemblies, I can not provide the TContext type parameter to the AddDbContextPool method, since that's statically compiled and not available at compile time.

Background

This is for a larger Asp.Net Core MVC app. The plugins must be able to both access the main database of the overall app and a separate database of their own.

Plugin assemblies, containing domain code and their private database context are to be dropped in a specified directory. The main app loads the plugin assembly dynamically upon startup.

The way I am solving this now is to have each controller get the IConfiguration instance injected, obtain the appropriate connection string from the config, and the database context is instantiated in the controller. Not so nice but does work.

One can easily inject a general class into the Services collection with AddScoped<>, and then use it as a sort of ServiceLocator - however, that is considered an antipattern.

I looked into the source code for AddDbContext but honestly I am lost.

Is there any simple way to achieve this?

CodePudding user response：

Solved it by creating an extensibility point in the plugin assembly.

Define an interface in the main app, which all plugins must implement.

  public interface IPluginContextRegistration
  {
      void RegisterContext(ref IServiceCollection services, Action<DbContextOptionsBuilder> optionsAction);
      String GetDatabaseName();
  }

Create a class implementing this interface (in the plugin). It has access to the type of its private database context, thus can use the generic AddDbContext method:

   public class DatabaseRegistration : IPluginContextRegistration
   {
       public void RegisterContext(ref IServiceCollection services, Action<DbContextOptionsBuilder> optionsAction)
       {
           services.AddDbContext<Test1DbContext>(optionsAction);
       } 

       public String GetDatabaseName()
       {
           return "test-plugin-db";
       }
   }

Then in the main app ASP.Net Startup.cs file, add following code, which calls the RegisterContext() method for each plugin. For example, if you want to use Sql Server:

    void RegisterPluginDbContexts(ref IServiceCollection services, List<Assembly> assemblyList)
    {
        IEnumerable<IPluginContextRegistration> registrars = new List<IPluginContextRegistration>();
        foreach (Assembly assembly in assemblyList)
        {
            registrars = registrars.Concat(GetClassInstances<IPluginContextRegistration>(assembly));
        }
        foreach (var reg in registrars)
        {
            String name = reg.GetDatabaseName();
            String connStr = Configuration.GetConnectionString(name);
            reg.RegisterContext(ref services, options => options.UseSqlServer(connStr));
        }
    }

For completeness - the method "GetClassInstances" is just a helper method using Reflection to obtain an instance of classes implementing the specified interface.

So it's simple after all - no need for re-writing framework code .