Fix decompression performance by delaying stream wrapping

Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com>

.github/agents/copilot-agent.yml

@@ -0,0 +1,17 @@
+enabled: true
+agent:
+  name: copilot-coding-agent
+  allow:
+    - paths: ["src/**/*", "tests/**/*", "README.md", "AGENTS.md"]
+      actions: ["create", "modify", "delete"]
+  require_review_before_merge: true
+  required_approvals: 1
+  allowed_merge_strategies:
+    - squash
+    - merge
+  auto_merge_on_green: false
+  run_workflows: true
+notes: |
+  - This manifest expresses the policy for the Copilot coding agent in this repository.
+  - It does NOT install or authorize the agent; a repository admin must install the Copilot coding agent app and grant the repository the necessary permissions (contents: write, pull_requests: write, checks: write, actions: write/read, issues: write) to allow the agent to act.
+  - Keep allow paths narrow and prefer require_review_before_merge during initial rollout.

.github/workflows/dotnetcore.yml

@@ -19,7 +19,7 @@ jobs:
       with:
         dotnet-version: 8.0.x
     - run: dotnet run --project build/build.csproj
-    - uses: actions/upload-artifact@v4
+    - uses: actions/upload-artifact@v5
       with:
         name: ${{ matrix.os }}-sharpcompress.nupkg
         path: artifacts/*

AGENTS.md

@@ -26,6 +26,7 @@ applyTo: '**/*.cs'
 - Use CSharpier for all code formatting to ensure consistent style across the project.
 - Install CSharpier globally: `dotnet tool install -g csharpier`
 - Format files with: `dotnet csharpier format .`
+- **ALWAYS run `dotnet csharpier format .` after making code changes before committing.**
 - Configure your IDE to format on save using CSharpier.
 - CSharpier configuration can be customized via `.csharpierrc` file in the project root.
 - Trust CSharpier's opinionated formatting decisions to maintain consistency.

SharpCompress.sln

@@ -21,6 +21,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 		Directory.Packages.props = Directory.Packages.props
 		NuGet.config = NuGet.config
 		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
+		USAGE.md = USAGE.md
+		README.md = README.md
+		FORMATS.md = FORMATS.md
+		AGENTS.md = AGENTS.md
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.Performance", "tests\SharpCompress.Performance\SharpCompress.Performance.csproj", "{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}"

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -20,8 +20,9 @@ public static class ArchiveFactory
     public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
+        var factory = FindFactory<IArchiveFactory>(stream);
         stream = new SharpCompressStream(stream, bufferSize: readerOptions.BufferSize);
-        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
+        return factory.Open(stream, readerOptions);
     }
 
     public static IWritableArchive Create(ArchiveType type)

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -14,8 +14,9 @@ public class TarArchiveEntry : TarEntry, IArchiveEntry
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public virtual Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        Task.FromResult(OpenEntryStream());
+    public virtual Task<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => Task.FromResult(OpenEntryStream());
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -13,8 +13,9 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public virtual Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        Task.FromResult(OpenEntryStream());
+    public virtual Task<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => Task.FromResult(OpenEntryStream());
 
     #region IArchiveEntry Members
 

src/SharpCompress/Common/EntryStream.cs

@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 using System.IO.Compression;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -51,6 +53,15 @@ public class EntryStream : Stream, IStreamStack
         _completed = true;
     }
 
+    /// <summary>
+    /// Asynchronously skip the rest of the entry stream.
+    /// </summary>
+    public async Task SkipEntryAsync(CancellationToken cancellationToken = default)
+    {
+        await this.SkipAsync(cancellationToken).ConfigureAwait(false);
+        _completed = true;
+    }
+
     protected override void Dispose(bool disposing)
     {
         if (!(_completed || _reader.Cancelled))
@@ -83,6 +94,40 @@ public class EntryStream : Stream, IStreamStack
         _stream.Dispose();
     }
 
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask DisposeAsync()
+    {
+        if (!(_completed || _reader.Cancelled))
+        {
+            await SkipEntryAsync().ConfigureAwait(false);
+        }
+
+        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
+        if (_stream is IStreamStack ss)
+        {
+            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
+            {
+                await deflateStream.FlushAsync().ConfigureAwait(false);
+            }
+            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
+            {
+                await lzmaStream.FlushAsync().ConfigureAwait(false);
+            }
+        }
+
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(EntryStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+        await _stream.DisposeAsync().ConfigureAwait(false);
+    }
+#endif
+
     public override bool CanRead => true;
 
     public override bool CanSeek => false;
@@ -91,6 +136,8 @@ public class EntryStream : Stream, IStreamStack
 
     public override void Flush() { }
 
+    public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
     public override long Length => _stream.Length;
 
     public override long Position
@@ -109,6 +156,38 @@ public class EntryStream : Stream, IStreamStack
         return read;
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var read = await _stream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+        if (read <= 0)
+        {
+            _completed = true;
+        }
+        return read;
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var read = await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+        if (read <= 0)
+        {
+            _completed = true;
+        }
+        return read;
+    }
+#endif
+
     public override int ReadByte()
     {
         var value = _stream.ReadByte();

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -66,6 +66,36 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
         base.Dispose(disposing);
     }
 
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async System.Threading.Tasks.ValueTask DisposeAsync()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+
+        _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(TarReadOnlySubStream));
+#endif
+        // Ensure we read all remaining blocks for this entry.
+        await Stream.SkipAsync(BytesLeftToRead).ConfigureAwait(false);
+        _amountRead += BytesLeftToRead;
+
+        // If the last block wasn't a full 512 bytes, skip the remaining padding bytes.
+        var bytesInLastBlock = _amountRead % 512;
+
+        if (bytesInLastBlock != 0)
+        {
+            await Stream.SkipAsync(512 - bytesInLastBlock).ConfigureAwait(false);
+        }
+
+        // Call base Dispose instead of base DisposeAsync to avoid double disposal
+        base.Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+#endif
+
     private long BytesLeftToRead { get; set; }
 
     public override bool CanRead => true;
@@ -76,6 +106,10 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
 
     public override void Flush() { }
 
+    public override System.Threading.Tasks.Task FlushAsync(
+        System.Threading.CancellationToken cancellationToken
+    ) => System.Threading.Tasks.Task.CompletedTask;
+
     public override long Length => throw new NotSupportedException();
 
     public override long Position
@@ -114,6 +148,48 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
         return value;
     }
 
+    public override async System.Threading.Tasks.Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        System.Threading.CancellationToken cancellationToken
+    )
+    {
+        if (BytesLeftToRead < count)
+        {
+            count = (int)BytesLeftToRead;
+        }
+        var read = await Stream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+        if (read > 0)
+        {
+            BytesLeftToRead -= read;
+            _amountRead += read;
+        }
+        return read;
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
+        System.Memory<byte> buffer,
+        System.Threading.CancellationToken cancellationToken = default
+    )
+    {
+        if (BytesLeftToRead < buffer.Length)
+        {
+            buffer = buffer.Slice(0, (int)BytesLeftToRead);
+        }
+        var read = await Stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+        if (read > 0)
+        {
+            BytesLeftToRead -= read;
+            _amountRead += read;
+        }
+        return read;
+    }
+#endif
+
     public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
 
     public override void SetLength(long value) => throw new NotSupportedException();

src/SharpCompress/Compressors/Deflate/DeflateStream.cs

@@ -28,6 +28,7 @@ using System;
 using System.IO;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
@@ -289,6 +290,34 @@ public class DeflateStream : Stream, IStreamStack
         _baseStream.Flush();
     }
 
+    public override async Task FlushAsync(CancellationToken cancellationToken)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("DeflateStream");
+        }
+        await _baseStream.FlushAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask DisposeAsync()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+        _disposed = true;
+        if (_baseStream != null)
+        {
+            await _baseStream.DisposeAsync().ConfigureAwait(false);
+        }
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(DeflateStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+    }
+#endif
+
     /// <summary>
     /// Read data from the stream.
     /// </summary>
@@ -325,6 +354,36 @@ public class DeflateStream : Stream, IStreamStack
         return _baseStream.Read(buffer, offset, count);
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("DeflateStream");
+        }
+        return await _baseStream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("DeflateStream");
+        }
+        return await _baseStream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+    }
+#endif
+
     public override int ReadByte()
     {
         if (_disposed)
@@ -386,6 +445,36 @@ public class DeflateStream : Stream, IStreamStack
         _baseStream.Write(buffer, offset, count);
     }
 
+    public override async Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("DeflateStream");
+        }
+        await _baseStream
+            .WriteAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask WriteAsync(
+        ReadOnlyMemory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("DeflateStream");
+        }
+        await _baseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
+    }
+#endif
+
     public override void WriteByte(byte value)
     {
         if (_disposed)

src/SharpCompress/Compressors/Deflate/GZipStream.cs

@@ -30,6 +30,8 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
@@ -257,6 +259,15 @@ public class GZipStream : Stream, IStreamStack
         BaseStream.Flush();
     }
 
+    public override async Task FlushAsync(CancellationToken cancellationToken)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("GZipStream");
+        }
+        await BaseStream.FlushAsync(cancellationToken).ConfigureAwait(false);
+    }
+
     /// <summary>
     ///   Read and decompress data from the source stream.
     /// </summary>
@@ -309,6 +320,54 @@ public class GZipStream : Stream, IStreamStack
         return n;
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("GZipStream");
+        }
+        var n = await BaseStream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+
+        if (!_firstReadDone)
+        {
+            _firstReadDone = true;
+            FileName = BaseStream._GzipFileName;
+            Comment = BaseStream._GzipComment;
+            LastModified = BaseStream._GzipMtime;
+        }
+        return n;
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("GZipStream");
+        }
+        var n = await BaseStream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+
+        if (!_firstReadDone)
+        {
+            _firstReadDone = true;
+            FileName = BaseStream._GzipFileName;
+            Comment = BaseStream._GzipComment;
+            LastModified = BaseStream._GzipMtime;
+        }
+        return n;
+    }
+#endif
+
     /// <summary>
     ///   Calling this method always throws a <see cref="NotImplementedException"/>.
     /// </summary>
@@ -368,6 +427,77 @@ public class GZipStream : Stream, IStreamStack
         BaseStream.Write(buffer, offset, count);
     }
 
+    public override async Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("GZipStream");
+        }
+        if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
+        {
+            if (BaseStream._wantCompress)
+            {
+                // first write in compression, therefore, emit the GZIP header
+                _headerByteCount = EmitHeader();
+            }
+            else
+            {
+                throw new InvalidOperationException();
+            }
+        }
+
+        await BaseStream.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask WriteAsync(
+        ReadOnlyMemory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("GZipStream");
+        }
+        if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Undefined)
+        {
+            if (BaseStream._wantCompress)
+            {
+                // first write in compression, therefore, emit the GZIP header
+                _headerByteCount = EmitHeader();
+            }
+            else
+            {
+                throw new InvalidOperationException();
+            }
+        }
+
+        await BaseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
+    }
+
+    public override async ValueTask DisposeAsync()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+        _disposed = true;
+        if (BaseStream != null)
+        {
+            await BaseStream.DisposeAsync().ConfigureAwait(false);
+        }
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(GZipStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+    }
+#endif
+
     #endregion Stream methods
 
     public string? Comment

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -31,6 +31,8 @@ using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 
@@ -197,6 +199,69 @@ internal class ZlibBaseStream : Stream, IStreamStack
         } while (!done);
     }
 
+    public override async Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        // workitem 7159
+        // calculate the CRC on the unccompressed data  (before writing)
+        if (crc != null)
+        {
+            crc.SlurpBlock(buffer, offset, count);
+        }
+
+        if (_streamMode == StreamMode.Undefined)
+        {
+            _streamMode = StreamMode.Writer;
+        }
+        else if (_streamMode != StreamMode.Writer)
+        {
+            throw new ZlibException("Cannot Write after Reading.");
+        }
+
+        if (count == 0)
+        {
+            return;
+        }
+
+        // first reference of z property will initialize the private var _z
+        z.InputBuffer = buffer;
+        _z.NextIn = offset;
+        _z.AvailableBytesIn = count;
+        var done = false;
+        do
+        {
+            _z.OutputBuffer = workingBuffer;
+            _z.NextOut = 0;
+            _z.AvailableBytesOut = _workingBuffer.Length;
+            var rc = (_wantCompress) ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode);
+            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+            {
+                throw new ZlibException((_wantCompress ? "de" : "in") + "flating: " + _z.Message);
+            }
+
+            await _stream
+                .WriteAsync(
+                    _workingBuffer,
+                    0,
+                    _workingBuffer.Length - _z.AvailableBytesOut,
+                    cancellationToken
+                )
+                .ConfigureAwait(false);
+
+            done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
+
+            // If GZIP and de-compress, we're done when 8 bytes remain.
+            if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
+            {
+                done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
+            }
+        } while (!done);
+    }
+
     private void finish()
     {
         if (_z is null)
@@ -335,6 +400,111 @@ internal class ZlibBaseStream : Stream, IStreamStack
         }
     }
 
+    private async Task finishAsync(CancellationToken cancellationToken = default)
+    {
+        if (_z is null)
+        {
+            return;
+        }
+
+        if (_streamMode == StreamMode.Writer)
+        {
+            var done = false;
+            do
+            {
+                _z.OutputBuffer = workingBuffer;
+                _z.NextOut = 0;
+                _z.AvailableBytesOut = _workingBuffer.Length;
+                var rc =
+                    (_wantCompress) ? _z.Deflate(FlushType.Finish) : _z.Inflate(FlushType.Finish);
+
+                if (rc != ZlibConstants.Z_STREAM_END && rc != ZlibConstants.Z_OK)
+                {
+                    var verb = (_wantCompress ? "de" : "in") + "flating";
+                    if (_z.Message is null)
+                    {
+                        throw new ZlibException(String.Format("{0}: (rc = {1})", verb, rc));
+                    }
+                    throw new ZlibException(verb + ": " + _z.Message);
+                }
+
+                if (_workingBuffer.Length - _z.AvailableBytesOut > 0)
+                {
+                    await _stream
+                        .WriteAsync(
+                            _workingBuffer,
+                            0,
+                            _workingBuffer.Length - _z.AvailableBytesOut,
+                            cancellationToken
+                        )
+                        .ConfigureAwait(false);
+                }
+
+                done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0;
+
+                // If GZIP and de-compress, we're done when 8 bytes remain.
+                if (_flavor == ZlibStreamFlavor.GZIP && !_wantCompress)
+                {
+                    done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0);
+                }
+            } while (!done);
+
+            await FlushAsync(cancellationToken).ConfigureAwait(false);
+
+            // workitem 7159
+            if (_flavor == ZlibStreamFlavor.GZIP)
+            {
+                if (_wantCompress)
+                {
+                    // Emit the GZIP trailer: CRC32 and  size mod 2^32
+                    byte[] intBuf = new byte[4];
+                    BinaryPrimitives.WriteInt32LittleEndian(intBuf, crc.Crc32Result);
+                    await _stream.WriteAsync(intBuf, 0, 4, cancellationToken).ConfigureAwait(false);
+                    var c2 = (int)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
+                    BinaryPrimitives.WriteInt32LittleEndian(intBuf, c2);
+                    await _stream.WriteAsync(intBuf, 0, 4, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    throw new ZlibException("Writing with decompression is not supported.");
+                }
+            }
+        }
+        // workitem 7159
+        else if (_streamMode == StreamMode.Reader)
+        {
+            if (_flavor == ZlibStreamFlavor.GZIP)
+            {
+                if (!_wantCompress)
+                {
+                    // workitem 8501: handle edge case (decompress empty stream)
+                    if (_z.TotalBytesOut == 0L)
+                    {
+                        return;
+                    }
+
+                    // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
+                    byte[] trailer = new byte[8];
+
+                    // workitem 8679
+                    if (_z.AvailableBytesIn != 8)
+                    {
+                        // Make sure we have read to the end of the stream
+                        _z.InputBuffer.AsSpan(_z.NextIn, _z.AvailableBytesIn).CopyTo(trailer);
+                        var bytesNeeded = 8 - _z.AvailableBytesIn;
+                        var bytesRead = await _stream
+                            .ReadAsync(trailer, _z.AvailableBytesIn, bytesNeeded, cancellationToken)
+                            .ConfigureAwait(false);
+                    }
+                }
+                else
+                {
+                    throw new ZlibException("Reading with compression is not supported.");
+                }
+            }
+        }
+    }
+
     private void end()
     {
         if (z is null)
@@ -382,6 +552,38 @@ internal class ZlibBaseStream : Stream, IStreamStack
         }
     }
 
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask DisposeAsync()
+    {
+        if (isDisposed)
+        {
+            return;
+        }
+        isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(ZlibBaseStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+        if (_stream is null)
+        {
+            return;
+        }
+        try
+        {
+            await finishAsync().ConfigureAwait(false);
+        }
+        finally
+        {
+            end();
+            if (_stream != null)
+            {
+                await _stream.DisposeAsync().ConfigureAwait(false);
+                _stream = null;
+            }
+        }
+    }
+#endif
+
     public override void Flush()
     {
         _stream.Flush();
@@ -390,6 +592,14 @@ internal class ZlibBaseStream : Stream, IStreamStack
         z.AvailableBytesIn = 0;
     }
 
+    public override async Task FlushAsync(CancellationToken cancellationToken)
+    {
+        await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);
+        //rewind the buffer
+        ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
+        z.AvailableBytesIn = 0;
+    }
+
     public override Int64 Seek(Int64 offset, SeekOrigin origin) =>
         throw new NotSupportedException();
 
@@ -436,6 +646,31 @@ internal class ZlibBaseStream : Stream, IStreamStack
         return _encoding.GetString(buffer, 0, buffer.Length);
     }
 
+    private async Task<string> ReadZeroTerminatedStringAsync(CancellationToken cancellationToken)
+    {
+        var list = new List<byte>();
+        var done = false;
+        do
+        {
+            // workitem 7740
+            var n = await _stream.ReadAsync(_buf1, 0, 1, cancellationToken).ConfigureAwait(false);
+            if (n != 1)
+            {
+                throw new ZlibException("Unexpected EOF reading GZIP header.");
+            }
+            if (_buf1[0] == 0)
+            {
+                done = true;
+            }
+            else
+            {
+                list.Add(_buf1[0]);
+            }
+        } while (!done);
+        var buffer = list.ToArray();
+        return _encoding.GetString(buffer, 0, buffer.Length);
+    }
+
     private int _ReadAndValidateGzipHeader()
     {
         var totalBytesRead = 0;
@@ -494,6 +729,68 @@ internal class ZlibBaseStream : Stream, IStreamStack
         return totalBytesRead;
     }
 
+    private async Task<int> _ReadAndValidateGzipHeaderAsync(CancellationToken cancellationToken)
+    {
+        var totalBytesRead = 0;
+
+        // read the header on the first read
+        byte[] header = new byte[10];
+        var n = await _stream.ReadAsync(header, 0, 10, cancellationToken).ConfigureAwait(false);
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (n == 0)
+        {
+            return 0;
+        }
+
+        if (n != 10)
+        {
+            throw new ZlibException("Not a valid GZIP stream.");
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            throw new ZlibException("Bad GZIP header.");
+        }
+
+        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
+        _GzipMtime = TarHeader.EPOCH.AddSeconds(timet);
+        totalBytesRead += n;
+        if ((header[3] & 0x04) == 0x04)
+        {
+            // read and discard extra field
+            n = await _stream.ReadAsync(header, 0, 2, cancellationToken).ConfigureAwait(false); // 2-byte length field
+            totalBytesRead += n;
+
+            var extraLength = (short)(header[0] + header[1] * 256);
+            var extra = new byte[extraLength];
+            n = await _stream
+                .ReadAsync(extra, 0, extra.Length, cancellationToken)
+                .ConfigureAwait(false);
+            if (n != extraLength)
+            {
+                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+            }
+            totalBytesRead += n;
+        }
+        if ((header[3] & 0x08) == 0x08)
+        {
+            _GzipFileName = await ReadZeroTerminatedStringAsync(cancellationToken)
+                .ConfigureAwait(false);
+        }
+        if ((header[3] & 0x10) == 0x010)
+        {
+            _GzipComment = await ReadZeroTerminatedStringAsync(cancellationToken)
+                .ConfigureAwait(false);
+        }
+        if ((header[3] & 0x02) == 0x02)
+        {
+            await _stream.ReadAsync(_buf1, 0, 1, cancellationToken).ConfigureAwait(false); // CRC16, ignore
+        }
+
+        return totalBytesRead;
+    }
+
     public override Int32 Read(Byte[] buffer, Int32 offset, Int32 count)
     {
         // According to MS documentation, any implementation of the IO.Stream.Read function must:
@@ -678,6 +975,220 @@ internal class ZlibBaseStream : Stream, IStreamStack
         return rc;
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        // According to MS documentation, any implementation of the IO.Stream.Read function must:
+        // (a) throw an exception if offset & count reference an invalid part of the buffer,
+        //     or if count < 0, or if buffer is null
+        // (b) return 0 only upon EOF, or if count = 0
+        // (c) if not EOF, then return at least 1 byte, up to <count> bytes
+
+        if (_streamMode == StreamMode.Undefined)
+        {
+            if (!_stream.CanRead)
+            {
+                throw new ZlibException("The stream is not readable.");
+            }
+
+            // for the first read, set up some controls.
+            _streamMode = StreamMode.Reader;
+
+            // (The first reference to _z goes through the private accessor which
+            // may initialize it.)
+            z.AvailableBytesIn = 0;
+            if (_flavor == ZlibStreamFlavor.GZIP)
+            {
+                _gzipHeaderByteCount = await _ReadAndValidateGzipHeaderAsync(cancellationToken)
+                    .ConfigureAwait(false);
+
+                // workitem 8501: handle edge case (decompress empty stream)
+                if (_gzipHeaderByteCount == 0)
+                {
+                    return 0;
+                }
+            }
+        }
+
+        if (_streamMode != StreamMode.Reader)
+        {
+            throw new ZlibException("Cannot Read after Writing.");
+        }
+
+        var rc = 0;
+
+        // set up the output of the deflate/inflate codec:
+        _z.OutputBuffer = buffer;
+        _z.NextOut = offset;
+        _z.AvailableBytesOut = count;
+
+        if (count == 0)
+        {
+            return 0;
+        }
+        if (nomoreinput && _wantCompress)
+        {
+            // no more input data available; therefore we flush to
+            // try to complete the read
+            rc = _z.Deflate(FlushType.Finish);
+
+            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+            {
+                throw new ZlibException(
+                    String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message)
+                );
+            }
+
+            rc = (count - _z.AvailableBytesOut);
+
+            // calculate CRC after reading
+            if (crc != null)
+            {
+                crc.SlurpBlock(buffer, offset, rc);
+            }
+
+            return rc;
+        }
+        if (buffer is null)
+        {
+            throw new ArgumentNullException(nameof(buffer));
+        }
+        if (count < 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(count));
+        }
+        if (offset < buffer.GetLowerBound(0))
+        {
+            throw new ArgumentOutOfRangeException(nameof(offset));
+        }
+        if ((offset + count) > buffer.GetLength(0))
+        {
+            throw new ArgumentOutOfRangeException(nameof(count));
+        }
+
+        // This is necessary in case _workingBuffer has been resized. (new byte[])
+        // (The first reference to _workingBuffer goes through the private accessor which
+        // may initialize it.)
+        _z.InputBuffer = workingBuffer;
+
+        do
+        {
+            // need data in _workingBuffer in order to deflate/inflate.  Here, we check if we have any.
+            if ((_z.AvailableBytesIn == 0) && (!nomoreinput))
+            {
+                // No data available, so try to Read data from the captive stream.
+                _z.NextIn = 0;
+                _z.AvailableBytesIn = await _stream
+                    .ReadAsync(_workingBuffer, 0, _workingBuffer.Length, cancellationToken)
+                    .ConfigureAwait(false);
+                if (_z.AvailableBytesIn == 0)
+                {
+                    nomoreinput = true;
+                }
+            }
+
+            // we have data in InputBuffer; now compress or decompress as appropriate
+            rc = (_wantCompress) ? _z.Deflate(_flushMode) : _z.Inflate(_flushMode);
+
+            if (nomoreinput && (rc == ZlibConstants.Z_BUF_ERROR))
+            {
+                return 0;
+            }
+
+            if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+            {
+                throw new ZlibException(
+                    String.Format(
+                        "{0}flating:  rc={1}  msg={2}",
+                        (_wantCompress ? "de" : "in"),
+                        rc,
+                        _z.Message
+                    )
+                );
+            }
+
+            if (
+                (nomoreinput || rc == ZlibConstants.Z_STREAM_END) && (_z.AvailableBytesOut == count)
+            )
+            {
+                break; // nothing more to read
+            }
+        } //while (_z.AvailableBytesOut == count && rc == ZlibConstants.Z_OK);
+        while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
+
+        // workitem 8557
+        // is there more room in output?
+        if (_z.AvailableBytesOut > 0)
+        {
+            if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)
+            {
+                // deferred
+            }
+
+            // are we completely done reading?
+            if (nomoreinput)
+            {
+                // and in compression?
+                if (_wantCompress)
+                {
+                    // no more input data available; therefore we flush to
+                    // try to complete the read
+                    rc = _z.Deflate(FlushType.Finish);
+
+                    if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END)
+                    {
+                        throw new ZlibException(
+                            String.Format("Deflating:  rc={0}  msg={1}", rc, _z.Message)
+                        );
+                    }
+                }
+            }
+        }
+
+        rc = (count - _z.AvailableBytesOut);
+
+        // calculate CRC after reading
+        if (crc != null)
+        {
+            crc.SlurpBlock(buffer, offset, rc);
+        }
+
+        if (rc == ZlibConstants.Z_STREAM_END && z.AvailableBytesIn != 0 && !_wantCompress)
+        {
+            //rewind the buffer
+            ((IStreamStack)this).Rewind(z.AvailableBytesIn); //unused
+            z.AvailableBytesIn = 0;
+        }
+
+        return rc;
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Use ArrayPool to rent a buffer and delegate to byte[] ReadAsync
+        byte[] array = System.Buffers.ArrayPool<byte>.Shared.Rent(buffer.Length);
+        try
+        {
+            int read = await ReadAsync(array, 0, buffer.Length, cancellationToken)
+                .ConfigureAwait(false);
+            array.AsSpan(0, read).CopyTo(buffer.Span);
+            return read;
+        }
+        finally
+        {
+            System.Buffers.ArrayPool<byte>.Shared.Return(array);
+        }
+    }
+#endif
+
     public override Boolean CanRead => _stream.CanRead;
 
     public override Boolean CanSeek => _stream.CanSeek;

src/SharpCompress/Compressors/Deflate/ZlibStream.cs

@@ -28,6 +28,8 @@
 using System;
 using System.IO;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Compressors.Deflate;
@@ -266,6 +268,34 @@ public class ZlibStream : Stream, IStreamStack
         _baseStream.Flush();
     }
 
+    public override async Task FlushAsync(CancellationToken cancellationToken)
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("ZlibStream");
+        }
+        await _baseStream.FlushAsync(cancellationToken).ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask DisposeAsync()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+        _disposed = true;
+        if (_baseStream != null)
+        {
+            await _baseStream.DisposeAsync().ConfigureAwait(false);
+        }
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(ZlibStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+    }
+#endif
+
     /// <summary>
     /// Read data from the stream.
     /// </summary>
@@ -301,6 +331,36 @@ public class ZlibStream : Stream, IStreamStack
         return _baseStream.Read(buffer, offset, count);
     }
 
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("ZlibStream");
+        }
+        return await _baseStream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("ZlibStream");
+        }
+        return await _baseStream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+    }
+#endif
+
     public override int ReadByte()
     {
         if (_disposed)
@@ -355,6 +415,36 @@ public class ZlibStream : Stream, IStreamStack
         _baseStream.Write(buffer, offset, count);
     }
 
+    public override async Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("ZlibStream");
+        }
+        await _baseStream
+            .WriteAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask WriteAsync(
+        ReadOnlyMemory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_disposed)
+        {
+            throw new ObjectDisposedException("ZlibStream");
+        }
+        await _baseStream.WriteAsync(buffer, cancellationToken).ConfigureAwait(false);
+    }
+#endif
+
     public override void WriteByte(byte value)
     {
         if (_disposed)

src/SharpCompress/IO/SourceStream.cs

@@ -337,7 +337,6 @@ public class SourceStream : Stream, IStreamStack
 
         return total - count;
     }
-
 #endif
 
     public override void Close()

src/SharpCompress/Readers/AbstractReader.cs

@@ -210,10 +210,15 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader, IReaderExtracti
     internal async Task WriteAsync(Stream writeStream, CancellationToken cancellationToken)
     {
         var streamListener = this as IReaderExtractionListener;
+#if NETFRAMEWORK || NETSTANDARD2_0
         using Stream s = OpenEntryStream();
-        await s
-            .TransferToAsync(writeStream, Entry, streamListener, cancellationToken)
+        await s.TransferToAsync(writeStream, Entry, streamListener, cancellationToken)
             .ConfigureAwait(false);
+#else
+        await using Stream s = OpenEntryStream();
+        await s.TransferToAsync(writeStream, Entry, streamListener, cancellationToken)
+            .ConfigureAwait(false);
+#endif
     }
 
     public EntryStream OpenEntryStream()

src/SharpCompress/Utility.cs

@@ -91,6 +91,31 @@ internal static class Utility
         while (source.Read(buffer.Memory.Span) > 0) { }
     }
 
+    public static async Task SkipAsync(
+        this Stream source,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var array = ArrayPool<byte>.Shared.Rent(TEMP_BUFFER_SIZE);
+        try
+        {
+            while (true)
+            {
+                var read = await source
+                    .ReadAsync(array, 0, array.Length, cancellationToken)
+                    .ConfigureAwait(false);
+                if (read <= 0)
+                {
+                    break;
+                }
+            }
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(array);
+        }
+    }
+
     public static DateTime DosDateToDateTime(ushort iDate, ushort iTime)
     {
         var year = (iDate / 512) + 1980;
@@ -239,7 +264,7 @@ internal static class Utility
             while (
                 await ReadTransferBlockAsync(source, array, maxReadSize, cancellationToken)
                     .ConfigureAwait(false)
-                is var (success, count)
+                    is var (success, count)
                 && success
             )
             {

tests/SharpCompress.Test/GZip/AsyncTests.cs

@@ -6,12 +6,11 @@ using System.Threading.Tasks;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Writers;
 using Xunit;
 
-namespace SharpCompress.Test;
+namespace SharpCompress.Test.GZip;
 
 public class AsyncTests : TestBase
 {
@@ -19,7 +18,11 @@ public class AsyncTests : TestBase
     public async Task Reader_Async_Extract_All()
     {
         var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz");
+#if NETFRAMEWORK
         using var stream = File.OpenRead(testArchive);
+#else
+        await using var stream = File.OpenRead(testArchive);
+#endif
         using var reader = ReaderFactory.Open(stream);
 
         await reader.WriteAllToDirectoryAsync(
@@ -28,7 +31,11 @@ public class AsyncTests : TestBase
         );
 
         // Just verify some files were extracted
-        var extractedFiles = Directory.GetFiles(SCRATCH_FILES_PATH, "*", SearchOption.AllDirectories);
+        var extractedFiles = Directory.GetFiles(
+            SCRATCH_FILES_PATH,
+            "*",
+            SearchOption.AllDirectories
+        );
         Assert.True(extractedFiles.Length > 0, "No files were extracted");
     }
 
@@ -36,7 +43,11 @@ public class AsyncTests : TestBase
     public async Task Reader_Async_Extract_Single_Entry()
     {
         var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz");
+#if NETFRAMEWORK
         using var stream = File.OpenRead(testArchive);
+#else
+        await using var stream = File.OpenRead(testArchive);
+#endif
         using var reader = ReaderFactory.Open(stream);
 
         while (reader.MoveToNextEntry())
@@ -45,8 +56,11 @@ public class AsyncTests : TestBase
             {
                 var outputPath = Path.Combine(SCRATCH_FILES_PATH, reader.Entry.Key!);
                 Directory.CreateDirectory(Path.GetDirectoryName(outputPath)!);
-
+#if NETFRAMEWORK
                 using var outputStream = File.Create(outputPath);
+#else
+                await using var outputStream = File.Create(outputPath);
+#endif
                 await reader.WriteEntryToAsync(outputStream);
                 break; // Just test one entry
             }
@@ -61,7 +75,11 @@ public class AsyncTests : TestBase
 
         foreach (var entry in archive.Entries.Where(e => !e.IsDirectory).Take(1))
         {
+#if NETFRAMEWORK
             using var entryStream = await entry.OpenEntryStreamAsync();
+#else
+            await using var entryStream = await entry.OpenEntryStreamAsync();
+#endif
             Assert.NotNull(entryStream);
             Assert.True(entryStream.CanRead);
 
@@ -107,7 +125,11 @@ public class AsyncTests : TestBase
         );
 
         // Just verify some files were extracted
-        var extractedFiles = Directory.GetFiles(SCRATCH_FILES_PATH, "*", SearchOption.AllDirectories);
+        var extractedFiles = Directory.GetFiles(
+            SCRATCH_FILES_PATH,
+            "*",
+            SearchOption.AllDirectories
+        );
         Assert.True(extractedFiles.Length > 0, "No files were extracted");
     }
 
@@ -130,4 +152,87 @@ public class AsyncTests : TestBase
         Assert.True(File.Exists(outputPath));
         Assert.True(new FileInfo(outputPath).Length > 0);
     }
+
+    [Fact]
+    public async Task EntryStream_ReadAsync_Works()
+    {
+        var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz");
+        using var stream = File.OpenRead(testArchive);
+        using var reader = ReaderFactory.Open(stream);
+
+        while (reader.MoveToNextEntry())
+        {
+            if (!reader.Entry.IsDirectory)
+            {
+                using var entryStream = reader.OpenEntryStream();
+                var buffer = new byte[4096];
+                var totalRead = 0;
+                int bytesRead;
+
+                // Test ReadAsync on EntryStream
+                while ((bytesRead = await entryStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
+                {
+                    totalRead += bytesRead;
+                }
+
+                Assert.True(totalRead > 0, "Should have read some data from entry stream");
+                break; // Test just one entry
+            }
+        }
+    }
+
+    [Fact]
+    public async Task CompressionStream_Async_ReadWrite()
+    {
+        var testData = new byte[1024];
+        new Random(42).NextBytes(testData);
+
+        var compressedPath = Path.Combine(SCRATCH_FILES_PATH, "async_compressed.gz");
+
+        // Test async write with GZipStream
+        using (var fileStream = File.Create(compressedPath))
+        using (
+            var gzipStream = new Compressors.Deflate.GZipStream(
+                fileStream,
+                Compressors.CompressionMode.Compress
+            )
+        )
+        {
+            await gzipStream.WriteAsync(testData, 0, testData.Length);
+            await gzipStream.FlushAsync();
+        }
+
+        Assert.True(File.Exists(compressedPath));
+        Assert.True(new FileInfo(compressedPath).Length > 0);
+
+        // Test async read with GZipStream
+        using (var fileStream = File.OpenRead(compressedPath))
+        using (
+            var gzipStream = new Compressors.Deflate.GZipStream(
+                fileStream,
+                Compressors.CompressionMode.Decompress
+            )
+        )
+        {
+            var decompressed = new byte[testData.Length];
+            var totalRead = 0;
+            int bytesRead;
+            while (
+                totalRead < decompressed.Length
+                && (
+                    bytesRead = await gzipStream.ReadAsync(
+                        decompressed,
+                        totalRead,
+                        decompressed.Length - totalRead
+                    )
+                ) > 0
+            )
+            {
+                totalRead += bytesRead;
+            }
+
+            Assert.Equal(testData.Length, totalRead);
+            Assert.Equal(testData, decompressed);
+        }
+    }
 }

tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs

@@ -0,0 +1,99 @@
+using System.IO;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.GZip;
+using SharpCompress.Test.Mocks;
+using Xunit;
+
+namespace SharpCompress.Test.GZip;
+
+public class GZipReaderAsyncTests : ReaderTests
+{
+    public GZipReaderAsyncTests() => UseExtensionInsteadOfNameToVerify = true;
+
+    [Fact]
+    public async Task GZip_Reader_Generic_Async() =>
+        await ReadAsync("Tar.tar.gz", CompressionType.GZip);
+
+    [Fact]
+    public async Task GZip_Reader_Generic2_Async()
+    {
+        //read only as GZip item
+        using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"));
+        using var reader = GZipReader.Open(new SharpCompressStream(stream));
+        while (reader.MoveToNextEntry())
+        {
+            Assert.NotEqual(0, reader.Entry.Size);
+            Assert.NotEqual(0, reader.Entry.Crc);
+
+            // Use async overload for reading the entry
+            if (!reader.Entry.IsDirectory)
+            {
+                using var entryStream = reader.OpenEntryStream();
+                using var ms = new MemoryStream();
+                await entryStream.CopyToAsync(ms);
+            }
+        }
+    }
+
+    protected async Task ReadAsync(
+        string testArchive,
+        CompressionType expectedCompression,
+        ReaderOptions? options = null
+    )
+    {
+        testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
+
+        options ??= new ReaderOptions() { BufferSize = 0x20000 };
+
+        options.LeaveStreamOpen = true;
+        await ReadImplAsync(testArchive, expectedCompression, options);
+
+        options.LeaveStreamOpen = false;
+        await ReadImplAsync(testArchive, expectedCompression, options);
+        VerifyFiles();
+    }
+
+    private async Task ReadImplAsync(
+        string testArchive,
+        CompressionType expectedCompression,
+        ReaderOptions options
+    )
+    {
+        using var file = File.OpenRead(testArchive);
+        using var protectedStream = SharpCompressStream.Create(
+            new ForwardOnlyStream(file, options.BufferSize),
+            leaveOpen: true,
+            throwOnDispose: true,
+            bufferSize: options.BufferSize
+        );
+        using var testStream = new TestStream(protectedStream);
+        using (var reader = ReaderFactory.Open(testStream, options))
+        {
+            await UseReaderAsync(reader, expectedCompression);
+            protectedStream.ThrowOnDispose = false;
+            Assert.False(testStream.IsDisposed, $"{nameof(testStream)} prematurely closed");
+        }
+
+        var message =
+            $"{nameof(options.LeaveStreamOpen)} is set to '{options.LeaveStreamOpen}', so {nameof(testStream.IsDisposed)} should be set to '{!testStream.IsDisposed}', but is set to {testStream.IsDisposed}";
+        Assert.True(options.LeaveStreamOpen != testStream.IsDisposed, message);
+    }
+
+    private async Task UseReaderAsync(IReader reader, CompressionType expectedCompression)
+    {
+        while (reader.MoveToNextEntry())
+        {
+            if (!reader.Entry.IsDirectory)
+            {
+                Assert.Equal(expectedCompression, reader.Entry.CompressionType);
+                await reader.WriteEntryToDirectoryAsync(
+                    SCRATCH_FILES_PATH,
+                    new ExtractionOptions { ExtractFullPath = true, Overwrite = true }
+                );
+            }
+        }
+    }
+}