Add GetStream overrides for ReadOnlyMemory<byte> (#201)

* Add GetStream overrides for ReadOnlyMemory<byte>

* Change to use ReadOnlySpan<byte>, obsolete methods that take Memory<byte>.

Co-authored-by: Ben Watson <[email protected]>

Author: benmwatson

UnitTests/Tests.cs

@@ -2453,6 +2453,7 @@ public void GetStreamWithOnlyBuffer()
         }
 
         [Test]
+        [Obsolete("GetStream(Memory<byte>) is obsolete.")]
         public void GetStreamWithMemoryBuffer()
         {
             var memMgr = this.GetMemoryManager();
@@ -2467,6 +2468,7 @@ public void GetStreamWithMemoryBuffer()
         }
 
         [Test]
+        [Obsolete("GetStream(Memory<byte>) is obsolete.")]
         public void GetStreamWithOnlyMemoryBuffer()
         {
             var memMgr = this.GetMemoryManager();
@@ -2476,6 +2478,31 @@ public void GetStreamWithOnlyMemoryBuffer()
             RMSAssert.BuffersAreEqual(buffer.Span, stream.GetBuffer(), buffer.Length);
             Assert.That(buffer, Is.Not.SameAs(stream.GetBuffer()));
         }
+
+        [Test]
+        public void GetStreamWithReadOnlySpan()
+        {
+            var memMgr = this.GetMemoryManager();
+            var buffer = new ReadOnlyMemory<byte>(this.GetRandomBuffer(1000));
+            var bufferSlice = buffer.Slice(1);
+            var tag = "MyTag";
+
+            var stream = memMgr.GetStream(tag, bufferSlice.Span) as RecyclableMemoryStream;
+            RMSAssert.BuffersAreEqual(bufferSlice.Span, stream.GetBuffer(), bufferSlice.Length);
+            Assert.That(bufferSlice, Is.Not.SameAs(stream.GetBuffer()));
+            Assert.That(stream.Tag, Is.EqualTo(tag));
+        }
+
+        [Test]
+        public void GetStreamWithOnlyReadOnlySpan()
+        {
+            var memMgr = this.GetMemoryManager();
+            var buffer = new ReadOnlyMemory<byte>(this.GetRandomBuffer(1000));
+
+            var stream = memMgr.GetStream(buffer.Span) as RecyclableMemoryStream;
+            RMSAssert.BuffersAreEqual(buffer.Span, stream.GetBuffer(), buffer.Length);
+            Assert.That(buffer, Is.Not.SameAs(stream.GetBuffer()));
+        }
         #endregion
 
         #region WriteTo tests

src/RecyclableMemoryStreamManager.cs

@@ -879,6 +879,7 @@ public MemoryStream GetStream(string tag, byte[] buffer, int offset, int count)
         /// <param name="tag">A tag which can be used to track the source of the stream.</param>
         /// <param name="buffer">The byte buffer to copy data from.</param>
         /// <returns>A <c>MemoryStream</c>.</returns>
+        [Obsolete("Use the ReadOnlySpan<byte> version of this method instead.")]
         public MemoryStream GetStream(Guid id, string tag, Memory<byte> buffer)
         {
             RecyclableMemoryStream stream = null;
@@ -896,18 +897,57 @@ public MemoryStream GetStream(Guid id, string tag, Memory<byte> buffer)
             }
         }
 
+        /// <summary>
+        /// Retrieve a new <c>MemoryStream</c> object with the given tag and with contents copied from the provided
+        /// buffer. The provided buffer is not wrapped or used after construction.
+        /// </summary>
+        /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+        /// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+        /// <param name="tag">A tag which can be used to track the source of the stream.</param>
+        /// <param name="buffer">The byte buffer to copy data from.</param>
+        /// <returns>A <c>MemoryStream</c>.</returns>
+        public MemoryStream GetStream(Guid id, string tag, ReadOnlySpan<byte> buffer)
+        {
+            RecyclableMemoryStream stream = null;
+            try
+            {
+                stream = new RecyclableMemoryStream(this, id, tag, buffer.Length);
+                stream.Write(buffer);
+                stream.Position = 0;
+                return stream;
+            }
+            catch
+            {
+                stream?.Dispose();
+                throw;
+            }
+        }
+
         /// <summary>
         /// Retrieve a new <c>MemoryStream</c> object with the contents copied from the provided
         /// buffer. The provided buffer is not wrapped or used after construction.
         /// </summary>
         /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
         /// <param name="buffer">The byte buffer to copy data from.</param>
         /// <returns>A <c>MemoryStream</c>.</returns>
+        [Obsolete("Use the ReadOnlySpan<byte> version of this method instead.")]
         public MemoryStream GetStream(Memory<byte> buffer)
         {
             return GetStream(null, buffer);
         }
 
+        /// <summary>
+        /// Retrieve a new <c>MemoryStream</c> object with the contents copied from the provided
+        /// buffer. The provided buffer is not wrapped or used after construction.
+        /// </summary>
+        /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+        /// <param name="buffer">The byte buffer to copy data from.</param>
+        /// <returns>A <c>MemoryStream</c>.</returns>
+        public MemoryStream GetStream(ReadOnlySpan<byte> buffer)
+        {
+            return GetStream(null, buffer);
+        }
+
         /// <summary>
         /// Retrieve a new <c>MemoryStream</c> object with the given tag and with contents copied from the provided
         /// buffer. The provided buffer is not wrapped or used after construction.
@@ -916,11 +956,25 @@ public MemoryStream GetStream(Memory<byte> buffer)
         /// <param name="tag">A tag which can be used to track the source of the stream.</param>
         /// <param name="buffer">The byte buffer to copy data from.</param>
         /// <returns>A <c>MemoryStream</c>.</returns>
+        [Obsolete("Use the ReadOnlySpan<byte> version of this method instead.")]
         public MemoryStream GetStream(string tag, Memory<byte> buffer)
         {
             return GetStream(Guid.NewGuid(), tag, buffer);
         }
 
+        /// <summary>
+        /// Retrieve a new <c>MemoryStream</c> object with the given tag and with contents copied from the provided
+        /// buffer. The provided buffer is not wrapped or used after construction.
+        /// </summary>
+        /// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+        /// <param name="tag">A tag which can be used to track the source of the stream.</param>
+        /// <param name="buffer">The byte buffer to copy data from.</param>
+        /// <returns>A <c>MemoryStream</c>.</returns>
+        public MemoryStream GetStream(string tag, ReadOnlySpan<byte> buffer)
+        {
+            return GetStream(Guid.NewGuid(), tag, buffer);
+        }
+
         /// <summary>
         /// Triggered when a new block is created.
         /// </summary>