Net4x.AppDomain 2.0.0

Net4x.AppDomain

Classic AppDomain isolation for .NET Standard 2.0 and .NET 8+, where each domain is a real operating-system process and cross-domain calls travel over Net4x.Runtime.Remoting.

Isolation is stronger than a .NET Framework application domain ever provided: a child that stack-overflows, corrupts native memory, or calls Environment.FailFast cannot bring the parent down.

Quick start

using System;                       // the extensions live in System — no extra using needed

var domain = AppDomain.CurrentDomain.CreateChildDomain("worker");

var worker = domain.CreateInstanceAndUnwrap<Worker>();
Console.WriteLine(worker.ProcessId);          // a different process id
Console.WriteLine(worker.Compute(21));

domain.Unload();                              // or: using var domain = ...

The worker is an ordinary MarshalByRefObject. Members must be virtual so calls can be intercepted — if one is not, domain creation fails and tells you which:

public class Worker : MarshalByRefObject
{
    public virtual int Compute(int x) => x * 2;
    public virtual int ProcessId => Environment.ProcessId;
}

Migrating from classic AppDomain

C# has no static extension methods, so the two statics change; everything else keeps its name.

// before                                     after
AppDomain.CreateDomain("worker")              AppDomain.CurrentDomain.CreateChildDomain("worker")
AppDomain.Unload(domain)                      domain.Unload()

// unchanged
domain.CreateInstanceAndUnwrap(asm, type)
domain.DoCallBack(SomeStaticMethod)
domain.SetData("k", v) / domain.GetData("k")
domain.FriendlyName / domain.BaseDirectory / domain.IsDefaultAppDomain()

AppDomainSetup becomes AppDomainSetup2 (the platform owns the original name on .NET 8), keeping the classic property names plus process-specific ones:

var setup = new AppDomainSetup2
{
    ApplicationBase = @"C:\plugins\acme",
    PrivateBinPath  = "lib",
    StartupTimeout  = TimeSpan.FromSeconds(30),
};
setup.InitialData["tenant"] = "acme";

using var domain = AppDomain.CurrentDomain.CreateChildDomain("acme-plugin", setup);

Members that could not keep their signature

Assembly, AppDomainSetup and evidence cannot cross a process boundary.

Classic properties with no meaning off .NET Framework — ShadowCopyFiles, LoaderOptimization, evidence, permission sets — are deliberately not declared. A setting that silently does nothing is worse than a compile error.

Callbacks and events

domain.DoCallBack(Plugin.Initialize);            // runs in the child

domain.AssemblyResolve += (d, request) =>        // child could not resolve something
    AssemblyResolveResponse.FromPath(Locate(request.Name));

domain.UnhandledException += (s, e) => Log(e.ExceptionText);
domain.OutputReceived    += (s, e) => Log(e.Line);
domain.DomainUnloaded    += (s, e) => Log("domain gone");

DoCallBack requires a static method, or an instance method on a MarshalByRefObject. A lambda capturing local state compiles to a closure with no identity the child can reach, and is rejected rather than silently running in the wrong process.

Lifetime

Unload() asks the domain to exit, then kills it after UnloadTimeout. Calls into an unloaded or crashed domain throw AppDomainUnloadedException. A child watches its parent and exits if the parent dies, so a crashed parent leaves no orphans. ChildAppDomain is IDisposable.

Requirements and caveats

The package ships a host program under tools/net8.0 which is launched per domain, normally through the dotnet muxer. If the parent is self-contained or single-file and the muxer cannot be found, point AppDomainSetup2.HostExecutable at a host executable directly; the error message lists everywhere it looked.

Domains communicate over loopback TCP on an ephemeral port, bound to 127.0.0.1 and reached through unguessable capability URIs. That is hardening, not a security boundary — another process running as the same user can reach a domain. Do not use domains to isolate code you do not trust.

A domain costs roughly 50–100 ms to start, against about 1 ms for a real application domain. Pool and reuse domains rather than creating one per unit of work.