What is AssemblyLoadContext, and how do you build an unloadable plugin system with it?

How I would answer this in an interview

An AssemblyLoadContext (ALC) is a container for loaded assemblies that controls how dependencies are resolved and provides isolation (different versions of the same assembly can be loaded in different contexts). With isCollectible: true, an ALC and everything loaded into it can be unloaded. It's the modern replacement for AppDomains and the foundation for plugin systems. I'd explain the concepts, build a plugin host, and cover the unloading pitfalls.

1. Key concepts

• Every process has the default ALC (AssemblyLoadContext.Default) holding the app and framework.
• Custom ALCs override Load(AssemblyName) to decide where dependencies come from. Returning null delegates to the default context.
• Type identity includes the ALC: IPlugin loaded in the default ALC and IPlugin loaded in a plugin ALC are different types — casts fail. Shared contracts must be loaded once, from the default ALC.
• Collectible ALCs can be unloaded when no references to anything inside them remain.
• AssemblyDependencyResolver reads a plugin's .deps.json to resolve its managed and native dependencies.

2. The plugin contract

// Plugins.Abstractions.dll - referenced by host and plugins, loaded ONLY in the default ALC
public interface IReportPlugin
{
    string Name { get; }
    Task<byte[]> GenerateAsync(ReportRequest request, CancellationToken ct);
}

Plugin projects reference the contract with <Private>false</Private> / <ExcludeAssets>runtime</ExcludeAssets> so the contract DLL isn't copied into the plugin folder (avoids loading a second copy), and set <EnableDynamicLoading>true</EnableDynamicLoading> so their deps.json includes all dependencies.

3. The load context

public sealed class PluginLoadContext(string pluginPath) : AssemblyLoadContext(name: Path.GetFileNameWithoutExtension(pluginPath), isCollectible: true)
{
    private readonly AssemblyDependencyResolver _resolver = new(pluginPath);

    protected override Assembly? Load(AssemblyName name)
    {
        // Share contracts and framework with the host: let the default ALC resolve them
        if (name.Name is "Plugins.Abstractions") return null;

        var path = _resolver.ResolveAssemblyToPath(name);
        return path is not null ? LoadFromAssemblyPath(path) : null;   // plugin's own dependency versions
    }

    protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
    {
        var path = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
        return path is not null ? LoadUnmanagedDllFromPath(path) : IntPtr.Zero;
    }
}

4. Loading and using a plugin

public sealed class PluginHandle : IDisposable
{
    private PluginLoadContext? _context;
    public IReportPlugin Plugin { get; private set; }

    public PluginHandle(string pluginPath)
    {
        _context = new PluginLoadContext(pluginPath);
        var assembly = _context.LoadFromAssemblyPath(pluginPath);
        var type = assembly.GetTypes().Single(t => typeof(IReportPlugin).IsAssignableFrom(t) && !t.IsAbstract);
        Plugin = (IReportPlugin)Activator.CreateInstance(type)!;
    }

    public void Dispose()
    {
        Plugin = null!;
        _context?.Unload();     // starts unloading; completes when nothing references the ALC
        _context = null;
    }
}

typeof(IReportPlugin).IsAssignableFrom(t) works because the plugin's IReportPlugin resolves to the default context's contract (via Load returning null).

5. Unloading correctly

Unload() is cooperative: the ALC is collected only when no references remain to:

• objects created from plugin types (including via caches, DI containers, static fields in the host),
• Type, Assembly, MethodInfo objects from the plugin,
• delegates targeting plugin methods, event subscriptions (host events holding plugin handlers),
• threads running plugin code, timers, ThreadLocal, AsyncLocal values,
• GCHandles, native callbacks.

Verify unloading in tests:

[MethodImpl(MethodImplOptions.NoInlining)]
static WeakReference LoadAndUnload(string path)
{
    using var handle = new PluginHandle(path);
    handle.Plugin.Name.ToString();
    return new WeakReference(handle.Context);   // expose the ALC weakly
}

var weak = LoadAndUnload(path);
for (int i = 0; weak.IsAlive && i < 10; i++) { GC.Collect(); GC.WaitForPendingFinalizers(); }
Assert.False(weak.IsAlive);

Common leak sources: logging frameworks caching plugin types, System.Text.Json's metadata cache (call JsonSerializerOptions per plugin), TypeDescriptor caches, static event subscriptions, MVC application parts.

6. Limits

• Not a security sandbox — plugins run with full trust in-process. Untrusted code needs process/container isolation.
• Not available under NativeAOT (no runtime loading).
• Unloading is best-effort; complex frameworks may hold references.
• Native libraries loaded by plugins can't be unloaded reliably.

7. A production example

A reporting platform let customers upload report plugins. Initially all plugins loaded into the default ALC: two plugins needing different ClosedXML versions conflicted, and updating a plugin required restarting the service. Moving each plugin into a collectible PluginLoadContext with AssemblyDependencyResolver fixed the version conflicts and enabled hot reload. The first unload attempt leaked: the host's IMemoryCache held report definitions referencing plugin types. Scoping caches per plugin and clearing them before Unload(), verified with the weak-reference test, made unloading reliable.