Default to creating dynamic assemblies in the ALC that loaded the first interface

Author: AArnott

docfx/docs/dynamicproxy.md

@@ -53,21 +53,24 @@ The dynamic proxy maintains the same async-only contract that is exposed by the
 
 ## AssemblyLoadContext considerations
 
-When in a .NET process with multiple <xref:System.Runtime.Loader.AssemblyLoadContext> instances, you should consider whether StreamJsonRpc is loaded in an <xref:System.Runtime.Loader.AssemblyLoadContext> that can load all the types required by the proxy interface.
+When in a .NET process with multiple <xref:System.Runtime.Loader.AssemblyLoadContext> (ALC) instances, you should consider whether StreamJsonRpc is loaded in an ALC that can load all the types required by the proxy interface.
 
-By default, StreamJsonRpc will generate dynamic proxies in the <xref:System.Runtime.Loader.AssemblyLoadContext> that StreamJsonRpc is loaded within.
-This means that if your own code is running in a different <xref:System.Runtime.Loader.AssemblyLoadContext> from StreamJsonRpc and ask for a proxy, the proxy may fail to activate from a type load failure even if your calling code *can* or has loaded that type.
-It might also manifest as an <xref:System.MissingMethodException> or <xref:System.InvalidCastException> due to types loading into multiple <xref:System.Runtime.Loader.AssemblyLoadContext> instances.
+By default, StreamJsonRpc will generate dynamic proxies in the ALC that the (first) interface requested for the proxy is loaded within.
+This is usually the right choice because the interface should be in an ALC that can resolve all the interface's type references.
+When you request a proxy that implements *multiple* interfaces, and if those interfaces are loaded in different ALCs, you *may* need to control which ALC the proxy is generated in.
+The need to control this may manifest as an <xref:System.MissingMethodException> or <xref:System.InvalidCastException> due to types loading into multiple ALC instances.
 
-In such cases, you may control the <xref:System.Runtime.Loader.AssemblyLoadContext> used to generate the proxy by surrounding your proxy request with a call to <xref:System.Runtime.Loader.AssemblyLoadContext.EnterContextualReflection*> (and disposal of its result).
+In such cases, you may control the ALC used to generate the proxy by surrounding your proxy request with a call to <xref:System.Runtime.Loader.AssemblyLoadContext.EnterContextualReflection*> (and disposal of its result).
 
-For example, you might use the following code when StreamJsonRpc is loaded into a different <xref:System.Runtime.Loader.AssemblyLoadContext> from your own code:
+For example, you might use the following code when StreamJsonRpc is loaded into a different ALC from your own code:
 
 ```cs
-IMyService proxy;
-using (AssemblyLoadContext.EnterContextualReflection(MethodBase.GetCurrentMethod()!.DeclaringType!.Assembly))
+// Whatever ALC can resolve *all* type references in *all* proxy interfaces.
+AssemblyLoadContext alc = AssemblyLoadContext.GetLoadContext(MethodBase.GetCurrentMethod()!.DeclaringType!.Assembly);
+IFoo proxy;
+using (AssemblyLoadContext.EnterContextualReflection(alc))
 {
-    proxy = jsonRpc.Attach<IMyService>();
+    proxy = (IFoo)jsonRpc.Attach([typeof(IFoo), typeof(IFoo2)]);
 }
 ```
 

src/StreamJsonRpc/ProxyGeneration.cs

@@ -111,6 +111,7 @@ internal static TypeInfo Get(Type contractInterface, ReadOnlySpan<Type> addition
             // Rpc interfaces must be sorted so that we implement methods from base interfaces before those from their derivations.
             SortRpcInterfaces(rpcInterfaces);
 
+            // For ALC selection reasons, it's vital that the *user's* selected interfaces come *before* our own supporting interfaces.
             Type[] proxyInterfaces = [.. rpcInterfaces.Select(i => i.Type), typeof(IJsonRpcClientProxy), typeof(IJsonRpcClientProxyInternal)];
             ModuleBuilder proxyModuleBuilder = GetProxyModuleBuilder(proxyInterfaces);
 
@@ -764,7 +765,11 @@ private static ModuleBuilder GetProxyModuleBuilder(Type[] interfaceTypes)
 #if NET
         // We have to key the dynamic assembly by ALC as well, since callers may set a custom contextual reflection context
         // that influences how the assembly will resolve its type references.
-        AssemblyLoadContext alc = AssemblyLoadContext.CurrentContextualReflectionContext ?? AssemblyLoadContext.GetLoadContext(typeof(ProxyGeneration).Assembly) ?? throw new Exception("No ALC for our own assembly!");
+        // If they haven't set a contextual one, we assume the ALC that defines the (first) proxy interface.
+        AssemblyLoadContext alc = AssemblyLoadContext.CurrentContextualReflectionContext
+            ?? AssemblyLoadContext.GetLoadContext(interfaceTypes[0].Assembly)
+            ?? AssemblyLoadContext.GetLoadContext(typeof(ProxyGeneration).Assembly)
+            ?? throw new Exception("No ALC for our own assembly!");
         foreach ((AssemblyLoadContext AssemblyLoadContext, ImmutableHashSet<AssemblyName> SkipVisibilitySet, ModuleBuilder Builder) existingSet in TransparentProxyModuleBuilderByVisibilityCheck)
         {
             if (existingSet.AssemblyLoadContext != alc)
@@ -787,7 +792,14 @@ private static ModuleBuilder GetProxyModuleBuilder(Type[] interfaceTypes)
         // I have disabled this optimization though till we need it since it would sometimes cover up any bugs in the above visibility checking code.
         ////skipVisibilityCheckAssemblies = skipVisibilityCheckAssemblies.Union(AppDomain.CurrentDomain.GetAssemblies().Select(a => a.GetName()));
 
-        AssemblyBuilder assemblyBuilder = CreateProxyAssemblyBuilder();
+        AssemblyBuilder assemblyBuilder;
+#if NET
+        using (alc.EnterContextualReflection())
+#endif
+        {
+            assemblyBuilder = CreateProxyAssemblyBuilder();
+        }
+
         ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("rpcProxies");
         var skipClrVisibilityChecks = new SkipClrVisibilityChecks(assemblyBuilder, moduleBuilder);
         skipClrVisibilityChecks.SkipVisibilityChecksFor(skipVisibilityCheckAssemblies);

test/StreamJsonRpc.Tests/JsonRpcProxyGenerationTests.cs

@@ -853,14 +853,8 @@ private static void DynamicAssembliesKeyedByAssemblyLoadContext_Helper()
         // that we can here (the ones from UnreachableAssembly).
         // That's what makes this test effective: it'll fail if the DynamicAssembly is shared across ALCs,
         // thereby verifying that StreamJsonRpc has a dedicated set of DynamicAssemblies for each ALC.
-        // We have to manually set the contextual reflection context to this special ALC
-        // so that StreamJsonRpc knows to get the DynamicAssembly for this ALC.
-        // Otherwise it will default to its own.
-        using (AssemblyLoadContext.EnterContextualReflection(MethodBase.GetCurrentMethod()!.DeclaringType!.Assembly))
-        {
-            JsonRpc clientRpc = new(Stream.Null);
-            clientRpc.Attach<IReferenceAnUnreachableAssembly>();
-        }
+        JsonRpc clientRpc = new(Stream.Null);
+        clientRpc.Attach<IReferenceAnUnreachableAssembly>();
     }
 
 #endif