Merge branch 'adam/update-docs'

updates from review
Merge pull request #1120 from adamhathcock/adam/update-docs
2026-02-12 05:25:03 +00:00 · 2026-01-07 16:18:51 +00:00 · 2026-01-07 16:18:27 +00:00 · 2026-01-07 16:12:51 +00:00 · 2026-01-07 16:10:55 +00:00 · 2026-01-07 15:56:38 +00:00
14 changed files with 718 additions and 302 deletions
--- a/OLD_CHANGELOG.md
+++ b/OLD_CHANGELOG.md
@@ -0,0 +1,142 @@
+
+# Version Log
+
+* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
+
+## Version 0.18
+
+* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
+
+## Version 0.17.1
+
+* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
+
+## Version 0.17.0
+
+* New - Full LZip support! Can read and write LZip files and Tars inside LZip files. [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)
+* New - XZ read support! Can read XZ files and Tars inside XZ files. [XZ in SharpCompress #91](https://github.com/adamhathcock/sharpcompress/issues/94)
+* Fix - [Regression - zip file writing on seekable streams always assumed stream start was 0. Introduced with Zip64 writing.](https://github.com/adamhathcock/sharpcompress/issues/244)
+* Fix - [Zip files with post-data descriptors can be properly skipped via decompression](https://github.com/adamhathcock/sharpcompress/issues/162)
+
+## Version 0.16.2
+
+* Fix [.NET 3.5 should support files and cryptography (was a regression from 0.16.0)](https://github.com/adamhathcock/sharpcompress/pull/251)
+* Fix [Zip per entry compression customization wrote the wrong method into the zip archive](https://github.com/adamhathcock/sharpcompress/pull/249)
+
+## Version 0.16.1
+
+* Fix [Preserve compression method when getting a compressed stream](https://github.com/adamhathcock/sharpcompress/pull/235)
+* Fix [RAR entry key normalization fix](https://github.com/adamhathcock/sharpcompress/issues/201)
+
+## Version 0.16.0
+
+* Breaking - [Progress Event Tracking rethink](https://github.com/adamhathcock/sharpcompress/pull/226)
+* Update to VS2017 - [VS2017](https://github.com/adamhathcock/sharpcompress/pull/231) - Framework targets have been changed.
+* New - [Add Zip64 writing](https://github.com/adamhathcock/sharpcompress/pull/211)
+* [Fix invalid/mismatching Zip version flags.](https://github.com/adamhathcock/sharpcompress/issues/164) - This allows nuget/System.IO.Packaging to read zip files generated by SharpCompress
+* [Fix 7Zip directory hiding](https://github.com/adamhathcock/sharpcompress/pull/215/files)
+* [Verify RAR CRC headers](https://github.com/adamhathcock/sharpcompress/pull/220)
+
+## Version 0.15.2
+
+* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
+
+## Version 0.15.1
+
+* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
+
+## Version 0.15.0
+
+* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
+
+## Version 0.14.1
+
+* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
+* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
+* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
+
+## Version 0.14.0
+
+* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
+
+## Version 0.13.1
+
+* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
+* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
+
+## Version 0.13.0
+
+* Breaking change: Big refactor of Options on API.
+* 7Zip supports Deflate
+
+## Version 0.12.4
+
+* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
+* Try to fix frameworks again by copying targets from JSON.NET
+
+## Version 0.12.3
+
+* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
+* Maybe all profiles will work with project.json now
+
+## Version 0.12.2
+
+* Support Profile 259 again
+
+## Version 0.12.1
+
+* Support Silverlight 5
+
+## Version 0.12.0
+
+* .NET Core RTM!
+* Bug fix for Tar long paths
+
+## Version 0.11.6
+
+* Bug fix for global header in Tar
+* Writers now have a leaveOpen `bool` overload. They won't close streams if not-requested to.
+
+## Version 0.11.5
+
+* Bug fix in Skip method
+
+## Version 0.11.4
+
+* SharpCompress is now endian neutral (matters for Mono platforms)
+* Fix for Inflate (need to change implementation)
+* Fixes for RAR detection
+
+## Version 0.11.1
+
+* Added Cancel on IReader
+* Removed .NET 2.0 support and LinqBridge dependency
+
+## Version 0.11
+
+* Been over a year, contains mainly fixes from contributors!
+* Possible breaking change: ArchiveEncoding is UTF8 by default now.
+* TAR supports writing long names using longlink
+* RAR Protect Header added
+
+## Version 0.10.3
+
+* Finally fixed Disposal issue when creating a new archive with the Archive API
+
+## Version 0.10.2
+
+* Fixed Rar Header reading for invalid extended time headers.
+* Windows Store assembly is now strong named
+* Known issues with Long Tar names being worked on
+* Updated to VS2013
+* Portable targets SL5 and Windows Phone 8 (up from SL4 and WP7)
+
+## Version 0.10.1
+
+* Fixed 7Zip extraction performance problem
+
+## Version 0.10:
+
+* Added support for RAR Decryption (thanks to https://github.com/hrasyid)
+* Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
+* Built in Release (I think)
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@ SharpCompress is a compression library in pure C# for .NET Framework 4.8, .NET 8

 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).

-**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [Async Usage](#async-usage) section below.
+**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [USAGE.md](USAGE.md#async-examples) for examples.

 GitHub Actions Build -
 [![SharpCompress](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml/badge.svg)](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml)
@@ -34,235 +34,11 @@ Hi everyone. I hope you're using SharpCompress and finding it useful. Please giv

 Please do not email me directly to ask for help. If you think there is a real issue, please report it here.

-## Async Usage
-
-SharpCompress now provides full async/await support for all I/O operations, allowing for better performance and scalability in modern applications.
-
-### Async Reading Examples
-
-Extract entries asynchronously:
-```csharp
-using (Stream stream = File.OpenRead("archive.zip"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        if (!reader.Entry.IsDirectory)
-        {
-            // Async extraction
-            await reader.WriteEntryToDirectoryAsync(
-                @"C:\temp",
-                new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-                cancellationToken
-            );
-        }
-    }
-}
-```
-
-Extract all entries to directory asynchronously:
-```csharp
-using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    await reader.WriteAllToDirectoryAsync(
-        @"C:\temp",
-        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-        cancellationToken
-    );
-}
-```
-
-Open entry stream asynchronously:
-```csharp
-using (var archive = ZipArchive.Open("archive.zip"))
-{
-    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
-    {
-        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
-        {
-            // Process stream asynchronously
-            await entryStream.CopyToAsync(outputStream, cancellationToken);
-        }
-    }
-}
-```
-
-### Async Writing Examples
-
-Write files asynchronously:
-```csharp
-using (Stream stream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    await writer.WriteAsync("file1.txt", fileStream, DateTime.Now, cancellationToken);
-}
-```
-
-Write all files from directory asynchronously:
-```csharp
-using (Stream stream = File.OpenWrite("output.tar.gz"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
-{
-    await writer.WriteAllAsync(@"D:\files", "*", SearchOption.AllDirectories, cancellationToken);
-}
-```
-
-All async methods support `CancellationToken` for graceful cancellation of long-running operations.
-
 ## Want to contribute?

 I'm always looking for help or ideas. Please submit code or email with ideas. Unfortunately, just letting me know you'd like to help is not enough because I really have no overall plan of what needs to be done. I'll definitely accept code submissions and add you as a member of the project!

-## TODOs (always lots)
-
-* RAR 5 decryption crc check support
-* 7Zip writing
-* Zip64 (Need writing and extend Reading)
-* Multi-volume Zip support.
-* ZStandard writing
-
-## Version Log
-
-* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
-
-### Version 0.18
-
-* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
-
-### Version 0.17.1
-
-* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
-
-### Version 0.17.0
-
-* New - Full LZip support! Can read and write LZip files and Tars inside LZip files. [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)
-* New - XZ read support! Can read XZ files and Tars inside XZ files. [XZ in SharpCompress #91](https://github.com/adamhathcock/sharpcompress/issues/94)
-* Fix - [Regression - zip file writing on seekable streams always assumed stream start was 0. Introduced with Zip64 writing.](https://github.com/adamhathcock/sharpcompress/issues/244)
-* Fix - [Zip files with post-data descriptors can be properly skipped via decompression](https://github.com/adamhathcock/sharpcompress/issues/162)
-
-### Version 0.16.2
-
-* Fix [.NET 3.5 should support files and cryptography (was a regression from 0.16.0)](https://github.com/adamhathcock/sharpcompress/pull/251)
-* Fix [Zip per entry compression customization wrote the wrong method into the zip archive](https://github.com/adamhathcock/sharpcompress/pull/249)
-
-### Version 0.16.1
-
-* Fix [Preserve compression method when getting a compressed stream](https://github.com/adamhathcock/sharpcompress/pull/235)
-* Fix [RAR entry key normalization fix](https://github.com/adamhathcock/sharpcompress/issues/201)
-
-### Version 0.16.0
-
-* Breaking - [Progress Event Tracking rethink](https://github.com/adamhathcock/sharpcompress/pull/226)
-* Update to VS2017 - [VS2017](https://github.com/adamhathcock/sharpcompress/pull/231) - Framework targets have been changed.
-* New - [Add Zip64 writing](https://github.com/adamhathcock/sharpcompress/pull/211)
-* [Fix invalid/mismatching Zip version flags.](https://github.com/adamhathcock/sharpcompress/issues/164) - This allows nuget/System.IO.Packaging to read zip files generated by SharpCompress
-* [Fix 7Zip directory hiding](https://github.com/adamhathcock/sharpcompress/pull/215/files)
-* [Verify RAR CRC headers](https://github.com/adamhathcock/sharpcompress/pull/220)
-
-### Version 0.15.2
-
-* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
-
-### Version 0.15.1
-
-* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
-
-### Version 0.15.0
-
-* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
-
-### Version 0.14.1
-
-* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
-* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
-* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
-
-### Version 0.14.0
-
-* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
-
-### Version 0.13.1
-
-* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
-* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
-
-### Version 0.13.0
-
-* Breaking change: Big refactor of Options on API.
-* 7Zip supports Deflate
-
-### Version 0.12.4
-
-* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
-* Try to fix frameworks again by copying targets from JSON.NET
-
-### Version 0.12.3
-
-* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
-* Maybe all profiles will work with project.json now
-
-### Version 0.12.2
-
-* Support Profile 259 again
-
-### Version 0.12.1
-
-* Support Silverlight 5
-
-### Version 0.12.0
-
-* .NET Core RTM!
-* Bug fix for Tar long paths
-
-### Version 0.11.6
-
-* Bug fix for global header in Tar
-* Writers now have a leaveOpen `bool` overload. They won't close streams if not-requested to.
-
-### Version 0.11.5
-
-* Bug fix in Skip method
-
-### Version 0.11.4
-
-* SharpCompress is now endian neutral (matters for Mono platforms)
-* Fix for Inflate (need to change implementation)
-* Fixes for RAR detection
-
-### Version 0.11.1
-
-* Added Cancel on IReader
-* Removed .NET 2.0 support and LinqBridge dependency
-
-### Version 0.11
-
-* Been over a year, contains mainly fixes from contributors!
-* Possible breaking change: ArchiveEncoding is UTF8 by default now.
-* TAR supports writing long names using longlink
-* RAR Protect Header added
-
-### Version 0.10.3
-
-* Finally fixed Disposal issue when creating a new archive with the Archive API
-
-### Version 0.10.2
-
-* Fixed Rar Header reading for invalid extended time headers.
-* Windows Store assembly is now strong named
-* Known issues with Long Tar names being worked on
-* Updated to VS2013
-* Portable targets SL5 and Windows Phone 8 (up from SL4 and WP7)
-
-### Version 0.10.1
-
-* Fixed 7Zip extraction performance problem
-
-### Version 0.10:
-
-* Added support for RAR Decryption (thanks to https://github.com/hrasyid)
-* Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
-* Built in Release (I think)
+## Notes

 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott

--- a/USAGE.md
+++ b/USAGE.md
@@ -113,38 +113,26 @@ using (var archive = RarArchive.Open("Test.rar"))
 }
 ```

-### Extract solid Rar or 7Zip archives with manual progress reporting
+### Extract solid Rar or 7Zip archives with progress reporting

 `ExtractAllEntries` only works for solid archives (Rar) or 7Zip archives. For optimal performance with these archive types, use this method:

 ```C#
-using (var archive = RarArchive.Open("archive.rar")) // Must be solid Rar or 7Zip
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+var progress = new Progress<ProgressReport>(report =>
 {
-    if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
+    Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
+});
+
+using (var archive = RarArchive.Open("archive.rar", new ReaderOptions { Progress = progress })) // Must be solid Rar or 7Zip
+{
+    archive.WriteToDirectory(@"D:\output", new ExtractionOptions()
    {
-        // Calculate total size for progress reporting
-        double totalSize = archive.Entries.Where(e => !e.IsDirectory).Sum(e => e.Size);
-        long completed = 0;
-
-        using (var reader = archive.ExtractAllEntries())
-        {
-            while (reader.MoveToNextEntry())
-            {
-                if (!reader.Entry.IsDirectory)
-                {
-                    reader.WriteEntryToDirectory(@"D:\output", new ExtractionOptions()
-                    {
-                        ExtractFullPath = true,
-                        Overwrite = true
-                    });
-
-                    completed += reader.Entry.Size;
-                    double progress = completed / totalSize;
-                    Console.WriteLine($"Progress: {progress:P}");
-                }
-            }
-        }
-    }
+        ExtractFullPath = true,
+        Overwrite = true
+    });
 }
 ```

--- a/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
@@ -55,7 +55,7 @@ internal class SevenZipFilePart : FilePart
        {
            folderStream.Skip(skipSize);
        }
-        return new ReadOnlySubStream(folderStream, Header.Size);
+        return new ReadOnlySubStream(folderStream, Header.Size, leaveOpen: false);
    }

    public CompressionType CompressionType
--- a/src/SharpCompress/Compressors/LZMA/LZ/LzOutWindow.cs
+++ b/src/SharpCompress/Compressors/LZMA/LZ/LzOutWindow.cs
@@ -153,7 +153,7 @@ internal class OutWindow : IDisposable
        _pendingLen = rem;
    }

-    public async Task CopyPendingAsync(CancellationToken cancellationToken = default)
+    public async ValueTask CopyPendingAsync(CancellationToken cancellationToken = default)
    {
        if (_pendingLen < 1)
        {
@@ -206,7 +206,7 @@ internal class OutWindow : IDisposable
        _pendingDist = distance;
    }

-    public async Task CopyBlockAsync(
+    public async ValueTask CopyBlockAsync(
        int distance,
        int len,
        CancellationToken cancellationToken = default
@@ -253,7 +253,7 @@ internal class OutWindow : IDisposable
        }
    }

-    public async Task PutByteAsync(byte b, CancellationToken cancellationToken = default)
+    public async ValueTask PutByteAsync(byte b, CancellationToken cancellationToken = default)
    {
        _buffer[_pos++] = b;
        _total++;
@@ -369,6 +369,28 @@ internal class OutWindow : IDisposable
        return size;
    }

+    public int Read(Memory<byte> buffer, int offset, int count)
+    {
+        if (_streamPos >= _pos)
+        {
+            return 0;
+        }
+
+        var size = _pos - _streamPos;
+        if (size > count)
+        {
+            size = count;
+        }
+        _buffer.AsMemory(_streamPos, size).CopyTo(buffer.Slice(offset, size));
+        _streamPos += size;
+        if (_streamPos >= _windowSize)
+        {
+            _pos = 0;
+            _streamPos = 0;
+        }
+        return size;
+    }
+
    public int ReadByte()
    {
        if (_streamPos >= _pos)
--- a/src/SharpCompress/Compressors/LZMA/LZipStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/LZipStream.cs
@@ -45,10 +45,12 @@ public sealed class LZipStream : Stream, IStreamStack
    private bool _finished;

    private long _writeCount;
+    private readonly Stream? _originalStream;

    public LZipStream(Stream stream, CompressionMode mode)
    {
        Mode = mode;
+        _originalStream = stream;

        if (mode == CompressionMode.Decompress)
        {
@@ -125,6 +127,10 @@ public sealed class LZipStream : Stream, IStreamStack
        {
            Finish();
            _stream.Dispose();
+            if (Mode == CompressionMode.Compress)
+            {
+                _originalStream?.Dispose();
+            }
        }
    }

--- a/src/SharpCompress/Compressors/LZMA/LzmaDecoder.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaDecoder.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA.LZ;
 using SharpCompress.Compressors.LZMA.RangeCoder;

@@ -475,7 +476,7 @@ public class Decoder : ICoder, ISetDecoderProperties // ,System.IO.Stream
        return false;
    }

-    internal async System.Threading.Tasks.Task<bool> CodeAsync(
+    internal async ValueTask<bool> CodeAsync(
        int dictionarySize,
        OutWindow outWindow,
        RangeCoder.Decoder rangeDecoder,
--- a/src/SharpCompress/Compressors/LZMA/LzmaStream.cs
+++ b/src/SharpCompress/Compressors/LZMA/LzmaStream.cs
@@ -425,7 +425,7 @@ public class LzmaStream : Stream, IStreamStack
        }
    }

-    private async Task DecodeChunkHeaderAsync(CancellationToken cancellationToken = default)
+    private async ValueTask DecodeChunkHeaderAsync(CancellationToken cancellationToken = default)
    {
        var controlBuffer = new byte[1];
        await _inputStream
@@ -632,6 +632,119 @@ public class LzmaStream : Stream, IStreamStack
        return total;
    }

+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_endReached)
+        {
+            return 0;
+        }
+
+        var total = 0;
+        var offset = 0;
+        var count = buffer.Length;
+        while (total < count)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (_availableBytes == 0)
+            {
+                if (_isLzma2)
+                {
+                    await DecodeChunkHeaderAsync(cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    _endReached = true;
+                }
+                if (_endReached)
+                {
+                    break;
+                }
+            }
+
+            var toProcess = count - total;
+            if (toProcess > _availableBytes)
+            {
+                toProcess = (int)_availableBytes;
+            }
+
+            _outWindow.SetLimit(toProcess);
+            if (_uncompressedChunk)
+            {
+                _inputPosition += await _outWindow
+                    .CopyStreamAsync(_inputStream, toProcess, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+            else if (
+                await _decoder
+                    .CodeAsync(_dictionarySize, _outWindow, _rangeDecoder, cancellationToken)
+                    .ConfigureAwait(false)
+                && _outputSize < 0
+            )
+            {
+                _availableBytes = _outWindow.AvailableBytes;
+            }
+
+            var read = _outWindow.Read(buffer, offset, toProcess);
+            total += read;
+            offset += read;
+            _position += read;
+            _availableBytes -= read;
+
+            if (_availableBytes == 0 && !_uncompressedChunk)
+            {
+                if (
+                    !_rangeDecoder.IsFinished
+                    || (_rangeDecoderLimit >= 0 && _rangeDecoder._total != _rangeDecoderLimit)
+                )
+                {
+                    _outWindow.SetLimit(toProcess + 1);
+                    if (
+                        !await _decoder
+                            .CodeAsync(
+                                _dictionarySize,
+                                _outWindow,
+                                _rangeDecoder,
+                                cancellationToken
+                            )
+                            .ConfigureAwait(false)
+                    )
+                    {
+                        _rangeDecoder.ReleaseStream();
+                        throw new DataErrorException();
+                    }
+                }
+
+                _rangeDecoder.ReleaseStream();
+
+                _inputPosition += _rangeDecoder._total;
+                if (_outWindow.HasPending)
+                {
+                    throw new DataErrorException();
+                }
+            }
+        }
+
+        if (_endReached)
+        {
+            if (_inputSize >= 0 && _inputPosition != _inputSize)
+            {
+                throw new DataErrorException();
+            }
+            if (_outputSize >= 0 && _position != _outputSize)
+            {
+                throw new DataErrorException();
+            }
+        }
+
+        return total;
+    }
+#endif
+
    public override Task WriteAsync(
        byte[] buffer,
        int offset,
--- a/src/SharpCompress/IO/BufferedSubStream.cs
+++ b/src/SharpCompress/IO/BufferedSubStream.cs
@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;

 namespace SharpCompress.IO;

@@ -68,6 +70,23 @@ internal class BufferedSubStream : SharpCompressStream, IStreamStack
        BytesLeftToRead -= _cacheLength;
    }

+    private async ValueTask RefillCacheAsync(CancellationToken cancellationToken)
+    {
+        var count = (int)Math.Min(BytesLeftToRead, _cache.Length);
+        _cacheOffset = 0;
+        if (count == 0)
+        {
+            _cacheLength = 0;
+            return;
+        }
+        Stream.Position = origin;
+        _cacheLength = await Stream
+            .ReadAsync(_cache, 0, count, cancellationToken)
+            .ConfigureAwait(false);
+        origin += _cacheLength;
+        BytesLeftToRead -= _cacheLength;
+    }
+
    public override int Read(byte[] buffer, int offset, int count)
    {
        if (count > Length)
@@ -104,6 +123,61 @@ internal class BufferedSubStream : SharpCompressStream, IStreamStack
        return _cache[_cacheOffset++];
    }

+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        if (count > Length)
+        {
+            count = (int)Length;
+        }
+
+        if (count > 0)
+        {
+            if (_cacheOffset == _cacheLength)
+            {
+                await RefillCacheAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            count = Math.Min(count, _cacheLength - _cacheOffset);
+            Buffer.BlockCopy(_cache, _cacheOffset, buffer, offset, count);
+            _cacheOffset += count;
+        }
+
+        return count;
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var count = buffer.Length;
+        if (count > Length)
+        {
+            count = (int)Length;
+        }
+
+        if (count > 0)
+        {
+            if (_cacheOffset == _cacheLength)
+            {
+                await RefillCacheAsync(cancellationToken).ConfigureAwait(false);
+            }
+
+            count = Math.Min(count, _cacheLength - _cacheOffset);
+            _cache.AsSpan(_cacheOffset, count).CopyTo(buffer.Span);
+            _cacheOffset += count;
+        }
+
+        return count;
+    }
+#endif
+
    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();

    public override void SetLength(long value) => throw new NotSupportedException();
--- a/src/SharpCompress/IO/ReadOnlySubStream.cs
+++ b/src/SharpCompress/IO/ReadOnlySubStream.cs
@@ -16,11 +16,11 @@ internal class ReadOnlySubStream : SharpCompressStream, IStreamStack

    private long _position;

-    public ReadOnlySubStream(Stream stream, long bytesToRead)
-        : this(stream, null, bytesToRead) { }
+    public ReadOnlySubStream(Stream stream, long bytesToRead, bool leaveOpen = true)
+        : this(stream, null, bytesToRead, leaveOpen) { }

-    public ReadOnlySubStream(Stream stream, long? origin, long bytesToRead)
-        : base(stream, leaveOpen: true, throwOnDispose: false)
+    public ReadOnlySubStream(Stream stream, long? origin, long bytesToRead, bool leaveOpen = true)
+        : base(stream, leaveOpen, throwOnDispose: false)
    {
        if (origin != null && stream.Position != origin.Value)
        {
--- a/src/SharpCompress/IO/SharpCompressStream.cs
+++ b/src/SharpCompress/IO/SharpCompressStream.cs
@@ -138,8 +138,6 @@ public class SharpCompressStream : Stream, IStreamStack
 #endif
    }

-    internal bool IsRecording { get; private set; }
-
    protected override void Dispose(bool disposing)
    {
 #if DEBUG_STREAMS
--- a/src/SharpCompress/Utility.cs
+++ b/src/SharpCompress/Utility.cs
@@ -71,48 +71,16 @@ internal static class Utility
            return;
        }

-        using var buffer = MemoryPool<byte>.Shared.Rent(TEMP_BUFFER_SIZE);
-        while (advanceAmount > 0)
-        {
-            var toRead = (int)Math.Min(buffer.Memory.Length, advanceAmount);
-            var read = source.Read(buffer.Memory.Slice(0, toRead).Span);
-            if (read <= 0)
-            {
-                break;
-            }
-            advanceAmount -= read;
-        }
+        using var readOnlySubStream = new IO.ReadOnlySubStream(source, advanceAmount);
+        readOnlySubStream.CopyTo(Stream.Null);
    }

-    public static void Skip(this Stream source)
-    {
-        using var buffer = MemoryPool<byte>.Shared.Rent(TEMP_BUFFER_SIZE);
-        while (source.Read(buffer.Memory.Span) > 0) { }
-    }
+    public static void Skip(this Stream source) => source.CopyTo(Stream.Null);

-    public static async Task SkipAsync(
-        this Stream source,
-        CancellationToken cancellationToken = default
-    )
+    public static 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);
-        }
+        cancellationToken.ThrowIfCancellationRequested();
+        return source.CopyToAsync(Stream.Null);
    }

    public static DateTime DosDateToDateTime(ushort iDate, ushort iTime)
--- a/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs
+++ b/tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs
@@ -0,0 +1,139 @@
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Archives;
+using SharpCompress.Common;
+using Xunit;
+
+namespace SharpCompress.Test.SevenZip;
+
+#if !NETFRAMEWORK
+public class SevenZipArchiveAsyncTests : ArchiveTests
+{
+    [Fact]
+    public async Task SevenZipArchive_LZMA_AsyncStreamExtraction()
+    {
+        var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA.7z");
+        using var stream = File.OpenRead(testArchive);
+        using var archive = ArchiveFactory.Open(stream);
+
+        foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+        {
+            var targetPath = Path.Combine(SCRATCH_FILES_PATH, entry.Key!);
+            var targetDir = Path.GetDirectoryName(targetPath);
+
+            if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
+            {
+                Directory.CreateDirectory(targetDir);
+            }
+
+            using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None);
+            await using var targetStream = File.Create(targetPath);
+            await sourceStream.CopyToAsync(targetStream, CancellationToken.None);
+        }
+
+        VerifyFiles();
+    }
+
+    [Fact]
+    public async Task SevenZipArchive_LZMA2_AsyncStreamExtraction()
+    {
+        var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.LZMA2.7z");
+        using var stream = File.OpenRead(testArchive);
+        using var archive = ArchiveFactory.Open(stream);
+
+        foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+        {
+            var targetPath = Path.Combine(SCRATCH_FILES_PATH, entry.Key!);
+            var targetDir = Path.GetDirectoryName(targetPath);
+
+            if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
+            {
+                Directory.CreateDirectory(targetDir);
+            }
+
+            using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None);
+            await using var targetStream = File.Create(targetPath);
+            await sourceStream.CopyToAsync(targetStream, CancellationToken.None);
+        }
+
+        VerifyFiles();
+    }
+
+    [Fact]
+    public async Task SevenZipArchive_Solid_AsyncStreamExtraction()
+    {
+        var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.solid.7z");
+        using var stream = File.OpenRead(testArchive);
+        using var archive = ArchiveFactory.Open(stream);
+
+        foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+        {
+            var targetPath = Path.Combine(SCRATCH_FILES_PATH, entry.Key!);
+            var targetDir = Path.GetDirectoryName(targetPath);
+
+            if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
+            {
+                Directory.CreateDirectory(targetDir);
+            }
+
+            using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None);
+            await using var targetStream = File.Create(targetPath);
+            await sourceStream.CopyToAsync(targetStream, CancellationToken.None);
+        }
+
+        VerifyFiles();
+    }
+
+    [Fact]
+    public async Task SevenZipArchive_BZip2_AsyncStreamExtraction()
+    {
+        var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.BZip2.7z");
+        using var stream = File.OpenRead(testArchive);
+        using var archive = ArchiveFactory.Open(stream);
+
+        foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+        {
+            var targetPath = Path.Combine(SCRATCH_FILES_PATH, entry.Key!);
+            var targetDir = Path.GetDirectoryName(targetPath);
+
+            if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
+            {
+                Directory.CreateDirectory(targetDir);
+            }
+
+            using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None);
+            await using var targetStream = File.Create(targetPath);
+            await sourceStream.CopyToAsync(targetStream, CancellationToken.None);
+        }
+
+        VerifyFiles();
+    }
+
+    [Fact]
+    public async Task SevenZipArchive_PPMd_AsyncStreamExtraction()
+    {
+        var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "7Zip.PPMd.7z");
+        using var stream = File.OpenRead(testArchive);
+        using var archive = ArchiveFactory.Open(stream);
+
+        foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+        {
+            var targetPath = Path.Combine(SCRATCH_FILES_PATH, entry.Key!);
+            var targetDir = Path.GetDirectoryName(targetPath);
+
+            if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
+            {
+                Directory.CreateDirectory(targetDir);
+            }
+
+            using var sourceStream = await entry.OpenEntryStreamAsync(CancellationToken.None);
+            await using var targetStream = File.Create(targetPath);
+            await sourceStream.CopyToAsync(targetStream, CancellationToken.None);
+        }
+
+        VerifyFiles();
+    }
+}
+#endif
--- a/tests/SharpCompress.Test/Streams/DisposalTests.cs
+++ b/tests/SharpCompress.Test/Streams/DisposalTests.cs
@@ -0,0 +1,189 @@
+using System;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.Deflate;
+using SharpCompress.Compressors.LZMA;
+using SharpCompress.Compressors.Lzw;
+using SharpCompress.Compressors.PPMd;
+using SharpCompress.Compressors.Reduce;
+using SharpCompress.Compressors.ZStandard;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Test.Mocks;
+using Xunit;
+
+namespace SharpCompress.Test.Streams;
+
+public class DisposalTests
+{
+    private void VerifyStreamDisposal(
+        Func<Stream, bool, Stream> createStream,
+        bool supportsLeaveOpen = true
+    )
+    {
+        // 1. Test Dispose behavior (should dispose inner stream)
+        {
+            using var innerStream = new TestStream(new MemoryStream());
+            // createStream(stream, leaveOpen: false)
+            var stream = createStream(innerStream, false);
+            stream.Dispose();
+
+            // Some streams might not support disposal of inner stream (e.g. PpmdStream apparently)
+            // But for those that satisfy the pattern, we assert true.
+            Assert.True(
+                innerStream.IsDisposed,
+                "Stream should have been disposed when leaveOpen=false"
+            );
+        }
+
+        // 2. Test LeaveOpen behavior (should NOT dispose inner stream)
+        if (supportsLeaveOpen)
+        {
+            using var innerStream = new TestStream(new MemoryStream());
+            // createStream(stream, leaveOpen: true)
+            var stream = createStream(innerStream, true);
+            stream.Dispose();
+            Assert.False(
+                innerStream.IsDisposed,
+                "Stream should NOT have been disposed when leaveOpen=true"
+            );
+        }
+    }
+
+    private void VerifyAlwaysDispose(Func<Stream, Stream> createStream)
+    {
+        using var innerStream = new TestStream(new MemoryStream());
+        var stream = createStream(innerStream);
+        stream.Dispose();
+        Assert.True(innerStream.IsDisposed, "Stream should have been disposed (AlwaysDispose)");
+    }
+
+    private void VerifyNeverDispose(Func<Stream, Stream> createStream)
+    {
+        using var innerStream = new TestStream(new MemoryStream());
+        var stream = createStream(innerStream);
+        stream.Dispose();
+        Assert.False(innerStream.IsDisposed, "Stream should NOT have been disposed (NeverDispose)");
+    }
+
+    [Fact]
+    public void SourceStream_Disposal()
+    {
+        VerifyStreamDisposal(
+            (stream, leaveOpen) =>
+                new SourceStream(
+                    stream,
+                    i => null,
+                    new ReaderOptions { LeaveStreamOpen = leaveOpen }
+                )
+        );
+    }
+
+    [Fact]
+    public void ProgressReportingStream_Disposal()
+    {
+        VerifyStreamDisposal(
+            (stream, leaveOpen) =>
+                new ProgressReportingStream(
+                    stream,
+                    new Progress<ProgressReport>(),
+                    "",
+                    0,
+                    leaveOpen: leaveOpen
+                )
+        );
+    }
+
+    [Fact]
+    public void DataDescriptorStream_Disposal()
+    {
+        // DataDescriptorStream DOES dispose inner stream
+        VerifyAlwaysDispose(stream => new DataDescriptorStream(stream));
+    }
+
+    [Fact]
+    public void DeflateStream_Disposal()
+    {
+        // DeflateStream in SharpCompress always disposes inner stream
+        VerifyAlwaysDispose(stream => new DeflateStream(stream, CompressionMode.Compress));
+    }
+
+    [Fact]
+    public void GZipStream_Disposal()
+    {
+        // GZipStream in SharpCompress always disposes inner stream
+        VerifyAlwaysDispose(stream => new GZipStream(stream, CompressionMode.Compress));
+    }
+
+    [Fact]
+    public void LzwStream_Disposal()
+    {
+        VerifyStreamDisposal(
+            (stream, leaveOpen) =>
+            {
+                var lzw = new LzwStream(stream);
+                lzw.IsStreamOwner = !leaveOpen;
+                return lzw;
+            }
+        );
+    }
+
+    [Fact]
+    public void PpmdStream_Disposal()
+    {
+        // PpmdStream seems to not dispose inner stream based on code analysis
+        // It takes PpmdProperties which we need to mock or create.
+        var props = new PpmdProperties();
+        VerifyNeverDispose(stream => new PpmdStream(props, stream, false));
+    }
+
+    [Fact]
+    public void LzmaStream_Disposal()
+    {
+        // LzmaStream always disposes inner stream
+        // Need to provide valid properties to avoid crash in constructor (invalid window size)
+        // 5 bytes: 1 byte properties + 4 bytes dictionary size (little endian)
+        // Dictionary size = 1024 (0x400) -> 00 04 00 00
+        var lzmaProps = new byte[] { 0, 0, 4, 0, 0 };
+        VerifyAlwaysDispose(stream => new LzmaStream(lzmaProps, stream));
+    }
+
+    [Fact]
+    public void LZipStream_Disposal()
+    {
+        // LZipStream always disposes inner stream
+        // Use Compress mode to avoid need for valid input header
+        VerifyAlwaysDispose(stream => new LZipStream(stream, CompressionMode.Compress));
+    }
+
+    [Fact]
+    public void ReduceStream_Disposal()
+    {
+        // ReduceStream does not dispose inner stream
+        VerifyNeverDispose(stream => new ReduceStream(stream, 0, 0, 1));
+    }
+
+    [Fact]
+    public void ZStandard_CompressionStream_Disposal()
+    {
+        VerifyStreamDisposal(
+            (stream, leaveOpen) =>
+                new CompressionStream(stream, level: 0, bufferSize: 0, leaveOpen: leaveOpen)
+        );
+    }
+
+    [Fact]
+    public void ZStandard_DecompressionStream_Disposal()
+    {
+        VerifyStreamDisposal(
+            (stream, leaveOpen) =>
+                new DecompressionStream(
+                    stream,
+                    bufferSize: 0,
+                    checkEndOfStream: false,
+                    leaveOpen: leaveOpen
+                )
+        );
+    }
+}
Author	SHA1	Message	Date
Adam Hathcock	5c947bccc7	Merge branch 'adam/update-docs'	2026-01-07 16:18:51 +00:00
Adam Hathcock	fbdefc17c1	updates from review	2026-01-07 16:18:27 +00:00
Adam Hathcock	1425c6ff0d	Merge pull request #1120 from adamhathcock/adam/update-docs Update docs	2026-01-07 16:12:51 +00:00
Adam Hathcock	e038aea694	move old changelog	2026-01-07 16:10:55 +00:00
Adam Hathcock	87ccbf329d	moved examples to USAGE	2026-01-07 15:56:38 +00:00
Adam Hathcock	9dcf384263	update for progress reporting	2026-01-07 15:30:26 +00:00
Adam Hathcock	be045c4f15	Merge pull request #1114 from adamhathcock/copilot/fix-7z-file-decompression-error Fix async decompression of .7z files by implementing Memory<byte> ReadAsync overload	2026-01-07 08:16:51 +00:00
Adam Hathcock	fd968b3f78	Update src/SharpCompress/IO/ReadOnlySubStream.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-01-06 16:33:03 +00:00
Adam Hathcock	833dd7b3a2	fix tests and fmt	2026-01-06 15:33:43 +00:00
Adam Hathcock	b9258ad496	use more ValueTask methods but types are still created because of state machine suspension	2026-01-06 15:26:49 +00:00
copilot-swe-agent[bot]	0678318dde	Fix async decompression by implementing Memory<byte> ReadAsync overload The issue was that .NET 10's ReadExactlyAsync calls the Memory<byte> overload of ReadAsync, which wasn't implemented in BufferedSubStream. This caused it to fall back to the base Stream implementation that uses synchronous reads, leading to cache state corruption. Solution: Added ValueTask<int> ReadAsync(Memory<byte>, CancellationToken) overload for modern .NET versions. All tests now passing including LZMA2 and Solid archives. Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com>	2026-01-06 14:18:15 +00:00
copilot-swe-agent[bot]	7116c0d098	Add async support to BufferedSubStream for 7zip decompression - Implemented ReadAsync and RefillCacheAsync methods in BufferedSubStream - Added async test cases for SevenZipArchive (LZMA, LZMA2, Solid, BZip2, PPMd) - Tests show LZMA, BZip2, and PPMd working correctly - LZMA2 and Solid archives still failing with Data Error - investigating cache state management Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com>	2026-01-06 14:13:48 +00:00
copilot-swe-agent[bot]	2fde8436fb	Initial plan	2026-01-06 14:00:03 +00:00
Adam Hathcock	61ecd6475f	Merge pull request #1113 from adamhathcock/adam/fix-readonly-dispose Fix a usage of ReadOnly that use dispose in 7Zip	2026-01-06 13:22:50 +00:00
Adam Hathcock	64b209a772	add disposal tests and fix lzipstream	2026-01-06 13:13:34 +00:00
Adam Hathcock	48dbdbfed5	fmt	2026-01-06 12:49:26 +00:00
Adam Hathcock	cf50311b9c	Skip should use framework stuff	2026-01-06 12:45:13 +00:00
Adam Hathcock	e4d8582a2a	7zip streams always want to be disposed	2026-01-06 12:42:48 +00:00