CSHARP-2383: Provide overloads for WriteBytes/ReadBytes methods that …

src/MongoDB.Bson/IO/BsonBinaryReader.cs

@@ -273,8 +273,34 @@ public override byte[] ReadBytes()
             State = GetNextState();
             return _bsonStream.ReadBytes(size);
         }
-#pragma warning restore 618
 
+        /// <summary>
+        /// Reads BSON binary data from the reader to the buffer at offset and respecting the size.
+        /// </summary>
+        /// <param name="bytes">Target buffer</param>
+        /// <param name="offset">Target offset</param>
+        /// <returns>Bytes read</returns>
+        public override int ReadBytes(byte[] bytes, int offset) {
+            if (Disposed) { ThrowObjectDisposedException(); }
+            VerifyBsonType("ReadBytes", BsonType.Binary);
+
+            int size = ReadSize();
+
+            var subType = _bsonStream.ReadBinarySubType();
+            if (subType != BsonBinarySubType.Binary)
+            {
+                var message = string.Format("ReadBytes requires the binary sub type to be Binary, not {0}.", subType);
+                throw new FormatException(message);
+            }
+
+            State = GetNextState();
+
+            _bsonStream.ReadBytes(bytes, offset, size);
+
+            return size;
+        }
+
+#pragma warning restore 618
         /// <summary>
         /// Reads a BSON DateTime from the reader.
         /// </summary>

src/MongoDB.Bson/IO/BsonBinaryWriter.cs

@@ -261,6 +261,28 @@ public override void WriteBytes(byte[] bytes)
             State = GetNextState();
         }
 
+        /// <summary>
+        /// Writes BSON binary data to the writer.
+        /// </summary>
+        /// <param name="bytes">The bytes.</param>
+        /// <param name="size"> The count of bytes used in the bytes[] </param>
+        public override void WriteBytes(byte[] bytes, int size)
+        {
+            if (Disposed) { throw new ObjectDisposedException("BsonBinaryWriter"); }
+            if (State != BsonWriterState.Value)
+            {
+                ThrowInvalidState("WriteBytes", BsonWriterState.Value);
+            }
+
+            _bsonStream.WriteBsonType(BsonType.Binary);
+            WriteNameHelper();
+            _bsonStream.WriteInt32(size);
+            _bsonStream.WriteBinarySubType(BsonBinarySubType.Binary);
+            _bsonStream.WriteBytes(bytes, 0, size);
+
+            State = GetNextState();
+        }
+
         /// <summary>
         /// Writes a BSON DateTime to the writer.
         /// </summary>

src/MongoDB.Bson/IO/BsonDocumentReader.cs

@@ -179,6 +179,32 @@ public override byte[] ReadBytes()
 
             return binaryData.Bytes;
         }
+
+        /// <summary>
+        /// Reads BSON binary data from the reader to the buffer at offset and respecting the size.
+        /// </summary>
+        /// <param name="bytes">Target buffer</param>
+        /// <param name="offset">Target offset</param>
+        /// <returns>Bytes read</returns>
+        public override int ReadBytes(byte[] bytes, int offset = 0)
+        {
+            if (Disposed) { ThrowObjectDisposedException(); }
+            VerifyBsonType("ReadBytes", BsonType.Binary);
+
+            State = GetNextState();
+            var binaryData = _currentValue.AsBsonBinaryData;
+
+            var subType = binaryData.SubType;
+            if (subType != BsonBinarySubType.Binary && subType != BsonBinarySubType.OldBinary)
+            {
+                var message = string.Format("ReadBytes requires the binary sub type to be Binary, not {0}.", subType);
+                throw new FormatException(message);
+            }
+
+            binaryData.Bytes.CopyTo(bytes, offset);
+
+            return binaryData.Bytes.Length;
+        }
 #pragma warning restore 618
 
         /// <summary>

src/MongoDB.Bson/IO/BsonDocumentWriter.cs

@@ -133,6 +133,21 @@ public override void WriteBytes(byte[] bytes)
             State = GetNextState();
         }
 
+		/// <summary>
+		/// Writes BSON binary data to the writer.
+		/// </summary>
+		/// <param name="bytes">The bytes.</param>
+		/// <param name="size"> The count of bytes used in the bytes[] </param>
+		public override void WriteBytes(byte[] bytes, int size) {
+			if (bytes.Length != size) {
+				// TODO: Better use a buffer manager here or Provide size in BsonBinaryData
+				var copy = new byte[size];
+				Buffer.BlockCopy(bytes, 0, copy, 0, size);
+				WriteBytes(copy);
+			} else 
+				WriteBytes(bytes);
+		}
+
         /// <summary>
         /// Writes a BSON DateTime to the writer.
         /// </summary>

src/MongoDB.Bson/IO/BsonReader.cs

@@ -167,6 +167,14 @@ public BsonType GetCurrentBsonType()
         /// <returns>A byte array.</returns>
         public abstract byte[] ReadBytes();
 
+        /// <summary>
+        /// Reads BSON binary data from the reader to the buffer at offset and respecting the size.
+        /// </summary>
+        /// <param name="bytes">Target buffer</param>
+        /// <param name="offset">Target offset</param>
+        /// <returns>Bytes read</returns>
+        public abstract int ReadBytes(byte[] bytes, int offset = 0);
+
         /// <summary>
         /// Reads a BSON DateTime from the reader.
         /// </summary>

src/MongoDB.Bson/IO/BsonWriter.cs

@@ -184,6 +184,13 @@ public void PushSettings(Action<BsonWriterSettings> configurator)
         /// <param name="bytes">The bytes.</param>
         public abstract void WriteBytes(byte[] bytes);
 
+		/// <summary>
+		/// Writes BSON binary data to the writer.
+		/// </summary>
+		/// <param name="bytes">The bytes.</param>
+		/// <param name="size"> </param>
+		public abstract void WriteBytes(byte[] bytes, int size);
+
         /// <summary>
         /// Writes a BSON DateTime to the writer.
         /// </summary>

src/MongoDB.Bson/IO/IBsonReader.cs

@@ -83,6 +83,14 @@ public interface IBsonReader : IDisposable
         /// <returns>A byte array.</returns>
         byte[] ReadBytes();
 
+        /// <summary>
+        /// Reads BSON binary data from the reader to the buffer at offset and respecting the size.
+        /// </summary>
+        /// <param name="buffer">Target buffer</param>
+        /// <param name="offset">Target offset</param>
+        /// <returns>Bytes read</returns>
+        int ReadBytes(byte[] buffer, int offset);
+
         /// <summary>
         /// Reads a BSON DateTime from the reader.
         /// </summary>

src/MongoDB.Bson/IO/IBsonWriter.cs

@@ -101,6 +101,13 @@ public interface IBsonWriter : IDisposable
         /// <param name="bytes">The bytes.</param>
         void WriteBytes(byte[] bytes);
 
+		/// <summary>
+		/// Writes BSON binary data to the writer.
+		/// </summary>
+		/// <param name="bytes">The bytes.</param>
+		/// <param name="size"> </param>
+		void WriteBytes(byte[] bytes, int size);
+
         /// <summary>
         /// Writes a BSON DateTime to the writer.
         /// </summary>

src/MongoDB.Bson/IO/JsonReader.cs

@@ -421,6 +421,33 @@ public override byte[] ReadBytes()
             }
 
             return binaryData.Bytes;
+
+        }
+
+        /// <summary>
+        /// Reads BSON binary data from the reader to the buffer at offset and respecting the size.
+        /// </summary>
+        /// <param name="bytes">Target buffer</param>
+        /// <param name="offset">Target offset</param>
+        /// <returns>Bytes read</returns>
+        public override int ReadBytes(byte[] bytes, int offset)
+        {
+
+            if (Disposed) { ThrowObjectDisposedException(); }
+            VerifyBsonType("ReadBinaryData", BsonType.Binary);
+            State = GetNextState();
+            var binaryData = _currentValue.AsBsonBinaryData;
+
+            var subType = binaryData.SubType;
+            if (subType != BsonBinarySubType.Binary && subType != BsonBinarySubType.OldBinary)
+            {
+                var message = string.Format("ReadBytes requires the binary sub type to be Binary, not {0}.", subType);
+                throw new FormatException(message);
+            }
+
+            binaryData.Bytes.CopyTo(bytes, offset);
+
+            return binaryData.Bytes.Length;
 #pragma warning restore
         }
 

src/MongoDB.Bson/IO/JsonToken.cs

@@ -13,6 +13,9 @@
 * limitations under the License.
 */
 
+
+
+
 using System;
 
 namespace MongoDB.Bson.IO

src/MongoDB.Bson/IO/JsonWriter.cs

@@ -175,6 +175,21 @@ public override void WriteBytes(byte[] bytes)
             WriteBinaryData(new BsonBinaryData(bytes, BsonBinarySubType.Binary));
         }
 
+		/// <summary>
+		/// Writes BSON binary data to the writer.
+		/// </summary>
+		/// <param name="bytes">The bytes.</param>
+		/// <param name="size"> The count of bytes used in the bytes[] </param>
+		public override void WriteBytes(byte[] bytes, int size) {
+			if (bytes.Length != size) {
+				// TODO: Better use a buffer manager here or Provide size in BsonBinaryData
+				var copy = new byte[size];
+				Buffer.BlockCopy(bytes, 0, copy, 0, size);
+				WriteBytes(copy);
+			} else 
+				WriteBytes(bytes);
+		}
+
         /// <summary>
         /// Writes a BSON DateTime to the writer.
         /// </summary>

src/MongoDB.Bson/IO/WrappingBsonWriter.cs

@@ -168,6 +168,13 @@ public virtual void WriteBytes(byte[] bytes)
             _wrapped.WriteBytes(bytes);
         }
 
+		/// <inheritdoc />
+		public virtual void WriteBytes(byte[] bytes, int size)
+		{
+			ThrowIfDisposed();
+			_wrapped.WriteBytes(bytes, size);
+		}
+
         /// <inheritdoc />
         public virtual void WriteDateTime(long value)
         {

src/MongoDB.Driver/Linq/Processors/Pipeline/MethodCallBinders/JoinSerializer.cs

@@ -188,6 +188,11 @@ public byte[] ReadBytes()
                 return _parent.ReadBytes();
             }
 
+            public int ReadBytes(byte[] bytes, int offset = 0)
+            {
+                return _parent.ReadBytes(bytes, offset);
+            }
+
             public long ReadDateTime()
             {
                 return _parent.ReadDateTime();

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

@@ -916,6 +916,23 @@ public void TestObjectIdStrict()
             Assert.Equal(json, BsonSerializer.Deserialize<ObjectId>(json).ToJson(jsonSettings));
         }
 
+        [Fact]
+        public void TestReadWithReusedBuffer() {
+            var expectedBytes = new byte[] { 0x01, 0x23 };
+            var json          = "HexData(0, \"123\")";
+            using (_bsonReader = new JsonReader(json))
+            {
+                Assert.Equal(BsonType.Binary, _bsonReader.ReadBsonType());
+                var bytes     = new byte[1024];
+                int readBytes = _bsonReader.ReadBytes(bytes, 50);
+                Assert.Equal(2, readBytes);
+                Assert.True(expectedBytes.SequenceEqual(bytes.Skip(50).Take(2)));
+                Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
+            }
+            var expectedJson = "new BinData(0, \"ASM=\")";
+            Assert.Equal(expectedJson, BsonSerializer.Deserialize<byte[]>(json).ToJson());
+        }
+
         [Theory]
         [InlineData("{ $regex : \"abc\", $options : \"i\" }", "abc", "i")]
         [InlineData("{ $regex : \"abc/\", $options : \"i\" }", "abc/", "i")]

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

@@ -368,6 +368,20 @@ public void WriteBytes_should_call_wrapped()
             mockWrapped.Verify(m => m.WriteBytes(value), Times.Once);
         }
 
+
+        [Fact]
+        public void WriteBytesPars_should_call_wrapped()
+        {
+            Mock<IBsonWriter> mockWrapped;
+            var subject = CreateSubject(out mockWrapped);
+            const int size = 0;
+            var value = new byte[0];
+
+            subject.WriteBytes(value, size);
+
+            mockWrapped.Verify(m => m.WriteBytes(value, size), Times.Once);
+        }
+
         [Fact]
         public void WriteBytes_should_throw_when_disposed()
         {