Add ctor overloads

Author: rzikm

src/libraries/System.IO.Compression.ZStandard/ref/System.IO.Compression.ZStandard.cs

@@ -60,6 +60,8 @@ public ZstandardStream(System.IO.Stream stream, System.IO.Compression.Compressio
         public ZstandardStream(System.IO.Stream stream, System.IO.Compression.CompressionMode mode) { }
         public ZstandardStream(System.IO.Stream stream, System.IO.Compression.CompressionMode mode, bool leaveOpen) { }
         public ZstandardStream(System.IO.Stream stream, System.IO.Compression.ZstandardCompressionOptions compressionOptions, bool leaveOpen = false) { }
+        public ZstandardStream(System.IO.Stream stream, System.IO.Compression.ZstandardDecoder decoder, bool leaveOpen = false) { }
+        public ZstandardStream(System.IO.Stream stream, System.IO.Compression.ZstandardEncoder encoder, bool leaveOpen = false) { }
         public System.IO.Stream BaseStream { get { throw null; } }
         public override bool CanRead { get { throw null; } }
         public override bool CanSeek { get { throw null; } }

src/libraries/System.IO.Compression.ZStandard/src/System/IO/Compression/ZStandardStream.Compress.cs

@@ -44,6 +44,18 @@ public ZstandardStream(Stream stream, ZstandardCompressionOptions compressionOpt
             }
         }
 
+        /// <summary>Initializes a new instance of the <see cref="ZstandardStream" /> class by using the specified stream and encoder instance.</summary>
+        /// <param name="stream">The stream to which compressed data is written.</param>
+        /// <param name="encoder">The encoder instance to use for compression. The stream will not dispose this encoder; instead, it will reset it when the stream is disposed.</param>
+        /// <param name="leaveOpen"><see langword="true" /> to leave the stream open after the <see cref="ZstandardStream" /> object is disposed; otherwise, <see langword="false" />.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="stream"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="stream"/> does not support writing.</exception>
+        public ZstandardStream(Stream stream, ZstandardEncoder encoder, bool leaveOpen = false) : this(stream, CompressionMode.Compress, leaveOpen)
+        {
+            _encoder = encoder;
+            _encoderOwned = false;
+        }
+
         private void WriteCore(ReadOnlySpan<byte> buffer, bool isFinalBlock = false, bool flush = false, bool checkActiveRWOps = true)
         {
             if (_mode != CompressionMode.Compress)

src/libraries/System.IO.Compression.ZStandard/src/System/IO/Compression/ZStandardStream.Decompress.cs

@@ -15,6 +15,18 @@ public sealed partial class ZstandardStream
         private int _bufferCount;
         private bool _nonEmptyInput;
 
+        /// <summary>Initializes a new instance of the <see cref="ZstandardStream" /> class by using the specified stream and decoder instance.</summary>
+        /// <param name="stream">The stream from which data to decompress is read.</param>
+        /// <param name="decoder">The decoder instance to use for decompression. The stream will not dispose this decoder; instead, it will reset it when the stream is disposed.</param>
+        /// <param name="leaveOpen"><see langword="true" /> to leave the stream open after the <see cref="ZstandardStream" /> object is disposed; otherwise, <see langword="false" />.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="stream"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException"><paramref name="stream"/> does not support reading.</exception>
+        public ZstandardStream(Stream stream, ZstandardDecoder decoder, bool leaveOpen = false) : this(stream, CompressionMode.Decompress, leaveOpen)
+        {
+            _decoder = decoder;
+            _decoderOwned = false;
+        }
+
         private bool TryDecompress(Span<byte> destination, out int bytesWritten)
         {
             // Decompress any data we may have in our buffer.

src/libraries/System.IO.Compression.ZStandard/src/System/IO/Compression/ZstandardStream.cs

@@ -18,6 +18,11 @@ public sealed partial class ZstandardStream : Stream
         private readonly CompressionMode _mode;
         private volatile bool _activeRwOperation;
 
+        // These fields track whether the encoder/decoder are owned by this stream instance
+        // When owned, they are disposed; when not owned, they are reset
+        private bool _encoderOwned = true;
+        private bool _decoderOwned = true;
+
         /// <summary>Initializes a new instance of the <see cref="ZstandardStream" /> class by using the specified stream and compression mode.</summary>
         /// <param name="stream">The stream to which compressed data is written or from which data to decompress is read.</param>
         /// <param name="mode">One of the enumeration values that indicates whether to compress data to the stream or decompress data from the stream.</param>
@@ -163,8 +168,24 @@ public override async ValueTask DisposeAsync()
         private void ReleaseStateForDispose()
         {
             _stream = null!;
-            _encoder.Dispose();
-            _decoder.Dispose();
+
+            if (_encoderOwned)
+            {
+                _encoder.Dispose();
+            }
+            else
+            {
+                _encoder.Reset();
+            }
+
+            if (_decoderOwned)
+            {
+                _decoder.Dispose();
+            }
+            else
+            {
+                _decoder.Reset();
+            }
 
             byte[] buffer = _buffer;
             if (buffer != null)

src/libraries/System.IO.Compression.ZStandard/tests/CompressionStreamUnitTests.ZStandard.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Buffers;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -24,5 +25,80 @@ public override Stream CreateStream(Stream stream, ZLibCompressionOptions option
         public override int BufferSize => 1 << 16;
 
         protected override string CompressedTestFile(string uncompressedPath) => Path.Combine("ZstandardTestData", Path.GetFileName(uncompressedPath) + ".zst");
+
+        [Fact]
+        public void ZstandardStream_WithEncoder_CompressesData()
+        {
+            var encoder = new ZstandardEncoder(5, 10);
+            byte[] testData = CreateTestData();
+            using var input = new MemoryStream(testData);
+            using var output = new MemoryStream();
+
+            using (var compressionStream = new ZstandardStream(output, encoder, leaveOpen: true))
+            {
+                input.CopyTo(compressionStream);
+            }
+
+            // Verify data was compressed
+            Assert.True(output.Length > 0);
+            Assert.True(output.Length < testData.Length);
+
+            // Verify the encoder was reset, not disposed (should be reusable)
+            using var output2 = new MemoryStream();
+            using (var compressionStream2 = new ZstandardStream(output2, encoder, leaveOpen: true))
+            {
+                input.Position = 0;
+                input.CopyTo(compressionStream2);
+            }
+
+            Assert.True(output2.Length > 0);
+            encoder.Dispose(); // Clean up
+        }
+
+        [Fact]
+        public void ZstandardStream_WithDecoder_DecompressesData()
+        {
+            // First, create some compressed data
+            byte[] testData = CreateTestData();
+            byte[] compressedData = new byte[ZstandardEncoder.GetMaxCompressedLength(testData.Length)];
+            bool compressResult = ZstandardEncoder.TryCompress(testData, compressedData, out int compressedLength);
+            Assert.True(compressResult);
+
+            Array.Resize(ref compressedData, compressedLength);
+
+            var decoder = new ZstandardDecoder();
+            using var input = new MemoryStream(compressedData);
+            using var output = new MemoryStream();
+
+            using (var decompressionStream = new ZstandardStream(input, decoder, leaveOpen: true))
+            {
+                decompressionStream.CopyTo(output);
+            }
+
+            // Verify data was decompressed correctly
+            Assert.Equal(testData, output.ToArray());
+
+            // Verify the decoder was reset, not disposed (should be reusable)
+            using var output2 = new MemoryStream();
+            using (var decompressionStream2 = new ZstandardStream(input, decoder, leaveOpen: true))
+            {
+                input.Position = 0;
+                decompressionStream2.CopyTo(output2);
+            }
+
+            Assert.Equal(testData, output2.ToArray());
+            decoder.Dispose(); // Clean up
+        }
+
+        private static byte[] CreateTestData()
+        {
+            // Create some test data that compresses well
+            byte[] data = new byte[1000];
+            for (int i = 0; i < data.Length; i++)
+            {
+                data[i] = (byte)(i % 10); // Repeating pattern
+            }
+            return data;
+        }
     }
 }