Plugins on ZeroSharp

Replacing a class at runtime using Ninject and Roslyn - Part 4: Roslyn

Wed, 17 Sep 2014 08:08:00 +0100

This is the fourth and final part of a series about using Roslyn with dependency injection to create a flexible and powerful plug-in framework. Here I review the parts of the solution that deal with the Roslyn runtime compilation of plug-ins. Check out the working example on GitHub.

Previously

Roslyn

Let’s look at some of the main classes used to compile plug-in code at runtime.

Replacing a class at runtime using Ninject and Roslyn - Part 3: Dependency Injection

Mon, 15 Sep 2014 08:01:00 +0100

This is the third part of a series about using Roslyn with dependency injection to create a flexible and powerful plug-in framework. Here I review the parts of the solution that deal with dependency injection. Check out the working example on GitHub.

Previously

Dependency injection

The first trick is to use dependency injection to create any instance of the HelloWorldGenerator class. Then if we need to add a new dependency to the class, we can just add it to the constructor without breaking anything.

Replacing a class at runtime using Ninject and Roslyn - Part 2: The Solution

Thu, 11 Sep 2014 09:18:00 +0100

Previously: Part 1: The Goal

The solution

The code for the example is available on GitHub.

How it looks

So here’s the Hello World page in production:

We navigate to the plugins view and create a new replacement for the HelloWorldGenerator:

Without restarting, we can return to the HelloWorld page and see that the new class is being used because the output has changed.

If you delete the row from the plugins page, the behaviour reverts to the original implementation (the code that was originally shipped with production).

Replacing a class at runtime using Ninject and Roslyn - Part 1: The Goal

Tue, 09 Sep 2014 10:47:00 +0100

The goal

How can we replace a given class’s code with new code at runtime? In particular, how we can we do this while allowing dependency injection and sidestepping assembly versioning issues.

Let’s say you have bunch of classes like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class SomeGenerator : IGenerator
{
 public SomeGenerator(ISomeDependency dependency, IAnotherDependency another)
 {
 ...
 }

 public void Generate()
 {
 ...
 // generate some output
 }
}

Now let’s assume that you need the ability to modify the behaviour of these classes at runtime without upgrading. And change the dependencies. Without restarting the application.