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.



See also

6 thoughts on “Building simple plug-ins system for ASP.NET Core

  • Rick Hodder says:

    Hi,

    Great article – simple and easy to follow.

    To make things even clearer, you may want to add an example of the usage of the CalculatorAttribute on DummyCalculator

    [Calculator(DisplayLabel=”Dummy Freezing Point”]
    public class DummyCalculator : ICalculator

  • Antonio Neto says:

    Why not use an IoC fw?

  • Gunnar says:

    Antonio, the example here uses IoC in form of dependency injection. All Calculator plug-in types are registered with ASP.NET Core framework-level dependency injection and they are also created through framework-level dependency injection in code that uses these.

  • Cecil says:

    Nice write up. Thanks for sharing.

    Did you ever consider using MEF since it (well, parts of it) are available for .NET Core?

  • Gunnar says:

    Yes, MEF is also good but also “bigger” option. Currently I needed some good way of adding new plug-ins in same project but will move later to MEF or some similar component for sure.

  • […] Building simple plug-ins system for ASP.NET Core […]

Leave a Reply

Your email address will not be published. Required fields are marked *