Use high-level library load API

src/NodeApi/Runtime/NativeLibrary.cs

@@ -4,6 +4,8 @@
 #if !NET7_0_OR_GREATER
 
 using System;
+using System.IO;
+using System.Reflection;
 using System.Runtime.InteropServices;
 #if !NETFRAMEWORK
 using SysNativeLibrary = System.Runtime.InteropServices.NativeLibrary;
@@ -50,6 +52,25 @@ public static nint Load(string libraryName)
 #endif
     }
 
+    /// <summary>
+    /// Loads a native library using the high-level API.
+    /// </summary>
+    /// <param name="libraryName">The name of the native library to be loaded.</param>
+    /// <param name="assembly">The assembly loading the native library.</param>
+    /// <param name="searchPath">The search path.</param>
+    /// <returns>The OS handle for the loaded native library.</returns>
+    public static nint Load(string libraryName, Assembly assembly, DllImportSearchPath? searchPath)
+    {
+#if NETFRAMEWORK
+        string libraryPath = FindLibrary(libraryName, assembly)
+            ?? throw new ArgumentNullException(nameof(libraryName));
+
+        return LoadLibrary(libraryPath);
+#else
+        return SysNativeLibrary.Load(libraryName, assembly, searchPath);
+#endif
+    }
+
     /// <summary>
     /// Gets the address of an exported symbol.
     /// </summary>
@@ -75,6 +96,72 @@ public static bool TryGetExport(nint handle, string name, out nint procAddress)
 #endif
     }
 
+    /// <summary>
+    /// Searches various well-known paths for a library and returns the first result.
+    /// </summary>
+    /// <param name="libraryName">Name of the library to search for.</param>
+    /// <param name="assembly">Assembly to search relative from.</param>
+    /// <returns>Library path if found, otherwise false.</returns>
+    private static string? FindLibrary(string libraryName, Assembly assembly)
+    {
+        if (File.Exists(libraryName))
+        {
+            return Path.GetFullPath(libraryName);
+        }
+
+        string[] tryLibraryNames;
+
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            tryLibraryNames =
+            [
+                libraryName,
+                $"{libraryName}.dll"
+            ];
+        }
+        else
+        {
+            string libraryExtension = RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+                ? "dylib"
+                : "so";
+
+            tryLibraryNames =
+            [
+                libraryName,
+                $"lib{libraryName}",
+                $"{libraryName}.{libraryExtension}",
+                $"lib{libraryName}.{libraryExtension}"
+            ];
+        }
+
+        string?[] tryDirectories =
+        [
+            Path.GetDirectoryName(assembly.Location),
+            Environment.CurrentDirectory,
+            Environment.SystemDirectory,
+        ];
+
+        foreach (string? tryDirectory in tryDirectories)
+        {
+            if (tryDirectory == null)
+            {
+                continue;
+            }
+
+            foreach (string tryLibraryName in tryLibraryNames)
+            {
+                string tryLibraryPath = Path.Combine(tryDirectory, tryLibraryName);
+
+                if (File.Exists(tryLibraryPath))
+                {
+                    return tryLibraryPath;
+                }
+            }
+        }
+
+        return null;
+    }
+
 #pragma warning disable CA2101 // Specify marshaling for P/Invoke string arguments
 
     [DllImport("kernel32")]

src/NodeApi/Runtime/NodejsPlatform.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Reflection;
 using System.Runtime.InteropServices;
 
 namespace Microsoft.JavaScript.NodeApi.Runtime;
@@ -25,23 +26,30 @@ public sealed class NodejsPlatform : IDisposable
     /// <summary>
     /// Initializes the Node.js platform.
     /// </summary>
-    /// <param name="libnodePath">Path to the `libnode` shared library, including extension.</param>
+    /// <param name="libnode">
+    /// Name of the `libnode` shared library.
+    /// Has to be a full file path when using .NET Framework.
+    /// </param>
     /// <param name="args">Optional platform arguments.</param>
     /// <exception cref="InvalidOperationException">A Node.js platform instance has already been
     /// loaded in the current process.</exception>
     public NodejsPlatform(
-        string libnodePath,
+        string libnode,
         string[]? args = null)
     {
-        if (string.IsNullOrEmpty(libnodePath)) throw new ArgumentNullException(nameof(libnodePath));
-
         if (Current != null)
         {
             throw new InvalidOperationException(
                 "Only one Node.js platform instance per process is allowed.");
         }
 
-        nint libnodeHandle = NativeLibrary.Load(libnodePath);
+        var entryAssembly = Assembly.GetAssembly(typeof(NodejsPlatform));
+
+        nint libnodeHandle =
+            entryAssembly != null
+                ? NativeLibrary.Load(libnode, entryAssembly!, null)
+                : NativeLibrary.Load(libnode);
+
         Runtime = new NodejsRuntime(libnodeHandle);
 
         Runtime.CreatePlatform(args, (error) => Console.WriteLine(error), out _platform)