load the assembly and get function address inside the domain

When using domain.Load for an assembly, the assembly resolution rules are awkward
Even if the full path is given to the AssemblyName, when the domain tries to load
the assembly, it does not use that context and tries to resolve the assembly using
normal domain resolution rules, which would require an assembly resolver to be
installed. However, the assembly resolver that is actually used at runtime is the
one installed to the main appdomain.

This prevents a library like Python.Runtime.dll (used by pythonnet) which
is not installed to the application base directory to be loaded by clr_loader.

To fix this issue, the assembly resolver of the main appdomain is lazily
extending to include paths needed for libraries passed into GetFunction,
and GetFunction internally uses AppDomain.DoCallBack() to marshal the
function pointer inside the target app domain, using global domain data
to access the function pointer and return it to the user of clr_loader.

Author: Mohamed Koubaa

netfx_loader/ClrLoader.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Reflection;
 using System.Runtime.InteropServices;
 using NXPorts.Attributes;
 
@@ -21,23 +22,35 @@ public static void Initialize()
             }
         }
 
+        private static string AssemblyDirectory
+        {
+            get
+            {
+                string codeBase = Assembly.GetExecutingAssembly().CodeBase;
+                UriBuilder uri = new UriBuilder(codeBase);
+                string path = Uri.UnescapeDataString(uri.Path);
+                return Path.GetDirectoryName(path);
+            }
+        }
+
         [DllExport("pyclr_create_appdomain", CallingConvention.Cdecl)]
         public static IntPtr CreateAppDomain(
             [MarshalAs(UnmanagedType.LPUTF8Str)] string name,
             [MarshalAs(UnmanagedType.LPUTF8Str)] string configFile
         )
         {
             Print($"Creating AppDomain {name} with {configFile}");
+
+            var clrLoaderDir = AssemblyDirectory;
             if (!string.IsNullOrEmpty(name))
             {
                 var setup = new AppDomainSetup
                 {
-                    ApplicationBase = AppDomain.CurrentDomain.BaseDirectory,
+                    ApplicationBase = clrLoaderDir,
                     ConfigurationFile = configFile
                 };
-                Print($"Base: {AppDomain.CurrentDomain.BaseDirectory}");
+                Print($"Base: {clrLoaderDir}");
                 var domain = AppDomain.CreateDomain(name, null, setup);
-
                 Print($"Located domain {domain}");
 
                 var domainData = new DomainData(domain);
@@ -61,8 +74,8 @@ public static IntPtr GetFunction(
             try
             {
                 var domainData = _domains[(int)domain];
-                var deleg = domainData.GetEntryPoint(assemblyPath, typeName, function);
-                return Marshal.GetFunctionPointerForDelegate(deleg);
+                Print($"Getting functor for function {function} of type {typeName} in assembly {assemblyPath}");
+                return domainData.GetFunctor(assemblyPath, typeName, function);
             }
             catch (Exception exc)
             {

netfx_loader/DomainData.cs

@@ -1,54 +1,94 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
+using System.Runtime.InteropServices;
 
 namespace ClrLoader
 {
     using static ClrLoader;
 
-    class DomainData : IDisposable
+    public static class DomainSetup
     {
         public delegate int EntryPoint(IntPtr buffer, int size);
+        public static void StoreFunctorFromDomainData()
+        {
+            var domain = AppDomain.CurrentDomain;
+            var assemblyPath = (string)domain.GetData("_assemblyPath");
+            var typeName = (string)domain.GetData("_typeName");
+            var function = (string)domain.GetData("_function");
+            var functor = GetFunctor(domain, assemblyPath, typeName, function);
+            domain.SetData("_thisFunctor", functor);
+        }
+
+        private static IntPtr GetFunctor(AppDomain domain, string assemblyPath, string typeName, string function)
+        {
+            var assemblyName = AssemblyName.GetAssemblyName(assemblyPath).Name;
+            var assembly = domain.Load(AssemblyName.GetAssemblyName(assemblyPath));
+            var type = assembly.GetType(typeName, throwOnError: true);
+            var deleg = Delegate.CreateDelegate(typeof(EntryPoint), type, function);
+            IntPtr result = Marshal.GetFunctionPointerForDelegate(deleg);
+            return result;
+        }
+    }
 
+    class DomainData : IDisposable
+    {
         bool _disposed = false;
 
         public AppDomain Domain { get; }
-        public Dictionary<(string, string, string), EntryPoint> _delegates;
+        public Dictionary<(string, string, string), IntPtr> _functors;
+        public HashSet<string> _resolvedAssemblies;
 
         public DomainData(AppDomain domain)
         {
             Domain = domain;
-            _delegates = new Dictionary<(string, string, string), EntryPoint>();
+            _functors = new Dictionary<(string, string, string), IntPtr>();
+            _resolvedAssemblies = new HashSet<string>();
         }
 
-        public EntryPoint GetEntryPoint(string assemblyPath, string typeName, string function)
+        private void installResolver(string assemblyPath)
+        {
+            var assemblyName = AssemblyName.GetAssemblyName(assemblyPath).Name;
+            if (_resolvedAssemblies.Contains(assemblyName))
+                return;
+            _resolvedAssemblies.Add(assemblyName);
+
+            AppDomain.CurrentDomain.AssemblyResolve += (sender, args) =>
+            {
+                if (args.Name.Contains(assemblyName))
+                    return Assembly.LoadFrom(assemblyPath);
+                return null;
+            };
+        }
+
+        public IntPtr GetFunctor(string assemblyPath, string typeName, string function)
         {
             if (_disposed)
                 throw new InvalidOperationException("Domain is already disposed");
 
-            var key = (assemblyPath, typeName, function);
+            installResolver(assemblyPath);
 
-            EntryPoint result;
+            var key = (assemblyPath, typeName, function);
 
-            if (!_delegates.TryGetValue(key, out result))
+            IntPtr result;
+            if (!_functors.TryGetValue(key, out result))
             {
-                var assembly = Domain.Load(AssemblyName.GetAssemblyName(assemblyPath));
-                var type = assembly.GetType(typeName, throwOnError: true);
+                Domain.SetData("_assemblyPath", assemblyPath);
+                Domain.SetData("_typeName", typeName);
+                Domain.SetData("_function", function);
 
-                Print($"Loaded type {type}");
-                result = (EntryPoint)Delegate.CreateDelegate(typeof(EntryPoint), type, function);
-
-                _delegates[key] = result;
+                Domain.DoCallBack(new CrossAppDomainDelegate(DomainSetup.StoreFunctorFromDomainData));
+                result = (IntPtr)Domain.GetData("_thisFunctor");
+                _functors[key] = result;
             }
-
             return result;
         }
 
         public void Dispose()
         {
             if (!_disposed)
             {
-                _delegates.Clear();
+                _functors.Clear();
 
                 if (Domain != AppDomain.CurrentDomain)
                     AppDomain.Unload(Domain);