- Added IBufferSlicer for slicing the underlying byteBuffer in ReadOnlyMemoryBsonReader and ReadOnlyMemoryBuffer

Author: BorisDog

src/MongoDB.Bson/IO/BsonBinaryReaderUtils.cs

@@ -25,6 +25,7 @@ public static class BsonBinaryReaderUtils
 {
     /// <summary>
     /// Creates an instance of <see cref="IBsonReader"/> for the given byte buffer and reader settings.
+    /// The result <see cref="IBsonReader"/> instance does not own the byte buffer, and will not Dispose it.
     /// For continuous single chunk buffers an optimized implementation of <see cref="IBsonReader"/> is created.
     /// </summary>
     /// <param name="byteBuffer">The byte buffer containing BSON data.</param>
@@ -40,7 +41,7 @@ public static IBsonReader CreateBinaryReader(IByteBuffer byteBuffer, BsonBinaryR
         var backingBytes = byteBuffer.AccessBackingBytes(0);
         if (backingBytes.Count == byteBuffer.Length)
         {
-            return new ReadOnlyMemoryBsonReader(backingBytes, new ReadOnlyMemoryReaderSettings(settings));
+            return new ReadOnlyMemoryBsonReader(backingBytes, new ByteBufferSlicer(byteBuffer), new ReadOnlyMemoryReaderSettings(settings));
         }
 
         var stream = new ByteBufferStream(byteBuffer, ownsBuffer: false);
@@ -99,4 +100,4 @@ private static string GenerateDottedElementName(BsonBinaryReaderContext[] contex
 
         return elementName;
     }
-}
+}

src/MongoDB.Bson/IO/IBufferSlicer.cs

@@ -0,0 +1,37 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+
+namespace MongoDB.Bson.IO;
+
+internal interface IByteBufferSlicer
+{
+    public IByteBuffer GetSlice(int position, int length);
+}
+
+internal sealed class ReadOnlyMemorySlicer(ReadOnlyMemory<byte> ReadOnlyMemory) : IByteBufferSlicer
+{
+    public IByteBuffer GetSlice(int position, int length)
+    {
+        var slice = ReadOnlyMemory.Slice(position, length);
+        return new ReadOnlyMemoryBuffer(slice, new ReadOnlyMemorySlicer(slice));
+    }
+}
+
+internal sealed class ByteBufferSlicer(IByteBuffer ByteBuffer) : IByteBufferSlicer
+{
+    public IByteBuffer GetSlice(int position, int length) => ByteBuffer.GetSlice(position, length);
+}

src/MongoDB.Bson/IO/ReadOnlyMemoryBsonReader.cs

@@ -21,13 +21,11 @@
 
 namespace MongoDB.Bson.IO;
 
-/// <summary>
-/// Represents a BSON reader for a ReadOnlyMemory containing a binary BSON byte array.
-/// </summary>
-public sealed class ReadOnlyMemoryBsonReader : BsonReader
+internal sealed class ReadOnlyMemoryBsonReader : BsonReader
 {
     private static readonly BsonReaderState[] __stateMap;
 
+    private readonly IByteBufferSlicer _byteBufferSlicer;
     private readonly ReadOnlyMemory<byte> _memory;
     private int _position;
 
@@ -44,24 +42,26 @@ static ReadOnlyMemoryBsonReader()
         __stateMap[(int)ContextType.TopLevel] = BsonReaderState.Initial;
     }
 
-    /// <summary>
-    /// Initializes a new instance of the ReadOnlyMemoryBsonReader class.
-    /// </summary>
-    /// <param name="memory">Memory containing binary BSON.</param>
     public ReadOnlyMemoryBsonReader(ReadOnlyMemory<byte> memory)
         : this(memory, ReadOnlyMemoryReaderSettings.Defaults)
     {
     }
 
-    /// <summary>
-    /// Initializes a new instance of the ReadOnlyMemoryBsonReader class.
-    /// </summary>
-    /// <param name="memory">Memory containing binary BSON.</param>
-    /// <param name="settings">A ReadOnlyMemoryReaderSettings.</param>
     public ReadOnlyMemoryBsonReader(ReadOnlyMemory<byte> memory, ReadOnlyMemoryReaderSettings settings)
+        : this(memory, new ReadOnlyMemorySlicer(memory), settings)
+    {
+    }
+
+    public ReadOnlyMemoryBsonReader(ReadOnlyMemory<byte> memory, IByteBufferSlicer byteBufferSlicer, ReadOnlyMemoryReaderSettings settings)
         : base(settings)
     {
+        if (byteBufferSlicer == null)
+        {
+            throw new ArgumentNullException(nameof(byteBufferSlicer));
+        }
+
         _memory = memory;
+        _byteBufferSlicer = byteBufferSlicer;
         _position = 0;
 
         _context = new BsonBinaryReaderContext(ContextType.TopLevel, 0, 0);
@@ -700,8 +700,7 @@ private IByteBuffer ReadSliceFromMemory()
         var memoryAtPosition = _memory.Slice(_position);
         var length = BinaryPrimitives.ReadInt32LittleEndian(memoryAtPosition.Span);
 
-        var result = new ReadOnlyMemoryBuffer(memoryAtPosition.Slice(0, length));
-
+        var result = _byteBufferSlicer.GetSlice(_position, length);
         _position += length;
 
         return result;

src/MongoDB.Bson/IO/ReadOnlyMemoryBuffer.cs

@@ -21,10 +21,17 @@ namespace MongoDB.Bson.IO;
 internal sealed class ReadOnlyMemoryBuffer : IByteBuffer
 {
     private readonly ReadOnlyMemory<byte> _memory;
+    private readonly IByteBufferSlicer _bufferSlicer;
 
-    public ReadOnlyMemoryBuffer(ReadOnlyMemory<byte> memory)
+    public ReadOnlyMemoryBuffer(ReadOnlyMemory<byte> memory, IByteBufferSlicer bufferSlicer)
     {
+        if (bufferSlicer == null)
+        {
+            throw new ArgumentNullException(nameof(bufferSlicer));
+        }
+
         _memory = memory;
+        _bufferSlicer = bufferSlicer;
     }
 
     /// <inheritdoc/>
@@ -77,7 +84,7 @@ public void GetBytes(int position, byte[] destination, int offset, int count) =>
 
     /// <inheritdoc/>
     public IByteBuffer GetSlice(int position, int length) =>
-        new ReadOnlyMemoryBuffer(_memory.Slice(position, length));
+        _bufferSlicer.GetSlice(position, length);
 
     /// <inheritdoc/>
     public void MakeReadOnly()

src/MongoDB.Bson/IO/SingleChunkBuffer.cs

@@ -260,15 +260,15 @@ private void EnsureIsReadOnly()
         {
             if (!_isReadOnly)
             {
-                throw new InvalidOperationException("MultiChunkBuffer is not read only.");
+                throw new InvalidOperationException($"{nameof(SingleChunkBuffer)} is not read only.");
             }
         }
 
         private void EnsureIsWritable()
         {
             if (_isReadOnly)
             {
-                throw new InvalidOperationException("MultiChunkBuffer is not writable.");
+                throw new InvalidOperationException($"{nameof(SingleChunkBuffer)} is not writable.");
             }
         }
 

src/MongoDB.Bson/Properties/AssemblyInfo.cs

@@ -26,5 +26,6 @@
 // as Xamarin.iOS/Xamarin.Mac.
 [assembly: Preserve(AllMembers = true)]
 
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
 [assembly: InternalsVisibleTo("MongoDB.Bson.Tests, PublicKey=002400000480000094000000060200000024000052534131000400000100010035287f0d3883c0a075c88e0cda3ce93b621003ecbd5e920d4a8c7238564f4d2f4f68116aca28c9b21341dc3a877679c14556192b2b2f5fe2c11d624e0894d308ff7b94bf6fd72aef1b41017ffe2572e99019d1c61963e68cd0ed67734a42cb333b808e3867cbe631937214e32e409fb1fa62fdb69d494c2530e64a40e417d6ee")]
 [assembly: InternalsVisibleTo("MongoDB.Analyzer.MQLGenerator, PublicKey=002400000480000094000000060200000024000052534131000400000100010035287f0d3883c0a075c88e0cda3ce93b621003ecbd5e920d4a8c7238564f4d2f4f68116aca28c9b21341dc3a877679c14556192b2b2f5fe2c11d624e0894d308ff7b94bf6fd72aef1b41017ffe2572e99019d1c61963e68cd0ed67734a42cb333b808e3867cbe631937214e32e409fb1fa62fdb69d494c2530e64a40e417d6ee")]

tests/MongoDB.Bson.Tests/IO/BsonBinaryReaderUtilsTests.cs

@@ -0,0 +1,85 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Linq;
+using FluentAssertions;
+using MongoDB.Bson.IO;
+using Xunit;
+
+namespace MongoDB.Bson.Tests.IO;
+
+public class BsonBinaryReaderUtilsTests
+{
+    [Fact]
+    public void CreateBinaryReader_should_create_ReadOnlyMemoryBsonReader_for_ReadOnlyMemoryBuffer()
+    {
+        var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
+        using var buffer = new ReadOnlyMemoryBuffer(bytes, new ReadOnlyMemorySlicer(bytes));
+        using var reader = BsonBinaryReaderUtils.CreateBinaryReader(buffer, new());
+
+        reader.Should().BeOfType<ReadOnlyMemoryBsonReader>();
+
+        ValidateSliceType<ReadOnlyMemoryBuffer>(reader, bytes.Length);
+    }
+
+    [Fact]
+    public void CreateBinaryReader_should_create_ReadOnlyMemoryBsonReader_for_SingleChunkBuffer()
+    {
+        var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
+
+        var buffer = new SingleChunkBuffer(new ByteArrayChunk(bytes), bytes.Length, true);
+        var reader = BsonBinaryReaderUtils.CreateBinaryReader(buffer, new());
+
+        reader.Should().BeOfType<ReadOnlyMemoryBsonReader>();
+
+        ValidateSliceType<ByteBufferSlice>(reader, bytes.Length);
+    }
+
+    [Fact]
+    public void CreateBinaryReader_should_create_ReadOnlyMemoryBsonReader_for_MultiChunkBuffer_with_single_chunk()
+    {
+        var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
+
+        var buffer = new MultiChunkBuffer([new ByteArrayChunk(bytes)], bytes.Length, true);
+        var reader = BsonBinaryReaderUtils.CreateBinaryReader(buffer, new());
+
+        reader.Should().BeOfType<ReadOnlyMemoryBsonReader>();
+
+        ValidateSliceType<ByteBufferSlice>(reader, bytes.Length);
+    }
+
+    [Fact]
+    public void CreateBinaryReader_should_create_BsonBinaryReader_for_MultiChunkBuffer_with_multiple_chunks()
+    {
+        var bytes = new byte[] { 29, 0, 0, 0, 5, 120, 0, 16, 0, 0, 0, 4, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0 };
+
+        var buffer = new MultiChunkBuffer([new ByteArrayChunk(bytes.Take(10).ToArray()), new ByteArrayChunk(bytes.Skip(10).ToArray())], bytes.Length, true);
+        var reader = BsonBinaryReaderUtils.CreateBinaryReader(buffer, new());
+
+        reader.Should().BeOfType<BsonBinaryReader>();
+
+        ValidateSliceType<ByteBufferSlice>(reader, bytes.Length);
+    }
+
+    private static void ValidateSliceType<T>(IBsonReader reader, int expectedSliceSize)
+        where T : IByteBuffer
+    {
+        // Check the usage of the correct slicer by reading a slice
+        var slice = reader.ReadRawBsonDocument();
+
+        slice.Length.Should().Be(expectedSliceSize);
+        slice.Should().BeOfType<T>();
+    }
+}

tests/MongoDB.Bson.Tests/IO/IByteBufferSlicerTests.cs

@@ -0,0 +1,54 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using FluentAssertions;
+using MongoDB.Bson.IO;
+using Moq;
+using Xunit;
+
+namespace MongoDB.Bson.Tests.IO;
+
+public class ByteBufferSlicerTests
+{
+    [Fact]
+    public void ByteBufferSlicer_should_use_underlying_buffer_slice()
+    {
+        using var byteBufferExpected = new ByteArrayBuffer([1, 2, 3]);
+
+        var byteBufferMock = new Mock<IByteBuffer>();
+        byteBufferMock.Setup(b => b.GetSlice(0, 3)).Returns(byteBufferExpected);
+
+        var slicer = new ByteBufferSlicer(byteBufferMock.Object);
+
+        using var slice = slicer.GetSlice(0, 3);
+
+        slice.Should().Be(byteBufferExpected);
+        byteBufferMock.Verify(b => b.GetSlice(0, 3), Times.Once);
+    }
+
+    [Fact]
+    public void ReadOnlyMemorySlicer_should_return_ReadOnlyMemoryBuffer()
+    {
+        byte[] bytes = [1, 2, 3];
+
+        var slicer = new ReadOnlyMemorySlicer(bytes);
+
+        using var slice = slicer.GetSlice(0, 1);
+
+        var buffer = slice.Should().BeOfType<ReadOnlyMemoryBuffer>().Subject;
+        buffer.Memory.Length.Should().Be(1);
+        buffer.Memory.Span[0].Should().Be(1);
+    }
+}