Building simple plug-ins system for ASP.NET Core

Recently I built plug-ins support to my TemperatureStation IoT solution web site. The code for .NET Core is different from what we have seen on full .NET Framework (application domains etc) but there’s still nothing complex. This blog post describes how to build simple plug-ins support to ASP.NET Core web application.

After some searching in web and some small experimenting I came out with simple solution that covers the following:

1. Loading types from assemblies
2. Registering types automatically with built-in dependency injection
3. Getting instances through built-in dependency injection

The code shown here is also kind of experimental and it is taken from my open-source IoT solution called TemperatureStation.

Calculator plug-ins

TemperatureStation has plug-ins called Calculators. Calculators are classes that can be bound to measurements and when readings are reported then Calculators are run on readings. They provide different calculations like finding freezing point of liquid, estimating the time it takes for liquid to get to freezing point etc.

For calculators there is ICalculator interface shown below.

public interface ICalculator
{
    double Calculate(SensorReadings readings, Measurement measurement);
    string DisplayValue(double value);
    bool ReturnsReading { get; }
    void SetParameters(string parameters);
}

Calculators use CalculatorAttribute to define some metadata.

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
public class CalculatorAttribute : Attribute
{
    public CalculatorAttribute()
    {
        Order = -1;
        ShowOnChart = true;
    }
 
    public string Name { get; set; }
    public int Order { get; set; }
    public bool ShowOnChart { get; set; }
    public string DisplayLabel { get; set; }
}

And here is the example of dummy calculator.

public class DummyCalculator : ICalculator
{
    public bool ReturnsReading
    {
        get { return true; }
    }
 
    public double Calculate(SensorReadings readings, Measurement measurement)
    {
        return readings.Readings.First().Reading + 10f;
    }
 
    public string DisplayValue(double value)
    {
        return value.ToString();
    }
 
    public void SetParameters(string parameters)
    {
    }
}

Finding plug-in types

To detect plug-ins I wrote CalculatorsLoader class. This a static class that creates list of calculator types. Rule is simple: class must implement ICalculator interface and must have CalculatorAttribute. Consider this class as internal matter of application.

public static class CalculatorsLoader
{
    private static IList<Type> _calculatorTypes;
 
    public static IList<Type> CalculatorTypes
    {
        get
        {
            if(_calculatorTypes == null)
            {
                LoadCalculatorTypes();
            }
 
            return _calculatorTypes.ToList();
        }            
    }
 
    private static void LoadCalculatorTypes()
    {
        if (_calculatorTypes != null)
        {
            return;
        }
 
        var calcs = from a in GetReferencingAssemblies()
                    from t in a.GetTypes()
                    where t.GetTypeInfo().GetCustomAttribute<CalculatorAttribute>() != null
                          && t.GetTypeInfo().ImplementedInterfaces.Contains(typeof(ICalculator))
                    select t;
 
        _calculatorTypes = calcs.OrderBy(t => t.GetTypeInfo().GetCustomAttribute<CalculatorAttribute>().Order).ToList();
    }
 
    private static IEnumerable<Assembly> GetReferencingAssemblies()
    {
        var assemblies = new List<Assembly>();
        var dependencies = DependencyContext.Default.RuntimeLibraries;
 
        foreach (var library in dependencies)
        {
            try
            {
                var assembly = Assembly.Load(new AssemblyName(library.Name));
                assemblies.Add(assembly);
            }
            catch (FileNotFoundException)
            { }
        }
        return assemblies;
    }
}

Automatic registering of plug-in types

To use ASP.NET Core dependency injection I wrote class that provides extension method for IServiceCollection. Dependency injection is needed because Calculators may use constructor injection to access services and database.

public static class CalculatorExtensions
{
    public static void AddCalculators(this IServiceCollection services)
    {
        foreach(var calcType in CalculatorsLoader.CalculatorTypes)
        {
            services.AddTransient(calcType);
        }
    }
}

This is how to use AddCalculators extension method in Startup class of web application.

public void ConfigureServices(IServiceCollection services)
{
    // ...
 
    services.AddMvc();
 
    services.AddSingleton<ICalculatorProvider, CalculatorProvider>();
    services.AddCalculators();
 
    // ...
}

When web application starts then ConfigureServices method is called and Calculators are automatically registered.

Plug-in provider

To access calculators I wrote ICalculatorProvider interface and CalculatorProvider class. This class with CalculatorExtensions are the only classes that access CalculatorsLoader directly. All other classes in system use provider to query calcutor types. ICalculatorProvider is introduced to ASP.NET Core dependency injection in application Startup class.

GetCalculators() method uses framework level dependency injection to create instances of ICalculator.

public interface ICalculatorProvider
{
    IDictionary<string, ICalculator> GetCalculators();
    IEnumerable<string> GetNames();
    IEnumerable<Type> GetTypes();
}
 
public class CalculatorProvider : ICalculatorProvider
{
    private IServiceProvider _serviceProvider;
 
    public CalculatorProvider(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }
 
    public IDictionary<string,ICalculator> GetCalculators()
    {
        var result = new Dictionary<string, ICalculator>();
 
        foreach(var type in CalculatorsLoader.CalculatorTypes)
        {
            var calc = (ICalculator)_serviceProvider.GetService(type);
            var name = type.GetTypeInfo().GetCustomAttribute<CalculatorAttribute>().Name;
 
            result.Add(name, calc);
        }
 
        return result;
    }
 
    public IEnumerable<string> GetNames()
    {
        return CalculatorsLoader.CalculatorTypes
                .Select(t => t.GetTypeInfo().GetCustomAttribute<CalculatorAttribute>()?.Name)
                .Where(t => !string.IsNullOrWhiteSpace(t));            
    }
 
    public IEnumerable<Type> GetTypes()
    {
        return CalculatorsLoader.CalculatorTypes;
    }
}

Using plug-ins in code

Here is the example about how I use ICalculatorProvider in controller code to output the list of available calculators.

public class DummyController : Controller
{
    private ICalculatorProvider _calculatorProvider;
 
    public DummyController(ICalculatorProvider calculatorProvider)
    {
        _calculatorProvider = calculatorProvider;
    }
 
    public IActionResult GetCalculators()
    {
        var calculators = _calculatorProvider.GetCalculators();
        var output = "";
 
        foreach (var calculator in calculators)
        {
            output += calculator.Key + "\r\n";
        }
 
        return Content(output, "text/plain");
    }
}

The real usage in my solution is more complex but this example gives the point.

Wrapping up

On .NET Core things work a little bit differently compared to full .NET Framework. Although this solution is not perfect it was still pretty easy to find information and make code work. It was also easy to automatically register plug-in types with ASP.NET Core framework-level dependency injection and come out with simple classes that architecturally fit in to web application. For my IoT system this solution today is good enough to go with.