Support pythonnet for AppDomain

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);