Clean up for async creation by adamhathcock · Pull Request #1132 · adamhathcock/sharpcompress

adamhathcock · 2026-01-15T16:44:25Z

For some formats, async should be all the way. 7Zip needs fixing

This pull request introduces asynchronous detection methods for multiple archive and compression formats, allowing non-blocking checks to determine file types. It also refactors and simplifies some synchronous detection logic for improved performance and consistency. The most significant changes are grouped below:

Asynchronous Format Detection:

Added IsArchiveAsync or similar async methods for ACE (AceHeader.cs), ARJ (ArjHeader.cs), BZip2 (BZip2Stream.cs), LZip (LZipStream.cs), LZW (LzwStream.cs), ZStandard (ZStandardStream.cs), RAR (RarArchive.Factory.cs), SevenZip (SevenZipArchive.Factory.cs), TAR (TarArchive.Factory.cs), and XZ (XZStream.cs) formats, enabling asynchronous file type checks with CancellationToken support. [1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
Updated the ACE and ARJ factories to implement and expose these new asynchronous detection methods. [1] [2]

Synchronous Detection Refactoring & Performance:

Refactored synchronous detection logic to use pooled buffers (via ArrayPool<byte>.Shared) for ARC and SevenZip formats, reducing allocations and improving performance. [1] [2]

API Consistency and Interface Changes:

Removed the CancellationToken parameter from the IArchiveFactory.OpenAsyncArchive method and its implementations to simplify the API, as the token was not being used in actual asynchronous operations. [1] [2] [3]

General Codebase Improvements:

Added missing using directives for System.Threading and System.Threading.Tasks where needed to support the new asynchronous methods. [1] [2] [3] [4] [5] [6] [7]

These changes collectively modernize the archive/compression format detection APIs and improve their efficiency and usability.

# Conflicts: # tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs

adamhathcock · 2026-01-15T16:44:48Z

@copilot fix the SevenZipArchive_LZMA_AsyncStreamExtraction test

Copilot · 2026-01-15T16:45:01Z

@adamhathcock I've opened a new pull request, #1133, to work on those changes. Once the pull request is ready, I'll request review from you.

Co-authored-by: adamhathcock <[email protected]>

…adDatabase methods Co-authored-by: adamhathcock <[email protected]>

Add async I/O support for SevenZip archive initialization

Co-authored-by: adamhathcock <[email protected]>

adamhathcock · 2026-01-16T09:18:13Z

Upgrading to xunit v3 that properly supports ValueTask as revealed that not all the tests were running correctly.

…kable streams) Co-authored-by: adamhathcock <[email protected]>

Copilot

Pull request overview

This pull request introduces asynchronous detection methods for multiple archive and compression formats to enable non-blocking file type checks. The changes also refactor synchronous detection logic to use pooled buffers for improved performance and remove unnecessary cancellation token parameters from the IArchiveFactory interface.

Changes:

Added async IsArchiveAsync methods for ACE, ARJ, BZip2, LZip, LZW, ZStandard, RAR, SevenZip, TAR, and XZ formats with proper cancellation token support
Refactored ARC and SevenZip format detection to use ArrayPool<byte>.Shared for buffer management, reducing allocations
Removed CancellationToken parameter from IArchiveFactory.OpenAsyncArchive interface methods to simplify the API

Reviewed changes

Copilot reviewed 29 out of 29 changed files in this pull request and generated 11 comments.

Show a summary per file

File	Description
tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs	Updated test methods to return `Task` instead of `ValueTask`, enabled tests for .NET Framework with conditional compilation, and commented out one test
tests/SharpCompress.Test/Mocks/AsyncOnlyStream.cs	Changed base class from `Stream` to `SharpCompressStream`
tests/SharpCompress.Test/ArchiveTests.cs	Removed two test methods for async archive opening scenarios
src/SharpCompress/packages.lock.json	Updated Microsoft.NET.ILLink.Tasks from 10.0.0 to 10.0.1
src/SharpCompress/Factories/ZipFactory.cs	Removed duplicate `IsArchiveAsync` method
src/SharpCompress/Factories/ZStandardFactory.cs	Added `CancellationToken` parameter to `IsArchiveAsync` method signature
src/SharpCompress/Factories/TarFactory.cs	Updated `IsArchiveAsync` to call new `TarArchive.IsTarFileAsync` method and removed `CancellationToken` from `OpenAsyncArchive`
src/SharpCompress/Factories/SevenZipFactory.cs	Added async detection implementation and updated `OpenAsyncArchive` methods to remove `CancellationToken`
src/SharpCompress/Factories/RarFactory.cs	Added async detection method and removed `CancellationToken` from `OpenAsyncArchive`
src/SharpCompress/Factories/GZipFactory.cs	Removed `CancellationToken` parameter from `OpenAsyncArchive` method
src/SharpCompress/Factories/Factory.cs	Made `IsArchiveAsync` abstract with `CancellationToken` parameter and removed unused `TryOpenReaderAsync` method
src/SharpCompress/Factories/ArjFactory.cs	Added async detection method via `ArjHeader.IsArchiveAsync`
src/SharpCompress/Factories/ArcFactory.cs	Implemented async detection using `ArrayPool<byte>.Shared` for buffer management
src/SharpCompress/Factories/AceFactory.cs	Added async detection method via `AceHeader.IsArchiveAsync`
src/SharpCompress/Compressors/ZStandard/ZStandardStream.cs	Added `IsZStandardAsync` method for async format detection
src/SharpCompress/Compressors/Xz/XZStream.cs	Added `IsXZStreamAsync` method for async format detection
src/SharpCompress/Compressors/Lzw/LzwStream.cs	Added `IsLzwStreamAsync` method for async format detection
src/SharpCompress/Compressors/LZMA/LZipStream.cs	Added `IsLZipFileAsync` and `ValidateAndReadSizeAsync` methods for async detection
src/SharpCompress/Compressors/BZip2/BZip2Stream.cs	Added `IsBZip2Async` method for async format detection
src/SharpCompress/Common/SevenZip/ArchiveReader.cs	Added `OpenAsync` and `ReadDatabaseAsync` methods for async archive reading
src/SharpCompress/Common/Arj/Headers/ArjHeader.cs	Added `IsArchiveAsync` method for async detection
src/SharpCompress/Common/Ace/Headers/AceHeader.cs	Added `IsArchiveAsync` method for async detection
src/SharpCompress/Archives/Tar/TarArchive.Factory.cs	Added `IsTarFileAsync` method (currently synchronous implementation)
src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs	Refactored `LoadEntries` and added `LoadEntriesAsync` with `LoadFactoryAsync` for async archive processing
src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs	Added `IsSevenZipFileAsync`, refactored signature matching to use `ArrayPool<byte>.Shared`, and added `OpenAsyncArchive` overloads
src/SharpCompress/Archives/Rar/RarArchive.Factory.cs	Added `IsRarFileAsync` method (currently synchronous implementation)
src/SharpCompress/Archives/IArchiveFactory.cs	Removed `CancellationToken` parameter from `OpenAsyncArchive(FileInfo)` method
src/SharpCompress/Archives/AutoArchiveFactory.cs	Updated `OpenAsyncArchive` to match interface changes
src/SharpCompress/Archives/ArchiveFactory.cs	Updated calls to remove `CancellationToken` parameter when calling factory methods

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-01-16T09:24:42Z

src/SharpCompress/Archives/Tar/TarArchive.Factory.cs

+    public static async ValueTask<bool> IsTarFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        try
+        {
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+            var reader = new BinaryReader(stream);
+            var readSucceeded = tarHeader.Read(reader);
+            var isEmptyArchive =
+                tarHeader.Name?.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
+        }
+        catch { }
+        return false;
+    }


The IsTarFileAsync method does not actually perform any asynchronous operations. It synchronously reads from the stream using the synchronous Read method of BinaryReader. This defeats the purpose of having an async method and could block the calling thread. The method should be refactored to use ReadAsync or similar asynchronous I/O operations to properly support async file detection.

Copilot · 2026-01-16T09:24:42Z

src/SharpCompress/Archives/Rar/RarArchive.Factory.cs

+    public static async ValueTask<bool> IsRarFileAsync(
+        Stream stream,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        try
+        {
+            MarkHeader.Read(stream, true, false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }


The IsRarFileAsync method does not actually perform any asynchronous operations. It synchronously reads from the stream using the synchronous Read method within MarkHeader.Read. This defeats the purpose of having an async method and could block the calling thread. The method should be refactored to use ReadAsync or implement a proper async version of MarkHeader.Read to support true asynchronous file detection.

tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs

Copilot · 2026-01-16T09:24:43Z

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -47,9 +47,5 @@ public interface IArchiveFactory : IFactory
    /// <param name="fileInfo">the file to open.</param>
    /// <param name="readerOptions">reading options.</param>
    /// <param name="cancellationToken">Cancellation token.</param>


The XML documentation comment includes a param tag for cancellationToken on line 49, but the actual method signature on line 50 no longer has this parameter. This will cause a documentation warning. Remove the cancellationToken documentation parameter.

Suggested change

/// <param name="cancellationToken">Cancellation token.</param>

Copilot · 2026-01-16T09:24:43Z

src/SharpCompress/Archives/SevenZip/SevenZipArchive.Factory.cs

+        var buffer = ArrayPool<byte>.Shared.Rent(6);
+        try
+        {
+            if (!await stream.ReadFullyAsync(buffer, cancellationToken).ConfigureAwait(false))


The ReadFullyAsync call attempts to read buffer.Length bytes from the stream, but the buffer is rented from ArrayPool<byte>.Shared.Rent(6), which may return a buffer larger than 6 bytes. This could cause the method to try reading more bytes than intended and potentially block or fail. Use the overload ReadFullyAsync(buffer, 0, 6, cancellationToken) to explicitly specify reading exactly 6 bytes.

Suggested change

if (!await stream.ReadFullyAsync(buffer, cancellationToken).ConfigureAwait(false))

if (!await stream.ReadFullyAsync(buffer, 0, 6, cancellationToken).ConfigureAwait(false))

tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs

Copilot · 2026-01-16T09:24:44Z

tests/SharpCompress.Test/Mocks/AsyncOnlyStream.cs

    private readonly Stream _stream;

    public AsyncOnlyStream(Stream stream)
+        : base(stream)
    {
        _stream = stream;
        // Console.WriteLine("AsyncOnlyStream created");


The AsyncOnlyStream now stores the same stream in both the _stream field and the base SharpCompressStream class through the base(stream) call. This creates redundancy and could lead to maintenance issues. Consider removing the _stream field and using the inherited Stream property from SharpCompressStream instead. All references to _stream in this class should be changed to use the base class property.

@copilot open a new pull request to apply changes based on this feedback

src/SharpCompress/Factories/ZStandardFactory.cs

src/SharpCompress/Archives/Tar/TarArchive.Factory.cs

Copilot · 2026-01-16T09:24:45Z

src/SharpCompress/Archives/Tar/TarArchive.Factory.cs

+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
+        }
+        catch { }


Poor error handling: empty catch block.

@copilot open a new pull request to apply changes based on this feedback

Co-authored-by: adamhathcock <[email protected]>

Copilot · 2026-01-16T09:29:12Z

@adamhathcock I've opened a new pull request, #1138, to work on those changes. Once the pull request is ready, I'll request review from you.

Co-authored-by: Copilot <[email protected]>

adamhathcock added 6 commits January 15, 2026 14:52

archive asyncs are more right

a410f73

be more lazy with loading of sync stuff

2d597e6

Merge remote-tracking branch 'origin/master' into adam/async-creation

33b6447

Merge remote-tracking branch 'origin/master' into adam/async-creation

63736ef

# Conflicts: # tests/SharpCompress.Test/SevenZip/SevenZipArchiveAsyncTests.cs

revert lazy archive

810df8a

enable single test

5c06b8c

Initial plan

0b2158f

Copilot AI mentioned this pull request Jan 15, 2026

Add async I/O support for SevenZip archive initialization #1133

Merged

Copilot AI and others added 8 commits January 15, 2026 16:53

Initial plan for fixing SevenZipArchive_LZMA_AsyncStreamExtraction test

bbba2e6

Co-authored-by: adamhathcock <[email protected]>

Fix SevenZipArchive async stream handling by adding async Open and Re…

9bb670a

…adDatabase methods Co-authored-by: adamhathcock <[email protected]>

uncomment tests

491beab

fix tests for both frameworks

f4ce4cb

Merge pull request #1133 from adamhathcock/copilot/sub-pr-1132

394d982

Add async I/O support for SevenZip archive initialization

Upgrade xunit to v3

63e124e

Initial plan

75cc368

Fix ReaderFactory.OpenAsyncReader to use async IsArchiveAsync methods

2906529

Co-authored-by: adamhathcock <[email protected]>

adamhathcock marked this pull request as ready for review January 16, 2026 09:17

Copilot AI review requested due to automatic review settings January 16, 2026 09:17

Copilot started reviewing on behalf of adamhathcock January 16, 2026 09:18 View session

Fix Archive async tests to not use AsyncOnlyStream (archives need see…

e919930

…kable streams) Co-authored-by: adamhathcock <[email protected]>

Copilot AI reviewed Jan 16, 2026

View reviewed changes

Copilot AI and others added 2 commits January 16, 2026 09:26

Format code with CSharpier

c7da19f

Co-authored-by: adamhathcock <[email protected]>

Initial plan

bbbbc88

Copilot AI mentioned this pull request Jan 16, 2026

Remove redundant stream field in AsyncOnlyStream #1138

Merged

Update src/SharpCompress/Factories/ZStandardFactory.cs

b9fccbd

Co-authored-by: Copilot <[email protected]>

Copilot AI review requested due to automatic review settings January 16, 2026 09:29

	if (!await stream.ReadFullyAsync(buffer, cancellationToken).ConfigureAwait(false))
	if (!await stream.ReadFullyAsync(buffer, 0, 6, cancellationToken).ConfigureAwait(false))

Conversation

adamhathcock commented Jan 15, 2026

Uh oh!

adamhathcock commented Jan 15, 2026

Uh oh!

Copilot AI commented Jan 15, 2026

Uh oh!

adamhathcock commented Jan 16, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Copilot AI Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Copilot AI Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

adamhathcock Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Copilot AI Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

adamhathcock Jan 16, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI commented Jan 16, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants