Merge pull request #48 from FabianTerhorst/dev

Improve assembly execution and loading

Author: FabianTerhorst

api/AltV.Net.Async/AltV.Net.Async.csproj

@@ -12,10 +12,9 @@
         <RepositoryUrl>https://github.com/altmp-csharp/docs</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <PackageTags>altv gta bridge</PackageTags>
-        <PackageVersion>1.13.1-alpha</PackageVersion>
+        <PackageVersion>1.13.1</PackageVersion>
         <PackageLicenseFile>license.txt</PackageLicenseFile>
-        <PackageReleaseNotes>Add IScript for automatically loading scripts that contains Events and ScriptEvents
-Update dependencies</PackageReleaseNotes>
+        <PackageReleaseNotes>Fix multi async resources</PackageReleaseNotes>
     </PropertyGroup>
 
     <ItemGroup>

api/AltV.Net.Async/AltVAsync.cs

@@ -13,7 +13,11 @@ internal class AltVAsync
         public AltVAsync(ITickSchedulerFactory tickSchedulerFactory)
         {
             mainThread = Thread.CurrentThread;
-            mainThread.Name = "main";
+            if (mainThread.Name == "")
+            {
+                mainThread.Name = "main";
+            }
+
             scheduler = tickSchedulerFactory.Create(mainThread);
             taskFactory = new TaskFactory(
                 CancellationToken.None, TaskCreationOptions.DenyChildAttach,

api/AltV.Net.Example/AltV.Net.Example.csproj

@@ -31,7 +31,8 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="MySqlConnector" Version="0.49.3" />
+      <PackageReference Include="MySql.Data" Version="8.0.17" />
+      <PackageReference Include="System.Data.SqlClient" Version="4.7.0-preview8.19405.3" />
     </ItemGroup>
 
     <Target Name="CopyFiles" AfterTargets="build">

api/AltV.Net.Host/Host.cs

@@ -3,25 +3,56 @@
 using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Threading;
 
 namespace AltV.Net.Host
 {
     public class Host
     {
-        private static IDictionary<string, ResourceAssemblyLoadContext> _loadContexts =
+        private static readonly IDictionary<string, ResourceAssemblyLoadContext> _loadContexts =
             new Dictionary<string, ResourceAssemblyLoadContext>();
 
+        private const string DllName = "csharp-module";
+        private const CallingConvention NativeCallingConvention = CallingConvention.Cdecl;
+
+        internal delegate int CoreClrDelegate(IntPtr args, int argsLength);
+
+        [DllImport(DllName, CallingConvention = NativeCallingConvention)]
+        internal static extern void CoreClr_SetResourceLoadDelegates(CoreClrDelegate resourceExecute,
+            CoreClrDelegate resourceExecuteUnload);
+
+        private static CoreClrDelegate _executeResource;
+
+        private static CoreClrDelegate _executeResourceUnload;
+
         /// <summary>
         /// Main is present to execute the dll as a assembly
         /// </summary>
-        static void Main()
+        static int Main(string[] args)
         {
-            //TODO: init stuff we need
-            Console.WriteLine("Init host");
+            var semaphore = new Semaphore(0, 1);
+            SetDelegates();
+            semaphore.WaitOne();
+            return 0;
+        }
+
+        public static int Main2(IntPtr arg, int argLength)
+        {
+            SetDelegates();
+            return 0;
+        }
+
+        private static void SetDelegates()
+        {
+            _executeResource = ExecuteResource;
+            GCHandle.Alloc(_executeResource);
+            _executeResourceUnload = ExecuteResourceUnload;
+            GCHandle.Alloc(_executeResourceUnload);
+            CoreClr_SetResourceLoadDelegates(_executeResource, _executeResourceUnload);
         }
 
         private static string GetPath(string resourcePath, string resourceMain) =>
-            $"{resourcePath}/{resourceMain}";
+            $"{resourcePath}{Path.DirectorySeparatorChar}{resourceMain}";
 
         [StructLayout(LayoutKind.Sequential)]
         public struct LibArgs
@@ -56,6 +87,8 @@ public static int ExecuteResource(IntPtr arg, int argLength)
             var resourceAssemblyLoadContext =
                 new ResourceAssemblyLoadContext(resourceDllPath, resourcePath, resourceName);
 
+            _loadContexts[resourceDllPath] = resourceAssemblyLoadContext;
+
             Assembly resourceAssembly;
 
             try
@@ -65,21 +98,18 @@ public static int ExecuteResource(IntPtr arg, int argLength)
             catch (FileLoadException e)
             {
                 Console.WriteLine($"Threw a exception while loading the assembly \"{resourceDllPath}\": {e}");
-                resourceAssembly = null;
+                return 1;
             }
 
             var altVNetAssembly = resourceAssemblyLoadContext.LoadFromAssemblyName(new AssemblyName("AltV.Net"));
             foreach (var type in altVNetAssembly.GetTypes())
             {
-                if (type.Name == "ModuleWrapper")
-                {
-                    type.GetMethod("MainWithAssembly", BindingFlags.Public | BindingFlags.Static)?.Invoke(null,
-                        new object[] {libArgs.ServerPointer, libArgs.ResourcePointer, resourceAssemblyLoadContext});
-                }
+                if (type.Name != "ModuleWrapper") continue;
+                type.GetMethod("MainWithAssembly", BindingFlags.Public | BindingFlags.Static)?.Invoke(null,
+                    new object[] {libArgs.ServerPointer, libArgs.ResourcePointer, resourceAssemblyLoadContext});
+                break;
             }
 
-            _loadContexts[resourceDllPath] = resourceAssemblyLoadContext;
-
             return 0;
         }
 
@@ -97,7 +127,14 @@ public static int ExecuteResourceUnload(IntPtr arg, int argLength)
             var resourceDllPath = GetPath(resourcePath, resourceMain);
 
             if (!_loadContexts.Remove(resourceDllPath, out var loadContext)) return 1;
+            var loadContextWeakReference = new WeakReference(loadContext);
             loadContext.Unload();
+            for (var i = 0; loadContextWeakReference.IsAlive && (i < 10); i++)
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            }
+
             return 0;
         }
     }

api/AltV.Net.Host/ResourceAssemblyLoadContext.cs

@@ -9,56 +9,51 @@ public class ResourceAssemblyLoadContext : AssemblyLoadContext
     {
         private readonly AssemblyDependencyResolver resolver;
 
-        private readonly string resourcePath;
-
         public ResourceAssemblyLoadContext(string resourceDllPath, string resourcePath, string resourceName) : base(resourceName,
             true)
         {
             resolver = new AssemblyDependencyResolver(resourceDllPath);
-            this.resourcePath = resourcePath;
+            Resolving += (context, assemblyName) =>
+            {
+                var dllPath = resourcePath + Path.DirectorySeparatorChar + assemblyName.Name;
+                if (!File.Exists(dllPath)) return null;
+                try
+                {
+                    return LoadFromAssemblyPath(dllPath);
+                }
+                catch (Exception exception)
+                {
+                    Console.WriteLine(exception);
+                }
+
+                return null;
+            };
+            ResolvingUnmanagedDll += (assembly, unmanagedDllName) =>
+            {
+                var dllPath = resourcePath + Path.DirectorySeparatorChar + unmanagedDllName;
+                if (!File.Exists(dllPath)) return IntPtr.Zero;
+                try
+                {
+                    return LoadUnmanagedDllFromPath(dllPath);
+                }
+                catch (Exception exception)
+                {
+                    Console.WriteLine(exception);
+                }
+
+                return IntPtr.Zero;
+            };
         }
 
         protected override Assembly Load(AssemblyName assemblyName)
         {
             var assemblyPath = resolver.ResolveAssemblyToPath(assemblyName);
-            if (assemblyPath == null)
-            {
-                var dllPath = resourcePath + Path.DirectorySeparatorChar + assemblyName.Name;
-                if (File.Exists(dllPath))
-                {
-                    try
-                    {
-                        return LoadFromAssemblyPath(dllPath);
-                    }
-                    catch (Exception exception)
-                    {
-                        Console.WriteLine(exception);
-                    }
-                }
-            }
             return assemblyPath != null ? LoadFromAssemblyPath(assemblyPath) : null;
         }
 
         protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
         {
             var libraryPath = resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
-
-            if (libraryPath == null)
-            {
-                var dllPath = resourcePath + Path.DirectorySeparatorChar + unmanagedDllName;
-                if (File.Exists(dllPath))
-                {
-                    try
-                    {
-                        return LoadUnmanagedDllFromPath(dllPath);
-                    }
-                    catch (Exception exception)
-                    {
-                        Console.WriteLine(exception);
-                    }
-                }
-            }
-
             return libraryPath != null ? LoadUnmanagedDllFromPath(libraryPath) : IntPtr.Zero;
         }
     }

api/AltV.Net.Mock/AltV.Net.Mock.csproj

@@ -11,7 +11,7 @@
         <RepositoryUrl>https://github.com/altmp-csharp/docs</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <PackageTags>altv gta bridge mock</PackageTags>
-        <PackageVersion>1.13.1-alpha</PackageVersion>
+        <PackageVersion>1.13.0</PackageVersion>
         <PackageLicenseFile>license.txt</PackageLicenseFile>
         <PackageReleaseNotes>Update dependencies</PackageReleaseNotes>
     </PropertyGroup>

api/AltV.Net/AltV.Net.csproj

@@ -13,21 +13,9 @@
         <RepositoryUrl>https://github.com/altmp-csharp/docs</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <PackageTags>altv gta bridge</PackageTags>
-        <PackageVersion>1.13.1-alpha</PackageVersion>
+        <PackageVersion>1.13.0</PackageVersion>
         <PackageLicenseFile>license.txt</PackageLicenseFile>
-        <PackageReleaseNotes>Add to IVehicle
-```csharp
-byte Livery { get; set; }
-byte RoofLivery { get; set; }
-float LightsMultiplier { get; set; }
-```
-Add to IServer
-```csharp
-int NetTime { get; }
-```
-Improve meta data's
-Rewrite entity handling
-Add DegreeRotation and optimize position distance calculation</PackageReleaseNotes>
+        <PackageReleaseNotes></PackageReleaseNotes>
     </PropertyGroup>
 
     <ItemGroup>

api/AltV.Net/ModuleWrapper.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.Loader;
 using AltV.Net.Elements.Args;
@@ -46,7 +45,6 @@ public static void MainWithAssembly(IntPtr serverPointer, IntPtr resourcePointer
             }
 
             MainWithResource(serverPointer, resourcePointer, resource, assemblyLoadContext);
-            //TODO: set delegates here
             _scripts = AssemblyLoader.FindAllTypes<IScript>(assemblyLoadContext.Assemblies);
             _module.OnScriptsLoaded(_scripts);
             ResourceBuilder.SetDelegates(resourcePointer, OnStartResource);
@@ -55,7 +53,6 @@ public static void MainWithAssembly(IntPtr serverPointer, IntPtr resourcePointer
         public static void MainWithResource(IntPtr serverPointer, IntPtr resourcePointer, IResource resource,
             AssemblyLoadContext assemblyLoadContext)
         {
-            Console.WriteLine("before resource:" + (_resource == null));
             _resource = resource;
             if (_resource == null)
             {

runtime/include/CoreClr.h

@@ -14,6 +14,18 @@
 
 #endif
 
+#ifdef _WIN32
+
+#define EXPORT EXTERN __declspec(dllexport)
+#define IMPORT EXTERN __declspec(dllimport)
+
+#else
+
+#define EXPORT EXTERN __attribute__ ((visibility ("default")))
+#define IMPORT
+
+#endif // _WIN32
+
 #include <coreclr/hostfxr.h>
 #include <coreclr/coreclr_delegates.h>
 
@@ -87,6 +99,10 @@ int tail_gt(char* lhs, char* rhs);
 typedef void (* ExecuteResourceDelegate_t)(const char* resourcePath, const char* resourceName, const char* resourceMain,
                                            int resourceIndex);
 
+typedef int (* CoreClrDelegate_t)(void* args, int argsLength);
+
+#include <thread>
+
 class CoreClr {
 public:
     CoreClr(alt::IServer* server);
@@ -118,22 +134,21 @@ class CoreClr {
      */
     bool PrintError(alt::IServer* server, int errorCode);
 
-    void CreateManagedHost(alt::IServer* server);
+    void CreateManagedHost();
 
     void ExecuteManagedResource(alt::IServer* server, const char* resourcePath, const char* resourceName,
                                 const char* resourceMain, alt::IResource* resource);
 
     void ExecuteManagedResourceUnload(alt::IServer* server, const char* resourcePath, const char* resourceMain);
 
-    load_assembly_and_get_function_pointer_fn get_dotnet_load_assembly(const char_t* config_path);
-
 private:
 #ifdef _WIN32
     HMODULE _coreClrLib;
 #else
     void* _coreClrLib;
 #endif
     char* runtimeDirectory;
+    char* dotnetDirectory;
     coreclr_initialize_ptr _initializeCoreCLR;
     coreclr_shutdown_2_ptr _shutdownCoreCLR;
     coreclr_create_delegate_ptr _createDelegate;
@@ -145,5 +160,11 @@ class CoreClr {
 
     hostfxr_initialize_for_runtime_config_fn _initializeFxr;
     hostfxr_get_runtime_delegate_fn _getDelegate;
+    hostfxr_run_app_fn _runApp;
+    hostfxr_initialize_for_dotnet_command_line_fn _initForCmd;
     hostfxr_close_fn _closeFxr;
+    hostfxr_handle cxt;
+    std::thread thread;
 };
+
+EXPORT void CoreClr_SetResourceLoadDelegates(CoreClrDelegate_t resourceExecute, CoreClrDelegate_t resourceExecuteUnload);

runtime/src/CSharpScriptRuntime.cpp

@@ -4,7 +4,7 @@ CSharpScriptRuntime::CSharpScriptRuntime(alt::IServer* server)
 {
     this->server = server;
     this->coreClr = new CoreClr(server);
-    this->coreClr->CreateManagedHost(server);
+    this->coreClr->CreateManagedHost();
 }
 
 alt::IResource *CSharpScriptRuntime::CreateResource(alt::IResource::CreationInfo* info)