Add MemoryBackedStream

PowerKit.Tests/Extensions/StreamExtensionsTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -10,6 +11,93 @@ namespace PowerKit.Tests.Extensions;
 
 public class StreamExtensionsTests
 {
+    // A non-MemoryStream wrapper used to exercise the copy path
+    private sealed class NonMemoryStream(Stream inner) : Stream
+    {
+        public override bool CanRead => inner.CanRead;
+        public override bool CanSeek => false;
+        public override bool CanWrite => false;
+        public override long Length => throw new NotSupportedException();
+        public override long Position
+        {
+            get => throw new NotSupportedException();
+            set => throw new NotSupportedException();
+        }
+
+        public override void Flush() => inner.Flush();
+
+        public override int Read(byte[] buffer, int offset, int count) =>
+            inner.Read(buffer, offset, count);
+
+        public override long Seek(long offset, SeekOrigin origin) =>
+            throw new NotSupportedException();
+
+        public override void SetLength(long value) => throw new NotSupportedException();
+
+        public override void Write(byte[] buffer, int offset, int count) =>
+            throw new NotSupportedException();
+    }
+
+    [Fact]
+    public void ToMemoryStream_RegularStream_Test()
+    {
+        // Arrange
+        var data = new byte[] { 1, 2, 3, 4, 5 };
+        using var inner = new MemoryStream(data);
+        using var source = new NonMemoryStream(inner);
+
+        // Act
+        using var result = source.ToMemoryStream();
+
+        // Assert
+        result.Position.Should().Be(0);
+        result.ToArray().Should().Equal(data);
+    }
+
+    [Fact]
+    public void ToMemoryStream_AlreadyMemoryStream_ReturnsSameInstance_Test()
+    {
+        // Arrange
+        var data = new byte[] { 1, 2, 3, 4, 5 };
+        using var source = new MemoryStream(data);
+
+        // Act
+        var result = source.ToMemoryStream();
+
+        // Assert
+        result.Should().BeSameAs(source);
+    }
+
+    [Fact]
+    public async Task ToMemoryStreamAsync_RegularStream_Test()
+    {
+        // Arrange
+        var data = new byte[] { 1, 2, 3, 4, 5 };
+        using var inner = new MemoryStream(data);
+        using var source = new NonMemoryStream(inner);
+
+        // Act
+        using var result = await source.ToMemoryStreamAsync();
+
+        // Assert
+        result.Position.Should().Be(0);
+        result.ToArray().Should().Equal(data);
+    }
+
+    [Fact]
+    public async Task ToMemoryStreamAsync_AlreadyMemoryStream_ReturnsSameInstance_Test()
+    {
+        // Arrange
+        var data = new byte[] { 1, 2, 3, 4, 5 };
+        using var source = new MemoryStream(data);
+
+        // Act
+        var result = await source.ToMemoryStreamAsync();
+
+        // Assert
+        result.Should().BeSameAs(source);
+    }
+
     [Fact]
     public async Task CopyToAsync_AutoFlush_Test()
     {

PowerKit/Extensions/StreamExtensions.cs

@@ -13,6 +13,50 @@ public static class StreamExtensions
 {
     extension(Stream source)
     {
+        /// <summary>
+        /// Copies the contents of the stream into a new <see cref="MemoryStream" /> with
+        /// <see cref="Stream.Position" /> reset to 0.
+        /// </summary>
+        /// <remarks>
+        /// If the stream is already a <see cref="MemoryStream" />, it is returned as-is
+        /// without resetting its position.
+        /// </remarks>
+        public MemoryStream ToMemoryStream()
+        {
+            if (source is MemoryStream asMemoryStream)
+                return asMemoryStream;
+
+            var memoryStream = new MemoryStream();
+            source.CopyTo(memoryStream);
+            memoryStream.Position = 0;
+
+            return memoryStream;
+        }
+
+#if NET40_OR_GREATER || NETSTANDARD || NET
+        /// <summary>
+        /// Copies the contents of the stream into a new <see cref="MemoryStream" /> asynchronously
+        /// with <see cref="Stream.Position" /> reset to 0.
+        /// </summary>
+        /// <remarks>
+        /// If the stream is already a <see cref="MemoryStream" />, it is returned as-is
+        /// without resetting its position.
+        /// </remarks>
+        public async Task<MemoryStream> ToMemoryStreamAsync(
+            CancellationToken cancellationToken = default
+        )
+        {
+            if (source is MemoryStream asMemoryStream)
+                return asMemoryStream;
+
+            var memoryStream = new MemoryStream();
+            await source.CopyToAsync(memoryStream, 81920, cancellationToken).ConfigureAwait(false);
+            memoryStream.Position = 0;
+
+            return memoryStream;
+        }
+
+#endif
 #if NET40_OR_GREATER || NETSTANDARD || NET
         /// <summary>
         /// Copies the contents of the stream to the destination stream, optionally flushing after each write.