Moved logic for array pooling to a separate class.

Author: dlemstra

src/Magick.NET.Core/Magick.NET.Core.csproj

@@ -20,6 +20,7 @@
     <Compile Include="../Shared/FileHelper.cs" Link="Helpers/FileHelper.cs" />
     <Compile Include="../Shared/MemberNotNullAttribute.cs" Link="Helpers/MemberNotNullAttribute.cs" />
     <Compile Include="../Shared/NotNullAttribute.cs" Link="Helpers/NotNullAttribute.cs" />
+    <Compile Include="../Shared/PooledByteArray.cs" Link="Helpers/PooledByteArray.cs" />
     <Compile Include="../Shared/Throw.cs" Link="Helpers/Throw.cs" />
     <Compile Include="../Shared/CallerArgumentExpressionAttribute.cs" Link="Helpers/CallerArgumentExpressionAttribute.cs" />
     <Compile Include="../Shared/TypeHelper.cs" Link="Helpers/TypeHelper.cs" />

src/Magick.NET/Helpers/ByteArrayWrapper.cs

@@ -3,48 +3,21 @@
 
 using System;
 using System.IO;
-#if !NETSTANDARD2_0
-using System.Buffers;
-#endif
 
 namespace ImageMagick;
 
 internal sealed unsafe class ByteArrayWrapper : IDisposable
 {
-#if !NETSTANDARD2_0
-    private static readonly ArrayPool<byte> _pool = ArrayPool<byte>.Create(1024 * 1024 * 64, 128);
-
-    private byte[] _bytes = _pool.Rent(8192);
-#else
-    private byte[] _bytes = new byte[8192];
-#endif
+    private readonly PooledByteArray _bytes = new PooledByteArray(8192);
     private int _offset = 0;
-
     private int _length = 0;
 
-#if !NETSTANDARD2_0
     public void Dispose()
-        => _pool.Return(_bytes);
+        => _bytes.Dispose();
 
     public byte[] GetBytes()
-    {
-        var result = new byte[_length];
-        Array.Copy(_bytes, result, _length);
-        return result;
-    }
-
-#else
-    public void Dispose()
-    {
-    }
+        => _bytes.ToUnpooledArray(_length);
 
-    public byte[] GetBytes()
-    {
-        ResizeBytes(_length);
-        return _bytes;
-    }
-
-#endif
     public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
     {
         if (data == IntPtr.Zero)
@@ -58,7 +31,7 @@ public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
         if (length != 0)
         {
             var destination = (byte*)data.ToPointer();
-            fixed (byte* source = _bytes)
+            fixed (byte* source = _bytes.Data)
             {
                 NativeMemory.Copy(source + _offset, destination, length);
             }
@@ -108,7 +81,7 @@ public long Write(IntPtr data, UIntPtr count, IntPtr user_data)
         EnsureLength(newOffset);
 
         var source = (byte*)data.ToPointer();
-        fixed (byte* destination = _bytes)
+        fixed (byte* destination = _bytes.Data)
         {
             NativeMemory.Copy(source, destination + _offset, total);
         }
@@ -132,16 +105,6 @@ private void EnsureLength(int length)
         ResizeBytes(newLength);
     }
 
-#if !NETSTANDARD2_0
-    private void ResizeBytes(int length)
-    {
-        var newBytes = _pool.Rent(length);
-        Array.Copy(_bytes, newBytes, _bytes.Length);
-        _pool.Return(_bytes);
-        _bytes = newBytes;
-    }
-#else
     private void ResizeBytes(int length)
-        => Array.Resize(ref _bytes, length);
-#endif
+        => _bytes.Resize(length);
 }

src/Magick.NET/Helpers/StreamWrapper.cs

@@ -11,7 +11,7 @@ internal sealed unsafe class StreamWrapper : IDisposable
 {
     private const int BufferSize = 8192;
 
-    private readonly byte[] _buffer;
+    private readonly PooledByteArray _buffer;
     private readonly byte* _bufferStart;
     private readonly long _streamStart;
     private readonly GCHandle _handle;
@@ -20,8 +20,8 @@ internal sealed unsafe class StreamWrapper : IDisposable
     private StreamWrapper(Stream stream)
     {
         _stream = stream;
-        _buffer = new byte[BufferSize];
-        _handle = GCHandle.Alloc(_buffer, GCHandleType.Pinned);
+        _buffer = new PooledByteArray(BufferSize);
+        _handle = GCHandle.Alloc(_buffer.Data, GCHandleType.Pinned);
         _bufferStart = (byte*)_handle.AddrOfPinnedObject().ToPointer();
 
         try
@@ -49,7 +49,10 @@ public static StreamWrapper CreateForWriting(Stream stream)
     }
 
     public void Dispose()
-        => _handle.Free();
+    {
+        _handle.Free();
+        _buffer.Dispose();
+    }
 
     public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
     {
@@ -69,7 +72,7 @@ public long Read(IntPtr data, UIntPtr count, IntPtr user_data)
 
             try
             {
-                length = _stream.Read(_buffer, 0, (int)length);
+                length = _stream.Read(_buffer.Data, 0, (int)length);
             }
             catch
             {
@@ -138,7 +141,7 @@ public long Write(IntPtr data, UIntPtr count, IntPtr user_data)
 
             try
             {
-                _stream.Write(_buffer, 0, (int)length);
+                _stream.Write(_buffer.Data, 0, (int)length);
             }
             catch
             {

src/Magick.NET/Magick.NET.csproj

@@ -75,6 +75,7 @@
     <Compile Include="../Shared/FileHelper.cs" Link="Helpers/FileHelper.cs" />
     <Compile Include="../Shared/MemberNotNullAttribute.cs" Link="Helpers/MemberNotNullAttribute.cs" />
     <Compile Include="../Shared/NotNullAttribute.cs" Link="Helpers/NotNullAttribute.cs" />
+    <Compile Include="../Shared/PooledByteArray.cs" Link="Helpers/PooledByteArray.cs" />
     <Compile Include="../Shared/Throw.cs" Link="Helpers/Throw.cs" />
     <Compile Include="../Shared/CallerArgumentExpressionAttribute.cs" Link="Helpers/CallerArgumentExpressionAttribute.cs" />
     <Compile Include="../Shared/TypeHelper.cs" Link="Helpers/TypeHelper.cs" />

src/Shared/Bytes.cs

@@ -69,13 +69,13 @@ private static byte[] GetData(Stream stream, out int length)
             return GetDataWithSeekableStream(stream, out length);
 
         int count;
-        var buffer = new byte[BufferSize];
+        using var buffer = new PooledByteArray(BufferSize);
         using var tempStream = new MemoryStream();
-        while ((count = stream.Read(buffer, 0, BufferSize)) != 0)
+        while ((count = stream.Read(buffer.Data, 0, BufferSize)) != 0)
         {
             CheckLength(tempStream.Length + count);
 
-            tempStream.Write(buffer, 0, count);
+            tempStream.Write(buffer.Data, 0, count);
         }
 
         return GetDataFromMemoryStream(tempStream, out length);
@@ -98,13 +98,13 @@ private static byte[] GetData(Stream stream, out int length)
             return await GetDataWithSeekableStreamAsync(stream, cancellationToken).ConfigureAwait(false);
 
         int count;
-        var buffer = new byte[BufferSize];
+        using var buffer = new PooledByteArray(BufferSize);
         using var tempStream = new MemoryStream();
-        while ((count = await stream.ReadAsync(buffer, 0, BufferSize, cancellationToken).ConfigureAwait(false)) != 0)
+        while ((count = await stream.ReadAsync(buffer.Data, 0, BufferSize, cancellationToken).ConfigureAwait(false)) != 0)
         {
             CheckLength(tempStream.Length + count);
 
-            tempStream.Write(buffer, 0, count);
+            tempStream.Write(buffer.Data, 0, count);
         }
 
         bytes = GetDataFromMemoryStream(tempStream, out length);

src/Shared/PooledByteArray.cs

@@ -0,0 +1,71 @@
+// Copyright Dirk Lemstra https://github.com/dlemstra/Magick.NET.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+#if !NETSTANDARD2_0
+using System.Buffers;
+#endif
+
+namespace ImageMagick;
+
+internal sealed class PooledByteArray : IDisposable
+{
+#if !NETSTANDARD2_0
+    private static readonly ArrayPool<byte> _pool = ArrayPool<byte>.Create(1024 * 1024 * 64, 128);
+    private byte[] _bytes;
+
+    public PooledByteArray(int length)
+        => _bytes = _pool.Rent(length);
+
+    public byte[] Data
+        => _bytes;
+
+    public int Length
+        => _bytes.Length;
+
+    public void Dispose()
+        => _pool.Return(_bytes);
+
+    public void Resize(int length)
+    {
+        if (length <= _bytes.Length)
+            return;
+
+        var newBytes = _pool.Rent(length);
+        Buffer.BlockCopy(_bytes, 0, newBytes, 0, _bytes.Length);
+        _pool.Return(_bytes);
+    }
+
+    public byte[] ToUnpooledArray(int length)
+    {
+        var result = new byte[length];
+        Buffer.BlockCopy(_bytes, 0, result, 0, length);
+        return result;
+    }
+
+#else
+    private byte[] _bytes;
+
+    public PooledByteArray(int length)
+        => _bytes = new byte[length];
+
+    public byte[] Data
+        => _bytes;
+
+    public int Length
+        => _bytes.Length;
+
+    public void Dispose()
+    {
+    }
+
+    public void Resize(int length)
+        => Array.Resize(ref _bytes, length);
+
+    public byte[] ToUnpooledArray(int length)
+    {
+        Array.Resize(ref _bytes, length);
+        return _bytes;
+    }
+#endif
+}