针对大照片下，减少LOH对象的创建，经过修改，同一张NIKON Z8拍摄的无压缩照片（56.3 MB (59,137,944 字节)）由之前的读取一次创建80MB的LOH对象减少到读取一次只创建16MB的LOH对象。目前仅在net8编译。

Author: Wak1Z2

src/Magick.NET/Helpers/ByteArrayWrapper.cs

@@ -2,35 +2,45 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Buffers;
 using System.IO;
 
 namespace ImageMagick;
 
-internal sealed unsafe class ByteArrayWrapper
-{
-    private byte[] _bytes = new byte[8192];
-    private int _offset = 0;
-    private int _length = 0;
+internal sealed unsafe class ByteArrayWrapper {
+    private static readonly ArrayPool<byte> _pool = ArrayPool<byte>.Create(1024 * 1024 * 64, 1024);
+    private byte[] _bytes = _pool.Rent(1024 * 1024);
+    private int _length;
+    private int _offset;
 
     public byte[] GetBytes()
     {
-        ResizeBytes(_length);
-        return _bytes;
+        var  result = new byte[_length];
+        Array.Copy(_bytes, result, Math.Min(_bytes.Length, _length));
+        _pool.Return(_bytes, true);
+        return result;
     }
 
     public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
     {
         if (data == IntPtr.Zero)
+        {
             return 0;
+        }
+
+        int total = (int) count;
 
-        var total = (int)count;
         if (total == 0)
+        {
             return 0;
+        }
+
+        int length = Math.Min(total, _length - _offset);
 
-        var length = Math.Min(total, _length - _offset);
         if (length != 0)
         {
-            var destination = (byte*)data.ToPointer();
+            byte* destination = (byte*) data.ToPointer();
+
             fixed (byte* source = _bytes)
             {
                 NativeMemory.Copy(source + _offset, destination, length);
@@ -44,43 +54,54 @@ public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
 
     public long Seek(long offset, IntPtr whence, IntPtr user_data)
     {
-        var newOffset = (int)((SeekOrigin)whence switch
-        {
-            SeekOrigin.Begin => offset,
-            SeekOrigin.Current => _offset + offset,
-            SeekOrigin.End => _length - offset,
-            _ => -1,
-        });
+        int newOffset = (int) ((SeekOrigin) whence switch
+                                  {
+                                      SeekOrigin.Begin => offset,
+                                      SeekOrigin.Current => _offset + offset,
+                                      SeekOrigin.End => _length - offset,
+                                      _ => -1
+                                  });
 
         if (_offset == newOffset)
+        {
             return _offset;
+        }
 
         if (newOffset < 0)
+        {
             return -1;
+        }
 
         _offset = newOffset;
 
         return _offset;
     }
 
     public long Tell(IntPtr user_data)
-        => _offset;
+    {
+        return _offset;
+    }
 
     public long Write(IntPtr data, UIntPtr count, IntPtr user_data)
     {
         if (data == IntPtr.Zero)
+        {
             return 0;
+        }
 
-        var total = (int)count;
+        int total = (int) count;
 
         if (total == 0)
+        {
             return 0;
+        }
 
-        var newOffset = _offset + total;
+        int newOffset = _offset + total;
 
         EnsureLength(newOffset);
 
-        var source = (byte*)data.ToPointer();
+        byte* source = (byte*) data.ToPointer();
+
         fixed (byte* destination = _bytes)
         {
             NativeMemory.Copy(source, destination + _offset, total);
@@ -94,17 +115,26 @@ public long Write(IntPtr data, UIntPtr count, IntPtr user_data)
     private void EnsureLength(int length)
     {
         if (length < _length)
+        {
             return;
+        }
 
         _length = length;
 
         if (_length < _bytes.Length)
+        {
             return;
+        }
 
-        var newLength = Math.Max(_bytes.Length * 2, _length);
+        int newLength = Math.Max(_bytes.Length * 2, _length);
         ResizeBytes(newLength);
     }
 
     private void ResizeBytes(int length)
-        => Array.Resize(ref _bytes, length);
+    {
+        byte[] byte2 = _pool.Rent(length);
+        Array.Copy(_bytes, byte2, Math.Min(_bytes.Length, length));
+        _pool.Return(_bytes, true);
+        _bytes = byte2;
+    }
 }