mrdave1999 / cplugin.net Goto Github PK

Implementations:

• CPluginEnvConfiguration.GetPluginFiles
• CPluginJsonConfiguration.GetPluginFiles

This exception occurs when the Plugins key does not exist in a configuration file as a json or .env.
This behavior should be changed for two reasons:

• Violates the Principle of least astonishment. If the consumer does not want to load any plugins, then it should delete the configuration key, i.e. the Plugins key found in a configuration file and that's it.
  The expected behavior for the consumer is that no plugin is loaded, but the opposite happens: an exception is thrown.
  This surprises the consumer.
• As the consumer has been surprised, then should create the configuration key with an empty value. However, if the consumer uses a .json file as source, an exception will still be thrown if an empty array appears in the Plugins section.
  See issue #6

If the consumer forgets to add the Plugins key in the configuration file, then the expected behavior is that no plugins are loaded. This is not a bug.

This class allows to search for the subtypes that implement the contract from a plug-in.
It contains only one method:

public static class TypeFinder
{
   static IEnumerable<TSupertype> FindSubtypesOf<TSupertype>();
}

This method will search for classes that implement the contract specified by TSupertype (a generic parameter) and returns the instances that implement the contract.

Code:

Problem reproduction

Plugin project:

[assembly: Plugin(typeof(TestService))]

namespace MyPluginProject;

public class TestService(ILogger<TestService> logger) : ITestService
{
    public int Print()
    {
        logger.LogInformation("TestService Plugin");
        return 0;
    }
}

Host application

namespace MyHostApplication;

public class PluginStartup
{
    public void ConfigureServices(WebApplicationBuilder builder)
    {
        var envConfiguration = new CPluginEnvConfiguration();
        PluginLoader.Load(envConfiguration);
        var testServices = TypeFinder.FindSubtypesOf<ITestService>();
        foreach (ITestService testService in testServices)
            testService.Print();
    }
}

If the host application is executed, the code will fail with an exception, because the method called FindSubtypesOf uses Activator.CreateInstance and the TestService type is required to have a constructor without parameters in order to create the instance.

Solution proposal

Use the Microsoft.Extensions.DependencyInjection package to create the instances and resolve the dependencies of a service.
This solves the limitation of TypeFinder.FindSubtypesOf.

API proposal

public class PluginStartup
{
    public void ConfigureServices(WebApplicationBuilder builder)
    {
        var envConfiguration = new CPluginEnvConfiguration();
        PluginLoader.Load(envConfiguration);
        builder
          .Services
          .AddSubtypesOf<ITestService>(ServiceLifetime.Transient);
    }

    public void Configure(IApplicationBuilder app)
    {
        var testServices = app
            .Services
            .GetServices<ITestService>();

        foreach (ITestService testService in testServices)
            testService.Print();
    }
}

Given the following appsettings.json:

{
  "Plugins": [ ]
}

GetPluginFiles method throws an InvalidOperationException even though the section exists.
The exception should not happen because in reality the "section" does exist in the json file.

It is not necessary to interrupt the consumer's application for this case. The library can check if the file name has the extension .dll, if not, it adds it by default. This should be the behavior.

API documentation is published here: https://mrdave1999.github.io/CPlugin.Net/api/CPlugin.Net.html

This avoids copying the assemblies to the plugin output directory: