perf: Optimized special streams

Author: trungnt2910

MemoryModule/NativeAssembly.cs

@@ -57,12 +57,68 @@ private unsafe NativeAssembly()
         /// for dependency resolution. Can be null, to exclude from resolution.</param>
         /// <returns>A new NativeAssembly</returns>
         public static NativeAssembly Load(byte[] data, string name = null)
+        {
+            unsafe
+            {
+                fixed (byte* dataPtr = &data[0])
+                {
+                    return LoadInternal(dataPtr, data.Length, name);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Loads a NativeAssembly, from the specified Stream.
+        /// This function does not dispose the given stream.
+        /// </summary>
+        /// <param name="data">A valid Stream containing the assembly</param>
+        /// <param name="name">The name this assembly should be associated with
+        /// for dependency resolution. Can be null, to exclude from resolution.</param>
+        /// <returns>A new NativeAssembly</returns>
+        public static NativeAssembly Load(Stream data, string name = null)
+        {
+            if (data is MemoryStream mstream)
+            {
+                // Avoids more copying...
+                return Load(mstream.ToArray(), name);
+            }
+            // The most common stream in resoure files.
+            else if (data is UnmanagedMemoryStream umstream)
+            {
+                unsafe
+                {
+                    try
+                    {
+                        return LoadInternal(
+                           umstream.PositionPointer,
+                           umstream.Length - umstream.Position,
+                           name);
+                    }
+                    // There's no quick and easy way to do this,
+                    // but most resource streams are initialized using
+                    // byte*'s anyway.
+                    catch (NotSupportedException)
+                    {
+                        goto loadNormally;
+                    }
+                }
+            }
+            loadNormally:
+                var ms = new MemoryStream();
+                data.CopyTo(ms);
+                var arr = ms.ToArray();
+                ms.Dispose();
+                return Load(arr, name);
+        }
+
+        private static unsafe NativeAssembly LoadInternal(byte* data, long length, string name = null)
         {
             lock (_handles)
             {
                 var asm = new NativeAssembly();
                 IntPtr handle = NativeAssemblyImpl.LoadLibrary(
                     data,
+                    length,
                     loadLibrary: asm.LoadLibraryDelegate,
                     getProcAddress: GetProcAddressDelegate,
                     freeLibrary: FreeLibraryDelegate
@@ -84,23 +140,6 @@ public static NativeAssembly Load(byte[] data, string name = null)
             }
         }
 
-        /// <summary>
-        /// Loads a NativeAssembly, from the specified Stream.
-        /// This function does not dispose the given stream.
-        /// </summary>
-        /// <param name="data">A valid Stream containing the assembly</param>
-        /// <param name="name">The name this assembly should be associated with
-        /// for dependency resolution. Can be null, to exclude from resolution.</param>
-        /// <returns>A new NativeAssembly</returns>
-        public static NativeAssembly Load(Stream data, string name = null)
-        {
-            var ms = new MemoryStream();
-            data.CopyTo(ms);
-            var arr = ms.ToArray();
-            ms.Dispose();
-            return Load(arr, null);
-        }
-
         /// <summary>
         /// Unloads the library. You do not need to
         /// call this function, <code>Dispose()</code>

MemoryModule/NativeAssemblyImpl.cs

@@ -61,31 +61,52 @@ public static IntPtr LoadLibrary(
             CustomGetProcAddressFunc getProcAddress = null,
             CustomFreeLibraryFunc freeLibrary = null
         )
+        {
+            fixed (byte* dataPtr = &data[0])
+            {
+                return LoadLibrary(dataPtr, data.LongLength);
+            }
+        }
+
+        /// <summary>
+        /// Load EXE/DLL from memory location with the given size.
+        /// All dependencies are resolved using default LoadLibrary/GetProcAddress
+        /// calls through the Windows API, or through passed delegates.
+        /// </summary>
+        /// <param name="data">The assembly's code</param>
+        /// <param name="length">The assembly's code's length</param>
+        /// <returns>A handle to the loaded assembly</returns>
+        public static IntPtr LoadLibrary(
+            byte* dataPtr,
+            long length,
+            CustomAllocFunc allocMemory = null,
+            CustomFreeFunc freeMemory = null,
+            CustomLoadLibraryFunc loadLibrary = null,
+            CustomGetProcAddressFunc getProcAddress = null,
+            CustomFreeLibraryFunc freeLibrary = null
+        )
         {
             allocMemory = allocMemory ?? MemoryDefaultAllocDelegate;
             freeMemory = freeMemory ?? MemoryDefaultFreeDelegate;
             loadLibrary = loadLibrary ?? MemoryDefaultLoadLibraryDelegate;
             getProcAddress = getProcAddress ?? MemoryDefaultGetProcAddressDelegate;
             freeLibrary = freeLibrary ?? MemoryDefaultFreeLibraryDelegate;
-
-            fixed (void* dataPtr = &data[0])
+                            
+            var handle = MemoryLoadLibraryEx(
+                dataPtr, 
+                (ulong)length,
+                allocMemory, 
+                freeMemory, 
+                loadLibrary, 
+                getProcAddress, 
+                freeLibrary, 
+                null
+            );
+            if (handle == null)
             {
-                var handle = MemoryLoadLibraryEx(
-                    dataPtr, 
-                    (ulong)data.Length, 
-                    allocMemory, 
-                    freeMemory, 
-                    loadLibrary, 
-                    getProcAddress, 
-                    freeLibrary, 
-                    null
-                );
-                if (handle == null)
-                {
-                    throw new Win32Exception((int)GetLastError());
-                }
-                return new IntPtr(handle);
+                throw new Win32Exception((int)GetLastError());
             }
+            return new IntPtr(handle);
         }
 
         /// <summary>