Isolation of static member variables in AssemblyLoadContext

[msedi]

In my framework I currently have a static logger class Logger that has a static list of log messages. The framework is using plugins that can run independently. To have the possibility of completely unloading the plugins I now need to use the AssemblyLoadContext and I thought that it is a complete isolation of the plugin from the host application. Additionally I want to have the logs from the host application and the logs from the plugin separated into different log files.

But this seems not to be the case as the static members of my logger class seem to be shared.

Imagine I have a Logger class

public static class Logger
{
  private static readonly List<string> _messages = new();
  
  private static void Log(string message)
  {
    _messages.Add(message);
  }
}

and a plugin (in Plugin.dll)

public class  Plugin
{
  private void Run()
  {
    Logger.Log("Plugin")
  }
}

and the plugin is create like this

public static void Main()
{
  Logger.Log("Main");

  AssemblyLoadContext ctx = new("PluginLoader", true);
  var assembly = ctx.LoadFromAssemblyPath("Plugin.dll");

  Plugin plugin = assembly.CreateInstance("Plugin", false, BindingFlags.Default, null, null, null, null) as Plugin;
  plugin.Run();
}

Logger does now contain two entries (Main and Plugin).
Is there any way to get around this? Btw: I'm using NLog not my own solution. This is just to show what happens.

[PathogenDavid]

You need to explicitly load the logging framework into the PluginLoader context, otherwise it uses the already-loaded assembly from the main context.

[msedi]

@PathogenDavid: Thanks for the hint. While reading through the docs it I'm not sure if it is even possible what I want to achieve:

There's no binary isolation between these dependencies. They're only isolated by not finding each other by name.

As you suggested I have tried to load the static logger class into the plugins' AssemblyLoadContext but even the static constructor of my logger class wasn't called. Sure, there is a difference between AppDomains and AssemblyLoadContext, but it seems to me that the AppDomain have a stronger/better isolation, which is good or bad ;-)

Or am I doing something wrong?

[PathogenDavid]

Unless I'm misunderstanding what you're trying to accomplish, I think you're doing something wrong.

Make sure you're loading the logger assembly into the plugin context before the plugin assembly to make sure the plugin doesn't get a chance to bind to the logger from the default context.

Here's a quick and dirty demo with two contexts (the default one and a secondary one) each with their own copy of a static logger class: https://github.com/PathogenPlayground/Runtime69899

As you can see in the output below, the static constructor for Logger is being called twice, once for each context:

Logger initialized for context 'Default'
Message logged from context 'Default': 'Hello from main!'
Logger initialized for context 'PluginLoader'
Message logged from context 'PluginLoader': 'Hello from plugin!'

All messages from the default context's logger:
- Hello from main!

[msedi]

@PathogenDavid: Awesome. Thanks for working out the demo. I see what you are doing ;-) but it seems that doing it so by loading the static class into the ALC the dependencies are getting too complicated and types get mixed up. Nevertheless thanks a lot for your help.