Merge pull request #1184 from adamhathcock/adam/cleanup

Some clean up post-async merging

.copilot-agent.yml

@@ -1,7 +0,0 @@
-enabled: true
-agent:
-  name: copilot-coding-agent
-  allow:
-    - paths: ["src/**/*", "tests/**/*", "README.md", "AGENTS.md"]
-      actions: ["create", "modify"]
-  require_review_before_merge: true

.editorconfig

@@ -307,7 +307,6 @@ dotnet_diagnostic.CS8602.severity = error
 dotnet_diagnostic.CS8604.severity = error
 dotnet_diagnostic.CS8618.severity = error
 dotnet_diagnostic.CS0618.severity = suggestion
-dotnet_diagnostic.CS1998.severity = error
 dotnet_diagnostic.CS4014.severity = error
 dotnet_diagnostic.CS8600.severity = error
 dotnet_diagnostic.CS8603.severity = error

.github/agents/copilot-agent.yml

@@ -1,17 +0,0 @@
-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/prompts/plan-async.prompt.md

@@ -1,25 +0,0 @@
-# Plan: Implement Missing Async Functionality in SharpCompress
-
-SharpCompress has async support for low-level stream operations and Reader/Writer APIs, but critical entry points (Archive.Open, factory methods, initialization) remain synchronous. This plan adds async overloads for all user-facing I/O operations and fixes existing async bugs, enabling full end-to-end async workflows.
-
-## Steps
-
-1. **Add async factory methods** to [ArchiveFactory.cs](src/SharpCompress/Factories/ArchiveFactory.cs), [ReaderFactory.cs](src/SharpCompress/Factories/ReaderFactory.cs), and [WriterFactory.cs](src/SharpCompress/Factories/WriterFactory.cs) with `OpenAsync` and `CreateAsync` overloads accepting `CancellationToken`
-
-2. **Implement async Open methods** on concrete archive types ([ZipArchive.cs](src/SharpCompress/Archives/Zip/ZipArchive.cs), [TarArchive.cs](src/SharpCompress/Archives/Tar/TarArchive.cs), [RarArchive.cs](src/SharpCompress/Archives/Rar/RarArchive.cs), [GZipArchive.cs](src/SharpCompress/Archives/GZip/GZipArchive.cs), [SevenZipArchive.cs](src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs)) and reader types ([ZipReader.cs](src/SharpCompress/Readers/Zip/ZipReader.cs), [TarReader.cs](src/SharpCompress/Readers/Tar/TarReader.cs), etc.)
-
-3. **Convert archive initialization logic to async** including header reading, volume loading, and format signature detection across archive constructors and internal initialization methods
-
-4. **Fix LZMA decoder async bugs** in [LzmaStream.cs](src/SharpCompress/Compressors/LZMA/LzmaStream.cs), [Decoder.cs](src/SharpCompress/Compressors/LZMA/Decoder.cs), and [OutWindow.cs](src/SharpCompress/Compressors/LZMA/OutWindow.cs) to enable true async 7Zip support and remove `NonDisposingStream` workaround
-
-5. **Complete Rar async implementation** by converting `UnpackV2017` methods to async in [UnpackV2017.cs](src/SharpCompress/Compressors/Rar/UnpackV2017.cs) and updating Rar20 decompression
-
-6. **Add comprehensive async tests** covering all new async entry points, cancellation scenarios, and concurrent operations across all archive formats in test files
-
-## Further Considerations
-
-1. **Breaking changes** - Should new async methods be added alongside existing sync methods (non-breaking), or should sync methods eventually be deprecated? Recommend additive approach for backward compatibility.
-
-2. **Performance impact** - Header parsing for formats like Zip/Tar is often small; consider whether truly async parsing adds value vs sync parsing wrapped in Task, or make it conditional based on stream type (network vs file).
-
-3. **7Zip complexity** - The LZMA async bug fix (Step 4) may be challenging due to state management in the decoder; consider whether to scope it separately or implement a simpler workaround that maintains correctness.

.github/prompts/plan-for-next.prompt.md

@@ -1,123 +0,0 @@
-# Plan: Modernize SharpCompress Public API
-
-Based on comprehensive analysis, the API has several inconsistencies around factory patterns, async support, format capabilities, and options classes. Most improvements can be done incrementally without breaking changes.
-
-## Steps
-
-1. **Standardize factory patterns** by deprecating format-specific static `Open` methods in [Archives/Zip/ZipArchive.cs](src/SharpCompress/Archives/Zip/ZipArchive.cs), [Archives/Tar/TarArchive.cs](src/SharpCompress/Archives/Tar/TarArchive.cs), etc. in favor of centralized [Factories/ArchiveFactory.cs](src/SharpCompress/Factories/ArchiveFactory.cs)
-
-2. **Complete async implementation** in [Writers/Zip/ZipWriter.cs](src/SharpCompress/Writers/Zip/ZipWriter.cs) and other writers that currently use sync-over-async, implementing true async I/O throughout the writer hierarchy
-
-3. **Unify options classes** by making [Common/ExtractionOptions.cs](src/SharpCompress/Common/ExtractionOptions.cs) inherit from `OptionsBase` and adding progress reporting to extraction methods consistently
-
-4. **Clarify GZip semantics** in [Archives/GZip/GZipArchive.cs](src/SharpCompress/Archives/GZip/GZipArchive.cs) by adding XML documentation explaining single-entry limitation and relationship to GZip compression used in Tar.gz
-
-## Further Considerations
-
-1. **Breaking changes roadmap** - Should we plan a major version (2.0) to remove deprecated factory methods, clean up `ArchiveType` enum (remove Arc/Arj or add full support), and consolidate naming patterns?
-
-2. **Progress reporting consistency** - Should `IProgress<ArchiveExtractionProgress<IEntry>>` be added to all extraction extension methods or consolidated into options classes?
-
-## Detailed Analysis
-
-### Factory Pattern Issues
-
-Three different factory patterns exist with overlapping functionality:
-
-1. **Static Factories**: ArchiveFactory, ReaderFactory, WriterFactory
-2. **Instance Factories**: IArchiveFactory, IReaderFactory, IWriterFactory
-3. **Format-specific static methods**: Each archive class has static `Open` methods
-
-**Example confusion:**
-```csharp
-// Three ways to open a Zip archive - which is recommended?
-var archive1 = ArchiveFactory.Open("file.zip");
-var archive2 = ZipArchive.Open("file.zip");
-var archive3 = ArchiveFactory.AutoFactory.Open(fileInfo, options);
-```
-
-### Async Support Gaps
-
-Base `IWriter` interface has async methods, but writer implementations provide minimal async support. Most writers just call synchronous methods:
-
-```csharp
-public virtual async Task WriteAsync(...)
-{
-    // Default implementation calls synchronous version
-    Write(filename, source, modificationTime);
-    await Task.CompletedTask.ConfigureAwait(false);
-}
-```
-
-Real async implementations only in:
-- `TarWriter` - Proper async implementation
-- Most other writers use sync-over-async
-
-### GZip Archive Special Case
-
-GZip is treated as both a compression format and an archive format, but only supports single-entry archives:
-
-```csharp
-protected override GZipArchiveEntry CreateEntryInternal(...)
-{
-    if (Entries.Any())
-    {
-        throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-    }
-    // ...
-}
-```
-
-### Options Class Hierarchy
-
-```
-OptionsBase (LeaveStreamOpen, ArchiveEncoding)
-  ├─ ReaderOptions (LookForHeader, Password, DisableCheckIncomplete, BufferSize, ExtensionHint, Progress)
-  ├─ WriterOptions (CompressionType, CompressionLevel, Progress)
-  │   ├─ ZipWriterOptions (ArchiveComment, UseZip64)
-  │   ├─ TarWriterOptions (FinalizeArchiveOnClose, HeaderFormat)
-  │   └─ GZipWriterOptions (no additional properties)
-  └─ ExtractionOptions (standalone - Overwrite, ExtractFullPath, PreserveFileTime, PreserveAttributes)
-```
-
-**Issues:**
-- `ExtractionOptions` doesn't inherit from `OptionsBase` - no encoding support during extraction
-- Progress reporting inconsistency between readers and extraction
-- Obsolete properties (`ChecksumIsValid`, `Version`) with unclear migration path
-
-### Implementation Priorities
-
-**High Priority (Non-Breaking):**
-1. Add API usage guide (Archive vs Reader, factory recommendations, async best practices)
-2. Fix progress reporting consistency
-3. Complete async implementation in writers
-
-**Medium Priority (Next Major Version):**
-1. Unify factory pattern - deprecate format-specific static `Open` methods
-2. Clean up options classes - make `ExtractionOptions` inherit from `OptionsBase`
-3. Clarify archive types - remove Arc/Arj from `ArchiveType` enum or add full support
-4. Standardize naming across archive types
-
-**Low Priority:**
-1. Add BZip2 archive support similar to GZipArchive
-2. Complete obsolete property cleanup with migration guide
-
-### Backward Compatibility Strategy
-
-**Safe (Non-Breaking) Changes:**
-- Add new methods to interfaces (use default implementations)
-- Add new options properties (with defaults)
-- Add new factory methods
-- Improve async implementations
-- Add progress reporting support
-
-**Breaking Changes to Avoid:**
-- ❌ Removing format-specific `Open` methods (deprecate instead)
-- ❌ Changing `LeaveStreamOpen` default (currently `true`)
-- ❌ Removing obsolete properties before major version bump
-- ❌ Changing return types or signatures of existing methods
-
-**Deprecation Pattern:**
-- Use `[Obsolete]` for one major version
-- Use `[EditorBrowsable(EditorBrowsableState.Never)]` in next major version
-- Remove in following major version

.gitignore

@@ -4,8 +4,8 @@ _ReSharper.SharpCompress/
 bin/
 *.suo
 *.user
-TestArchives/Scratch/
-TestArchives/Scratch2/
+tests/TestArchives/Scratch/
+tests/TestArchives/Scratch2/
 TestResults/
 *.nupkg
 packages/*/

AGENTS.md

@@ -14,6 +14,7 @@ SharpCompress is a pure C# compression library supporting multiple archive forma
 - Follow the existing code style and patterns in the codebase.
 
 ## General Instructions
+- **Agents should NEVER commit to git** - Agents should stage files and leave committing to the user. Only create commits when the user explicitly requests them.
 - Make only high confidence suggestions when reviewing code changes.
 - Write code with good maintainability practices, including comments on why certain design decisions were made.
 - Handle edge cases and write clear exception handling.
@@ -110,7 +111,7 @@ SharpCompress supports multiple archive and compression formats:
 - **Archive Formats**: Zip, Tar, 7Zip, Rar (read-only)
 - **Compression**: DEFLATE, BZip2, LZMA/LZMA2, PPMd, ZStandard (decompress only), Deflate64 (decompress only)
 - **Combined Formats**: Tar.GZip, Tar.BZip2, Tar.LZip, Tar.XZ, Tar.ZStandard
-- See FORMATS.md for complete format support matrix
+- See [docs/FORMATS.md](docs/FORMATS.md) for complete format support matrix
 
 ### Stream Handling Rules
 - **Disposal**: As of version 0.21, SharpCompress closes wrapped streams by default
@@ -177,5 +178,59 @@ SharpCompress supports multiple archive and compression formats:
 2. **Solid archives (Rar, 7Zip)** - Use `ExtractAllEntries()` for best performance, not individual entry extraction
 3. **Stream disposal** - Always set `LeaveStreamOpen` explicitly when needed (default is to close)
 4. **Tar + non-seekable stream** - Must provide file size or it will throw
-5. **Multi-framework differences** - Some features differ between .NET Framework and modern .NET (e.g., Mono.Posix)
 6. **Format detection** - Use `ReaderFactory.Open()` for auto-detection, test with actual archive files
+
+### Async Struct-Copy Bug in LZMA RangeCoder
+
+When implementing async methods on mutable `struct` types (like `BitEncoder` and `BitDecoder` in the LZMA RangeCoder), be aware that the async state machine copies the struct when `await` is encountered. This means mutations to struct fields after the `await` point may not persist back to the original struct stored in arrays or fields.
+
+**The Bug:**
+```csharp
+// BAD: async method on mutable struct
+public async ValueTask<uint> DecodeAsync(Decoder decoder, CancellationToken cancellationToken = default)
+{
+    var newBound = (decoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
+    if (decoder._code < newBound)
+    {
+        decoder._range = newBound;
+        _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;  // Mutates _prob
+        await decoder.Normalize2Async(cancellationToken).ConfigureAwait(false);  // Struct gets copied here
+        return 0;  // Original _prob update may be lost
+    }
+    // ...
+}
+```
+
+**The Fix:**
+Refactor async methods on mutable structs to perform all struct mutations synchronously before any `await`, or use a helper method to separate the await from the struct mutation:
+
+```csharp
+// GOOD: struct mutations happen synchronously, await is conditional
+public ValueTask<uint> DecodeAsync(Decoder decoder, CancellationToken cancellationToken = default)
+{
+    var newBound = (decoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
+    if (decoder._code < newBound)
+    {
+        decoder._range = newBound;
+        _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;  // All mutations complete
+        return DecodeAsyncHelper(decoder.Normalize2Async(cancellationToken), 0);  // Await in helper
+    }
+    decoder._range -= newBound;
+    decoder._code -= newBound;
+    _prob -= (_prob) >> K_NUM_MOVE_BITS;  // All mutations complete
+    return DecodeAsyncHelper(decoder.Normalize2Async(cancellationToken), 1);  // Await in helper
+}
+
+private static async ValueTask<uint> DecodeAsyncHelper(ValueTask normalizeTask, uint result)
+{
+    await normalizeTask.ConfigureAwait(false);
+    return result;
+}
+```
+
+**Why This Matters:**
+In LZMA, the `BitEncoder` and `BitDecoder` structs maintain adaptive probability models in their `_prob` field. When these structs are stored in arrays (e.g., `_models[m]`), the async state machine copy breaks the adaptive model, causing incorrect bit decoding and eventually `DataErrorException` exceptions.
+
+**Related Files:**
+- `src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBit.Async.cs` - Fixed
+- `src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBitTree.Async.cs` - Uses readonly structs, so this pattern doesn't apply

Directory.Build.props

@@ -12,5 +12,6 @@
     <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
     <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+    <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
   </PropertyGroup>
 </Project>

Directory.Packages.props

@@ -3,7 +3,7 @@
     <PackageVersion Include="Bullseye" Version="6.1.0" />
     <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
     <PackageVersion Include="Glob" Version="1.1.9" />
-    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.15" />
+    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.16" />
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
@@ -11,9 +11,9 @@
     <PackageVersion Include="System.Text.Encoding.CodePages" Version="10.0.0" />
     <PackageVersion Include="System.Buffers" Version="4.6.1" />
     <PackageVersion Include="System.Memory" Version="4.6.3" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.102" />
     <GlobalPackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
     <GlobalPackageReference
       Include="Microsoft.VisualStudio.Threading.Analyzers"

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 [USAGE.md](USAGE.md#async-examples) for examples.
+**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [USAGE.md](docs/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)
@@ -14,7 +14,7 @@ GitHub Actions Build -
 
 Post Issues on Github!
 
-Check the [Supported Formats](FORMATS.md) and [Basic Usage.](USAGE.md)
+Check the [Supported Formats](docs/FORMATS.md) and [Basic Usage.](docs/USAGE.md)
 
 ## Recommended Formats
 

SharpCompress.sln

@@ -18,12 +18,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 		Directory.Build.props = Directory.Build.props
 		global.json = global.json
 		.editorconfig = .editorconfig
+		.gitignore = .gitignore
 		Directory.Packages.props = Directory.Packages.props
 		NuGet.config = NuGet.config
 		.github\workflows\nuget-release.yml = .github\workflows\nuget-release.yml
-		USAGE.md = USAGE.md
 		README.md = README.md
-		FORMATS.md = FORMATS.md
 		AGENTS.md = AGENTS.md
 	EndProjectSection
 EndProject

build/Program.cs

@@ -230,7 +230,7 @@ static async Task<(string version, bool isPrerelease)> GetVersion()
     }
     else
     {
-        // Not tagged - create prerelease version based on next minor version
+        // Not tagged - create prerelease version
         var allTags = (await GetGitOutput("tag", "--list"))
             .Split('\n', StringSplitOptions.RemoveEmptyEntries)
             .Where(tag => Regex.IsMatch(tag.Trim(), @"^\d+\.\d+\.\d+$"))
@@ -240,8 +240,22 @@ static async Task<(string version, bool isPrerelease)> GetVersion()
         var lastTag = allTags.OrderBy(tag => Version.Parse(tag)).LastOrDefault() ?? "0.0.0";
         var lastVersion = Version.Parse(lastTag);
 
-        // Increment minor version for next release
-        var nextVersion = new Version(lastVersion.Major, lastVersion.Minor + 1, 0);
+        // Determine version increment based on branch
+        var currentBranch = await GetCurrentBranch();
+        Version nextVersion;
+
+        if (currentBranch == "release")
+        {
+            // Release branch: increment patch version
+            nextVersion = new Version(lastVersion.Major, lastVersion.Minor, lastVersion.Build + 1);
+            Console.WriteLine($"Building prerelease for release branch (patch increment)");
+        }
+        else
+        {
+            // Master or other branches: increment minor version
+            nextVersion = new Version(lastVersion.Major, lastVersion.Minor + 1, 0);
+            Console.WriteLine($"Building prerelease for {currentBranch} branch (minor increment)");
+        }
 
         // Use commit count since the last version tag if available; otherwise, fall back to total count
         var revListArgs = allTags.Any() ? $"--count {lastTag}..HEAD" : "--count HEAD";
@@ -253,6 +267,28 @@ static async Task<(string version, bool isPrerelease)> GetVersion()
     }
 }
 
+static async Task<string> GetCurrentBranch()
+{
+    // In GitHub Actions, GITHUB_REF_NAME contains the branch name
+    var githubRefName = Environment.GetEnvironmentVariable("GITHUB_REF_NAME");
+    if (!string.IsNullOrEmpty(githubRefName))
+    {
+        return githubRefName;
+    }
+
+    // Fallback to git command for local builds
+    try
+    {
+        var (output, _) = await ReadAsync("git", "branch --show-current");
+        return output.Trim();
+    }
+    catch (Exception ex)
+    {
+        Console.WriteLine($"Warning: Could not determine current branch: {ex.Message}");
+        return "unknown";
+    }
+}
+
 static async Task<string> GetGitOutput(string command, string args)
 {
     try

build/packages.lock.json

@@ -25,12 +25,12 @@
       },
       "Microsoft.SourceLink.GitHub": {
         "type": "Direct",
-        "requested": "[8.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
+        "requested": "[10.0.102, )",
+        "resolved": "10.0.102",
+        "contentHash": "Oxq3RCIJSdtpIU4hLqO7XaDe/Ra3HS9Wi8rJl838SAg6Zu1iQjerA0+xXWBgUFYbgknUGCLOU0T+lzMLkvY9Qg==",
         "dependencies": {
-          "Microsoft.Build.Tasks.Git": "8.0.0",
-          "Microsoft.SourceLink.Common": "8.0.0"
+          "Microsoft.Build.Tasks.Git": "10.0.102",
+          "Microsoft.SourceLink.Common": "10.0.102"
         }
       },
       "Microsoft.VisualStudio.Threading.Analyzers": {
@@ -47,8 +47,8 @@
       },
       "Microsoft.Build.Tasks.Git": {
         "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
+        "resolved": "10.0.102",
+        "contentHash": "0i81LYX31U6UiXz4NOLbvc++u+/mVDmOt+PskrM/MygpDxkv9THKQyRUmavBpLK6iBV0abNWnn+CQgSRz//Pwg=="
       },
       "Microsoft.NETFramework.ReferenceAssemblies.net461": {
         "type": "Transitive",
@@ -57,8 +57,8 @@
       },
       "Microsoft.SourceLink.Common": {
         "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
+        "resolved": "10.0.102",
+        "contentHash": "Mk1IMb9q5tahC2NltxYXFkLBtuBvfBoCQ3pIxYQWfzbCE9o1OB9SsHe0hnNGo7lWgTA/ePbFAJLWu6nLL9K17A=="
       }
     }
   }

docs/API.md

@@ -0,0 +1,512 @@
+# API Quick Reference
+
+Quick reference for commonly used SharpCompress APIs.
+
+## Factory Methods
+
+### Opening Archives
+
+```csharp
+// Auto-detect format
+using (var reader = ReaderFactory.OpenReader(stream))
+{
+    // Works with Zip, Tar, GZip, Rar, 7Zip, etc.
+}
+
+// Specific format - Archive API
+using (var archive = ZipArchive.OpenArchive("file.zip"))
+using (var archive = TarArchive.OpenArchive("file.tar"))
+using (var archive = RarArchive.OpenArchive("file.rar"))
+using (var archive = SevenZipArchive.OpenArchive("file.7z"))
+using (var archive = GZipArchive.OpenArchive("file.gz"))
+
+// With options
+var options = new ReaderOptions
+{
+    Password = "password",
+    LeaveStreamOpen = true,
+    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
+};
+using (var archive = ZipArchive.OpenArchive("encrypted.zip", options))
+```
+
+### Creating Archives
+
+```csharp
+// Writer Factory
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    // Write entries
+}
+
+// Specific writer
+using (var archive = ZipArchive.CreateArchive())
+using (var archive = TarArchive.CreateArchive())
+using (var archive = GZipArchive.CreateArchive())
+
+// With options
+var options = new WriterOptions(CompressionType.Deflate)
+{
+    CompressionLevel = 9,
+    LeaveStreamOpen = false
+};
+using (var archive = ZipArchive.CreateArchive())
+{
+    archive.SaveTo("output.zip", options);
+}
+```
+
+---
+
+## Archive API Methods
+
+### Reading/Extracting
+
+```csharp
+using (var archive = ZipArchive.OpenArchive("file.zip"))
+{
+    // Get all entries
+    IEnumerable<IArchiveEntry> entries = archive.Entries;
+
+    // Find specific entry
+    var entry = archive.Entries.FirstOrDefault(e => e.Key == "file.txt");
+
+    // Extract all
+    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
+    {
+        ExtractFullPath = true,
+        Overwrite = true
+    });
+
+    // Extract single entry
+    var entry = archive.Entries.First();
+    entry.WriteToFile(@"C:\output\file.txt");
+    entry.WriteToFile(@"C:\output\file.txt", new ExtractionOptions { Overwrite = true });
+
+    // Get entry stream
+    using (var stream = entry.OpenEntryStream())
+    {
+        stream.CopyTo(outputStream);
+    }
+}
+
+// Async extraction (requires IAsyncArchive)
+using (var asyncArchive = await ZipArchive.OpenAsyncArchive("file.zip"))
+{
+    await asyncArchive.WriteToDirectoryAsync(
+        @"C:\output",
+        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
+        cancellationToken: cancellationToken
+    );
+}
+using (var stream = await entry.OpenEntryStreamAsync(cancellationToken))
+{
+    // ...
+}
+```
+
+### Entry Properties
+
+```csharp
+foreach (var entry in archive.Entries)
+{
+    string name = entry.Key;              // Entry name/path
+    long size = entry.Size;               // Uncompressed size
+    long compressedSize = entry.CompressedSize;
+    bool isDir = entry.IsDirectory;
+    DateTime? modTime = entry.LastModifiedTime;
+    CompressionType compression = entry.CompressionType;
+}
+```
+
+### Creating Archives
+
+```csharp
+using (var archive = ZipArchive.CreateArchive())
+{
+    // Add file
+    archive.AddEntry("file.txt", @"C:\source\file.txt");
+
+    // Add multiple files
+    archive.AddAllFromDirectory(@"C:\source");
+    archive.AddAllFromDirectory(@"C:\source", "*.txt");  // Pattern
+
+    // Save to file
+    archive.SaveTo("output.zip", CompressionType.Deflate);
+
+    // Save to stream
+    archive.SaveTo(outputStream, new WriterOptions(CompressionType.Deflate)
+    {
+        CompressionLevel = 9,
+        LeaveStreamOpen = true
+    });
+}
+```
+
+---
+
+## Reader API Methods
+
+### Forward-Only Reading
+
+```csharp
+using (var stream = File.OpenRead("file.zip"))
+using (var reader = ReaderFactory.OpenReader(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        IArchiveEntry entry = reader.Entry;
+
+        if (!entry.IsDirectory)
+        {
+            // Extract entry
+            reader.WriteEntryToDirectory(@"C:\output");
+            reader.WriteEntryToFile(@"C:\output\file.txt");
+
+            // Or get stream
+            using (var entryStream = reader.OpenEntryStream())
+            {
+                entryStream.CopyTo(outputStream);
+            }
+        }
+    }
+}
+
+// Async variants (use OpenAsyncReader to get IAsyncReader)
+using (var stream = File.OpenRead("file.zip"))
+using (var reader = await ReaderFactory.OpenAsyncReader(stream))
+{
+    while (await reader.MoveToNextEntryAsync())
+    {
+        await reader.WriteEntryToFileAsync(
+            @"C:\output\" + reader.Entry.Key,
+            cancellationToken: cancellationToken
+        );
+    }
+
+    // Async extraction of all entries
+    await reader.WriteAllToDirectoryAsync(
+        @"C:\output",
+        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
+        cancellationToken
+    );
+}
+```
+
+---
+
+## Writer API Methods
+
+### Creating Archives (Streaming)
+
+```csharp
+using (var stream = File.Create("output.zip"))
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    // Write single file
+    using (var fileStream = File.OpenRead("source.txt"))
+    {
+        writer.Write("entry.txt", fileStream, DateTime.Now);
+    }
+    
+    // Write directory
+    writer.WriteAll("C:\\source", "*", SearchOption.AllDirectories);
+    writer.WriteAll("C:\\source", "*.txt", SearchOption.TopDirectoryOnly);
+    
+    // Async variants
+    using (var fileStream = File.OpenRead("source.txt"))
+    {
+        await writer.WriteAsync("entry.txt", fileStream, DateTime.Now, cancellationToken);
+    }
+    
+    await writer.WriteAllAsync("C:\\source", "*", SearchOption.AllDirectories, cancellationToken);
+}
+```
+
+---
+
+## Common Options
+
+### ReaderOptions
+
+```csharp
+var options = new ReaderOptions
+{
+    Password = "password",                          // For encrypted archives
+    LeaveStreamOpen = true,                         // Don't close wrapped stream
+    ArchiveEncoding = new ArchiveEncoding          // Custom character encoding
+    {
+        Default = Encoding.GetEncoding(932)
+    }
+};
+using (var archive = ZipArchive.OpenArchive("file.zip", options))
+{
+    // ...
+}
+```
+
+### WriterOptions
+
+```csharp
+var options = new WriterOptions(CompressionType.Deflate)
+{
+    CompressionLevel = 9,                           // 0-9 for Deflate
+    LeaveStreamOpen = true,                         // Don't close stream
+};
+archive.SaveTo("output.zip", options);
+```
+
+### ExtractionOptions
+
+```csharp
+var options = new ExtractionOptions
+{
+    ExtractFullPath = true,                         // Recreate directory structure
+    Overwrite = true,                               // Overwrite existing files
+    PreserveFileTime = true                         // Keep original timestamps
+};
+archive.WriteToDirectory(@"C:\output", options);
+```
+
+---
+
+## Compression Types
+
+### Available Compressions
+
+```csharp
+// For creating archives
+CompressionType.None       // No compression (store)
+CompressionType.Deflate    // DEFLATE (default for ZIP/GZip)
+CompressionType.Deflate64  // Deflate64
+CompressionType.BZip2      // BZip2
+CompressionType.LZMA       // LZMA (for 7Zip, LZip, XZ)
+CompressionType.PPMd       // PPMd (for ZIP)
+CompressionType.Rar        // RAR compression (read-only)
+CompressionType.ZStandard  // ZStandard
+ArchiveType.Arc
+ArchiveType.Arj
+ArchiveType.Ace
+
+// For Tar archives with compression
+// Use WriterFactory to create compressed tar archives
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, CompressionType.GZip))  // Tar.GZip
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, CompressionType.BZip2)) // Tar.BZip2
+```
+
+### Archive Types
+
+```csharp
+ArchiveType.Zip
+ArchiveType.Tar
+ArchiveType.GZip
+ArchiveType.BZip2
+ArchiveType.Rar
+ArchiveType.SevenZip
+ArchiveType.XZ
+ArchiveType.ZStandard
+```
+
+---
+
+## Patterns & Examples
+
+### Extract with Error Handling
+
+```csharp
+try
+{
+    using (var archive = ZipArchive.Open("archive.zip", 
+        new ReaderOptions { Password = "password" }))
+    {
+        archive.WriteToDirectory(@"C:\output", new ExtractionOptions
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
+    }
+}
+catch (PasswordRequiredException)
+{
+    Console.WriteLine("Password required");
+}
+catch (InvalidArchiveException)
+{
+    Console.WriteLine("Archive is invalid");
+}
+catch (SharpCompressException ex)
+{
+    Console.WriteLine($"Error: {ex.Message}");
+}
+```
+
+### Extract with Progress
+
+```csharp
+var progress = new Progress<ProgressReport>(report =>
+{
+    Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
+});
+
+var options = new ReaderOptions { Progress = progress };
+using (var archive = ZipArchive.OpenArchive("archive.zip", options))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+```
+
+### Async Extract with Cancellation
+
+```csharp
+var cts = new CancellationTokenSource();
+cts.CancelAfter(TimeSpan.FromMinutes(5));
+
+try
+{
+    using (var archive = await ZipArchive.OpenAsyncArchive("archive.zip"))
+    {
+        await archive.WriteToDirectoryAsync(
+            @"C:\output",
+            new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
+            cancellationToken: cts.Token
+        );
+    }
+}
+catch (OperationCanceledException)
+{
+    Console.WriteLine("Extraction cancelled");
+}
+```
+
+### Create with Custom Compression
+
+```csharp
+using (var archive = ZipArchive.CreateArchive())
+{
+    archive.AddAllFromDirectory(@"D:\source");
+    
+    // Fastest
+    archive.SaveTo("fast.zip", new WriterOptions(CompressionType.Deflate)
+    {
+        CompressionLevel = 1
+    });
+    
+    // Balanced (default)
+    archive.SaveTo("normal.zip", CompressionType.Deflate);
+    
+    // Best compression
+    archive.SaveTo("best.zip", new WriterOptions(CompressionType.Deflate)
+    {
+        CompressionLevel = 9
+    });
+}
+```
+
+### Stream Processing (No File I/O)
+
+```csharp
+using (var outputStream = new MemoryStream())
+using (var archive = ZipArchive.CreateArchive())
+{
+    // Add content from memory
+    using (var contentStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello")))
+    {
+        archive.AddEntry("file.txt", contentStream);
+    }
+    
+    // Save to memory
+    archive.SaveTo(outputStream, CompressionType.Deflate);
+    
+    // Get bytes
+    byte[] archiveBytes = outputStream.ToArray();
+}
+```
+
+### Extract Specific Files
+
+```csharp
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
+{
+    var filesToExtract = new[] { "file1.txt", "file2.txt" };
+    
+    foreach (var entry in archive.Entries.Where(e => filesToExtract.Contains(e.Key)))
+    {
+        entry.WriteToFile(@"C:\output\" + entry.Key);
+    }
+}
+```
+
+### List Archive Contents
+
+```csharp
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
+{
+    foreach (var entry in archive.Entries)
+    {
+        if (entry.IsDirectory)
+            Console.WriteLine($"[DIR]  {entry.Key}");
+        else
+            Console.WriteLine($"[FILE] {entry.Key} ({entry.Size} bytes)");
+    }
+}
+```
+
+---
+
+## Common Mistakes
+
+### ✗ Wrong - Stream not disposed
+
+```csharp
+var stream = File.OpenRead("archive.zip");
+var archive = ZipArchive.OpenArchive(stream);
+archive.WriteToDirectory(@"C:\output");
+// stream not disposed - leaked resource
+```
+
+### ✓ Correct - Using blocks
+
+```csharp
+using (var stream = File.OpenRead("archive.zip"))
+using (var archive = ZipArchive.OpenArchive(stream))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+// Both properly disposed
+```
+
+### ✗ Wrong - Mixing API styles
+
+```csharp
+// Loading entire archive then iterating
+using (var archive = ZipArchive.OpenArchive("large.zip"))
+{
+    var entries = archive.Entries.ToList();  // Loads all in memory
+    foreach (var e in entries)
+    {
+        e.WriteToFile(...);  // Then extracts each
+    }
+}
+```
+
+### ✓ Correct - Use Reader for large files
+
+```csharp
+// Streaming iteration
+using (var stream = File.OpenRead("large.zip"))
+using (var reader = ReaderFactory.OpenReader(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        reader.WriteEntryToDirectory(@"C:\output");
+    }
+}
+```
+
+---
+
+## Related Documentation
+
+- [USAGE.md](USAGE.md) - Complete code examples
+- [FORMATS.md](FORMATS.md) - Supported formats
+- [PERFORMANCE.md](PERFORMANCE.md) - API selection guide

docs/ARCHITECTURE.md

@@ -0,0 +1,659 @@
+# SharpCompress Architecture Guide
+
+This guide explains the internal architecture and design patterns of SharpCompress for contributors.
+
+## Overview
+
+SharpCompress is organized into three main layers:
+
+```
+┌─────────────────────────────────────────┐
+│     User-Facing APIs (Top Layer)        │
+│  Archive, Reader, Writer Factories      │
+├─────────────────────────────────────────┤
+│     Format-Specific Implementations     │
+│  ZipArchive, TarReader, GZipWriter,     │
+│  RarArchive, SevenZipArchive, etc.      │
+├─────────────────────────────────────────┤
+│     Compression & Crypto (Bottom Layer) │
+│  Deflate, LZMA, BZip2, AES, CRC32       │
+└─────────────────────────────────────────┘
+```
+
+---
+
+## Directory Structure
+
+### `src/SharpCompress/`
+
+#### `Archives/` - Archive Implementations
+Contains `IArchive` implementations for seekable, random-access APIs.
+
+**Key Files:**
+- `AbstractArchive.cs` - Base class for all archives
+- `IArchive.cs` - Archive interface definition
+- `ArchiveFactory.cs` - Factory for opening archives
+- Format-specific: `ZipArchive.cs`, `TarArchive.cs`, `RarArchive.cs`, `SevenZipArchive.cs`, `GZipArchive.cs`
+
+**Use Archive API when:**
+- Stream is seekable (file, memory)
+- Need random access to entries
+- Archive fits in memory
+- Simplicity is important
+
+#### `Readers/` - Reader Implementations
+Contains `IReader` implementations for forward-only, non-seekable APIs.
+
+**Key Files:**
+- `AbstractReader.cs` - Base reader class
+- `IReader.cs` - Reader interface
+- `ReaderFactory.cs` - Auto-detection factory
+- `ReaderOptions.cs` - Configuration for readers
+- Format-specific: `ZipReader.cs`, `TarReader.cs`, `GZipReader.cs`, `RarReader.cs`, etc.
+
+**Use Reader API when:**
+- Stream is non-seekable (network, pipe, compressed)
+- Processing large files
+- Memory is limited
+- Forward-only processing is acceptable
+
+#### `Writers/` - Writer Implementations
+Contains `IWriter` implementations for forward-only writing.
+
+**Key Files:**
+- `AbstractWriter.cs` - Base writer class
+- `IWriter.cs` - Writer interface
+- `WriterFactory.cs` - Factory for creating writers
+- `WriterOptions.cs` - Configuration for writers
+- Format-specific: `ZipWriter.cs`, `TarWriter.cs`, `GZipWriter.cs`
+
+#### `Factories/` - Format Detection
+Factory classes for auto-detecting archive format and creating appropriate readers/writers.
+
+**Key Files:**
+- `Factory.cs` - Base factory class
+- `IFactory.cs` - Factory interface
+- Format-specific: `ZipFactory.cs`, `TarFactory.cs`, `RarFactory.cs`, etc.
+
+**How It Works:**
+1. `ReaderFactory.OpenReader(stream)` probes stream signatures
+2. Identifies format by magic bytes
+3. Creates appropriate reader instance
+4. Returns generic `IReader` interface
+
+#### `Common/` - Shared Types
+Common types, options, and enumerations used across formats.
+
+**Key Files:**
+- `IEntry.cs` - Entry interface (file within archive)
+- `Entry.cs` - Entry implementation
+- `ArchiveType.cs` - Enum for archive formats
+- `CompressionType.cs` - Enum for compression methods
+- `ArchiveEncoding.cs` - Character encoding configuration
+- `ExtractionOptions.cs` - Extraction configuration
+- Format-specific headers: `Zip/Headers/`, `Tar/Headers/`, `Rar/Headers/`, etc.
+
+#### `Compressors/` - Compression Algorithms
+Low-level compression streams implementing specific algorithms.
+
+**Algorithms:**
+- `Deflate/` - DEFLATE compression (Zip default)
+- `BZip2/` - BZip2 compression
+- `LZMA/` - LZMA compression (7Zip, XZ, LZip)
+- `PPMd/` - Prediction by Partial Matching (Zip, 7Zip)
+- `ZStandard/` - ZStandard compression (decompression only)
+- `Xz/` - XZ format (decompression only)
+- `Rar/` - RAR-specific unpacking
+- `Arj/`, `Arc/`, `Ace/` - Legacy format decompression
+- `Filters/` - BCJ/BCJ2 filters for executable compression
+
+**Each Compressor:**
+- Implements a `Stream` subclass
+- Provides both compression and decompression
+- Some are read-only (decompression only)
+
+#### `Crypto/` - Encryption & Hashing
+Cryptographic functions and stream wrappers.
+
+**Key Files:**
+- `Crc32Stream.cs` - CRC32 calculation wrapper
+- `BlockTransformer.cs` - Block cipher transformations
+- AES, PKWare, WinZip encryption implementations
+
+#### `IO/` - Stream Utilities
+Stream wrappers and utilities.
+
+**Key Classes:**
+- `SharpCompressStream` - Base stream class
+- `ProgressReportingStream` - Progress tracking wrapper
+- `MarkingBinaryReader` - Binary reader with position marks
+- `BufferedSubStream` - Buffered read-only substream
+- `ReadOnlySubStream` - Read-only view of parent stream
+- `NonDisposingStream` - Prevents wrapped stream disposal
+
+---
+
+## Design Patterns
+
+### 1. Factory Pattern
+
+**Purpose:** Auto-detect format and create appropriate reader/writer.
+
+**Example:**
+```csharp
+// User calls factory
+using (var reader = ReaderFactory.OpenReader(stream))  // Returns IReader
+{
+    while (reader.MoveToNextEntry())
+    {
+        // Process entry
+    }
+}
+
+// Behind the scenes:
+// 1. Factory.Open() probes stream signatures
+// 2. Detects format (Zip, Tar, Rar, etc.)
+// 3. Creates appropriate reader (ZipReader, TarReader, etc.)
+// 4. Returns as generic IReader interface
+```
+
+**Files:**
+- `src/SharpCompress/Factories/ReaderFactory.cs`
+- `src/SharpCompress/Factories/WriterFactory.cs`
+- `src/SharpCompress/Factories/ArchiveFactory.cs`
+
+### 2. Strategy Pattern
+
+**Purpose:** Encapsulate compression algorithms as swappable strategies.
+
+**Example:**
+```csharp
+// Different compression strategies
+CompressionType.Deflate     // DEFLATE
+CompressionType.BZip2       // BZip2
+CompressionType.LZMA        // LZMA
+CompressionType.PPMd        // PPMd
+
+// Writer uses strategy pattern
+var archive = ZipArchive.CreateArchive();
+archive.SaveTo("output.zip", CompressionType.Deflate);   // Use Deflate
+archive.SaveTo("output.bz2", CompressionType.BZip2);    // Use BZip2
+```
+
+**Files:**
+- `src/SharpCompress/Compressors/` - Strategy implementations
+
+### 3. Decorator Pattern
+
+**Purpose:** Wrap streams with additional functionality.
+
+**Example:**
+```csharp
+// Progress reporting decorator
+var progressStream = new ProgressReportingStream(baseStream, progressReporter);
+progressStream.Read(buffer, 0, buffer.Length);  // Reports progress
+
+// Non-disposing decorator
+var nonDisposingStream = new NonDisposingStream(baseStream);
+using (var compressor = new DeflateStream(nonDisposingStream))
+{
+    // baseStream won't be disposed when compressor is disposed
+}
+```
+
+**Files:**
+- `src/SharpCompress/IO/ProgressReportingStream.cs`
+- `src/SharpCompress/IO/NonDisposingStream.cs`
+
+### 4. Template Method Pattern
+
+**Purpose:** Define algorithm skeleton in base class, let subclasses fill details.
+
+**Example:**
+```csharp
+// AbstractArchive defines common archive operations
+public abstract class AbstractArchive : IArchive
+{
+    // Template methods
+    public virtual void WriteToDirectory(string destinationDirectory, ExtractionOptions options)
+    {
+        // Common extraction logic
+        foreach (var entry in Entries)
+        {
+            // Call subclass method
+            entry.WriteToFile(destinationPath, options);
+        }
+    }
+    
+    // Subclasses override format-specific details
+    protected abstract Entry CreateEntry(EntryData data);
+}
+```
+
+**Files:**
+- `src/SharpCompress/Archives/AbstractArchive.cs`
+- `src/SharpCompress/Readers/AbstractReader.cs`
+
+### 5. Iterator Pattern
+
+**Purpose:** Provide sequential access to entries.
+
+**Example:**
+```csharp
+// Archive API - provides collection
+IEnumerable<IEntry> entries = archive.Entries;
+foreach (var entry in entries)
+{
+    // Random access - entries already in memory
+}
+
+// Reader API - provides iterator
+IReader reader = ReaderFactory.OpenReader(stream);
+while (reader.MoveToNextEntry())
+{
+    // Forward-only iteration - one entry at a time
+    var entry = reader.Entry;
+}
+```
+
+---
+
+## Key Interfaces
+
+### IArchive - Random Access API
+
+```csharp
+public interface IArchive : IDisposable
+{
+    IEnumerable<IEntry> Entries { get; }
+    
+    void WriteToDirectory(string destinationDirectory, 
+                         ExtractionOptions options = null);
+    
+    IEntry FirstOrDefault(Func<IEntry, bool> predicate);
+    
+    // ... format-specific methods
+}
+```
+
+**Implementations:** `ZipArchive`, `TarArchive`, `RarArchive`, `SevenZipArchive`, `GZipArchive`
+
+### IReader - Forward-Only API
+
+```csharp
+public interface IReader : IDisposable
+{
+    IEntry Entry { get; }
+    
+    bool MoveToNextEntry();
+    
+    void WriteEntryToDirectory(string destinationDirectory,
+                              ExtractionOptions options = null);
+    
+    Stream OpenEntryStream();
+    
+    // ... async variants
+}
+```
+
+**Implementations:** `ZipReader`, `TarReader`, `RarReader`, `GZipReader`, etc.
+
+### IWriter - Writing API
+
+```csharp
+public interface IWriter : IDisposable
+{
+    void Write(string entryPath, Stream source, 
+              DateTime? modificationTime = null);
+    
+    void WriteAll(string sourceDirectory, string searchPattern,
+                 SearchOption searchOption);
+    
+    // ... async variants
+}
+```
+
+**Implementations:** `ZipWriter`, `TarWriter`, `GZipWriter`
+
+### IEntry - Archive Entry
+
+```csharp
+public interface IEntry
+{
+    string Key { get; }
+    uint Size { get; }
+    uint CompressedSize { get; }
+    bool IsDirectory { get; }
+    DateTime? LastModifiedTime { get; }
+    CompressionType CompressionType { get; }
+    
+    void WriteToFile(string fullPath, ExtractionOptions options = null);
+    void WriteToStream(Stream destinationStream);
+    Stream OpenEntryStream();
+    
+    // ... async variants
+}
+```
+
+---
+
+## Adding Support for a New Format
+
+### Step 1: Understand the Format
+- Research format specification
+- Understand compression/encryption used
+- Study existing similar formats in codebase
+
+### Step 2: Create Format Structure Classes
+
+**Create:** `src/SharpCompress/Common/NewFormat/`
+
+```csharp
+// Headers and data structures
+public class NewFormatHeader
+{
+    public uint Magic { get; set; }
+    public ushort Version { get; set; }
+    // ... other fields
+    
+    public static NewFormatHeader Read(BinaryReader reader)
+    {
+        // Deserialize from binary
+    }
+}
+
+public class NewFormatEntry
+{
+    public string FileName { get; set; }
+    public uint CompressedSize { get; set; }
+    public uint UncompressedSize { get; set; }
+    // ... other fields
+}
+```
+
+### Step 3: Create Archive Implementation
+
+**Create:** `src/SharpCompress/Archives/NewFormat/NewFormatArchive.cs`
+
+```csharp
+public class NewFormatArchive : AbstractArchive
+{
+    private NewFormatHeader _header;
+    private List<NewFormatEntry> _entries;
+    
+    public static NewFormatArchive OpenArchive(Stream stream)
+    {
+        var archive = new NewFormatArchive();
+        archive._header = NewFormatHeader.Read(stream);
+        archive.LoadEntries(stream);
+        return archive;
+    }
+    
+    public override IEnumerable<IEntry> Entries => _entries.Select(e => new Entry(e));
+    
+    protected override Stream OpenEntryStream(Entry entry)
+    {
+        // Return decompressed stream for entry
+    }
+    
+    // ... other abstract method implementations
+}
+```
+
+### Step 4: Create Reader Implementation
+
+**Create:** `src/SharpCompress/Readers/NewFormat/NewFormatReader.cs`
+
+```csharp
+public class NewFormatReader : AbstractReader
+{
+    private NewFormatHeader _header;
+    private BinaryReader _reader;
+    
+    public NewFormatReader(Stream stream)
+    {
+        _reader = new BinaryReader(stream);
+        _header = NewFormatHeader.Read(_reader);
+    }
+    
+    public override bool MoveToNextEntry()
+    {
+        // Read next entry header
+        if (!_reader.BaseStream.CanRead) return false;
+        
+        var entryData = NewFormatEntry.Read(_reader);
+        // ... set this.Entry
+        return entryData != null;
+    }
+    
+    // ... other abstract method implementations
+}
+```
+
+### Step 5: Create Factory
+
+**Create:** `src/SharpCompress/Factories/NewFormatFactory.cs`
+
+```csharp
+public class NewFormatFactory : Factory, IArchiveFactory, IReaderFactory
+{
+    // Archive format magic bytes (signature)
+    private static readonly byte[] NewFormatSignature = new byte[] { 0x4E, 0x46 };  // "NF"
+    
+    public static NewFormatFactory Instance { get; } = new();
+    
+    public IArchive CreateArchive(Stream stream)
+        => NewFormatArchive.OpenArchive(stream);
+    
+    public IReader CreateReader(Stream stream, ReaderOptions options)
+        => new NewFormatReader(stream) { Options = options };
+    
+    public bool Matches(Stream stream, ReadOnlySpan<byte> signature) 
+        => signature.StartsWith(NewFormatSignature);
+}
+```
+
+### Step 6: Register Factory
+
+**Update:** `src/SharpCompress/Factories/ArchiveFactory.cs`
+
+```csharp
+private static readonly IFactory[] Factories = 
+{
+    ZipFactory.Instance,
+    TarFactory.Instance,
+    RarFactory.Instance,
+    SevenZipFactory.Instance,
+    GZipFactory.Instance,
+    NewFormatFactory.Instance,  // Add here
+    // ... other factories
+};
+```
+
+### Step 7: Add Tests
+
+**Create:** `tests/SharpCompress.Test/NewFormat/NewFormatTests.cs`
+
+```csharp
+public class NewFormatTests : TestBase
+{
+    [Fact]
+    public void NewFormat_Extracts_Successfully()
+    {
+        var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "archive.newformat");
+        using (var archive = NewFormatArchive.OpenArchive(archivePath))
+        {
+            archive.WriteToDirectory(SCRATCH_FILES_PATH);
+            // Assert extraction
+        }
+    }
+    
+    [Fact]
+    public void NewFormat_Reader_Works()
+    {
+        var archivePath = Path.Combine(TEST_ARCHIVES_PATH, "archive.newformat");
+        using (var stream = File.OpenRead(archivePath))
+        using (var reader = new NewFormatReader(stream))
+        {
+            Assert.True(reader.MoveToNextEntry());
+            Assert.NotNull(reader.Entry);
+        }
+    }
+}
+```
+
+### Step 8: Add Test Archives
+
+Place test files in `tests/TestArchives/Archives/NewFormat/` directory.
+
+### Step 9: Document
+
+Update `docs/FORMATS.md` with format support information.
+
+---
+
+## Compression Algorithm Implementation
+
+### Creating a New Compression Stream
+
+**Example:** Creating `CustomStream` for a custom compression algorithm
+
+```csharp
+public class CustomStream : Stream
+{
+    private readonly Stream _baseStream;
+    private readonly bool _leaveOpen;
+    
+    public CustomStream(Stream baseStream, bool leaveOpen = false)
+    {
+        _baseStream = baseStream;
+        _leaveOpen = leaveOpen;
+    }
+    
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        // Decompress data from _baseStream into buffer
+        // Return number of decompressed bytes
+    }
+    
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        // Compress data from buffer into _baseStream
+    }
+    
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing && !_leaveOpen)
+        {
+            _baseStream?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+}
+```
+
+---
+
+## Stream Handling Best Practices
+
+### Disposal Pattern
+
+```csharp
+// Correct: Nested using blocks
+using (var fileStream = File.OpenRead("archive.zip"))
+using (var archive = ZipArchive.OpenArchive(fileStream))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+// Both archive and fileStream properly disposed
+
+// Correct: Using with options
+var options = new ReaderOptions { LeaveStreamOpen = true };
+var stream = File.OpenRead("archive.zip");
+using (var archive = ZipArchive.OpenArchive(stream, options))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+stream.Dispose();  // Manually dispose if LeaveStreamOpen = true
+```
+
+### NonDisposingStream Wrapper
+
+```csharp
+// Prevent unwanted stream closure
+var baseStream = File.OpenRead("data.bin");
+var nonDisposing = new NonDisposingStream(baseStream);
+
+using (var compressor = new DeflateStream(nonDisposing))
+{
+    // Compressor won't close baseStream when disposed
+}
+
+// baseStream still usable
+baseStream.Position = 0;  // Works
+baseStream.Dispose();  // Manual disposal
+```
+
+---
+
+## Performance Considerations
+
+### Memory Efficiency
+
+1. **Avoid loading entire archive in memory** - Use Reader API for large files
+2. **Process entries sequentially** - Especially for solid archives
+3. **Use appropriate buffer sizes** - Larger buffers for network I/O
+4. **Dispose streams promptly** - Free resources when done
+
+### Algorithm Selection
+
+1. **Archive API** - Fast for small archives with random access
+2. **Reader API** - Efficient for large files or streaming
+3. **Solid archives** - Sequential extraction much faster
+4. **Compression levels** - Trade-off between speed and size
+
+---
+
+## Testing Guidelines
+
+### Test Coverage
+
+1. **Happy path** - Normal extraction works
+2. **Edge cases** - Empty archives, single file, many files
+3. **Corrupted data** - Handle gracefully
+4. **Error cases** - Missing passwords, unsupported compression
+5. **Async operations** - Both sync and async code paths
+
+### Test Archives
+
+- Use `tests/TestArchives/` for test data
+- Create format-specific subdirectories
+- Include encrypted, corrupted, and edge case archives
+- Don't recreate existing archives
+
+### Test Patterns
+
+```csharp
+[Fact]
+public void Archive_Extraction_Works()
+{
+    // Arrange
+    var testArchive = Path.Combine(TEST_ARCHIVES_PATH, "test.zip");
+    
+    // Act
+    using (var archive = ZipArchive.OpenArchive(testArchive))
+    {
+        archive.WriteToDirectory(SCRATCH_FILES_PATH);
+    }
+    
+    // Assert
+    Assert.True(File.Exists(Path.Combine(SCRATCH_FILES_PATH, "file.txt")));
+}
+```
+
+---
+
+## Related Documentation
+
+- [AGENTS.md](../AGENTS.md) - Development guidelines
+- [FORMATS.md](FORMATS.md) - Supported formats

docs/ENCODING.md

@@ -0,0 +1,610 @@
+# SharpCompress Character Encoding Guide
+
+This guide explains how SharpCompress handles character encoding for archive entries (filenames, comments, etc.).
+
+## Overview
+
+Most archive formats store filenames and metadata as bytes. SharpCompress must convert these bytes to strings using the appropriate character encoding.
+
+**Common Problem:** Archives created on systems with non-UTF8 encodings (especially Japanese, Chinese systems) appear with corrupted filenames when extracted on systems that assume UTF8.
+
+---
+
+## ArchiveEncoding Class
+
+### Basic Usage
+
+```csharp
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+// Configure encoding before opening archive
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding(932)  // cp932 for Japanese
+    }
+};
+
+using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
+{
+    foreach (var entry in archive.Entries)
+    {
+        Console.WriteLine(entry.Key);  // Now shows correct characters
+    }
+}
+```
+
+### ArchiveEncoding Properties
+
+| Property | Purpose |
+|----------|---------|
+| `Default` | Default encoding for filenames (fallback) |
+| `CustomDecoder` | Custom decoding function for special cases |
+
+### Setting for Different APIs
+
+**Archive API:**
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
+};
+using (var archive = ZipArchive.OpenArchive("file.zip", options))
+{
+    // Use archive with correct encoding
+}
+```
+
+**Reader API:**
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
+};
+using (var stream = File.OpenRead("file.zip"))
+using (var reader = ReaderFactory.OpenReader(stream, options))
+{
+    while (reader.MoveToNextEntry())
+    {
+        // Filenames decoded correctly
+    }
+}
+```
+
+---
+
+## Common Encodings
+
+### Asian Encodings
+
+#### cp932 (Japanese)
+```csharp
+// Windows-31J, Shift-JIS variant used on Japanese Windows
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding(932)
+    }
+};
+using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
+{
+    // Correctly decodes Japanese filenames
+}
+```
+
+**When to use:**
+- Archives from Japanese Windows systems
+- Files with Japanese characters in names
+
+#### gb2312 (Simplified Chinese)
+```csharp
+// Simplified Chinese
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("gb2312")
+    }
+};
+```
+
+#### gbk (Extended Simplified Chinese)
+```csharp
+// Extended Simplified Chinese (more characters than gb2312)
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("gbk")
+    }
+};
+```
+
+#### big5 (Traditional Chinese)
+```csharp
+// Traditional Chinese (Taiwan, Hong Kong)
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("big5")
+    }
+};
+```
+
+#### euc-jp (Japanese, Unix)
+```csharp
+// Extended Unix Code for Japanese
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("eucjp")
+    }
+};
+```
+
+#### euc-kr (Korean)
+```csharp
+// Extended Unix Code for Korean
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("euc-kr")
+    }
+};
+```
+
+### Western European Encodings
+
+#### iso-8859-1 (Latin-1)
+```csharp
+// Western European (includes accented characters)
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("iso-8859-1")
+    }
+};
+```
+
+**When to use:**
+- Archives from French, German, Spanish systems
+- Files with accented characters (é, ñ, ü, etc.)
+
+#### cp1252 (Windows-1252)
+```csharp
+// Windows Western European
+// Very similar to iso-8859-1 but with additional printable characters
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("cp1252")
+    }
+};
+```
+
+**When to use:**
+- Archives from older Western European Windows systems
+- Files with smart quotes and other Windows-specific characters
+
+#### iso-8859-15 (Latin-9)
+```csharp
+// Western European with Euro symbol support
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("iso-8859-15")
+    }
+};
+```
+
+### Cyrillic Encodings
+
+#### cp1251 (Windows Cyrillic)
+```csharp
+// Russian, Serbian, Bulgarian, etc.
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("cp1251")
+    }
+};
+```
+
+#### koi8-r (KOI8 Russian)
+```csharp
+// Russian (Unix standard)
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("koi8-r")
+    }
+};
+```
+
+### UTF Encodings (Modern)
+
+#### UTF-8 (Default)
+```csharp
+// Modern standard - usually correct for new archives
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.UTF8
+    }
+};
+```
+
+#### UTF-16
+```csharp
+// Unicode - rarely used in archives
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.Unicode
+    }
+};
+```
+
+---
+
+## Encoding Auto-Detection
+
+SharpCompress attempts to auto-detect encoding, but this isn't always reliable:
+
+```csharp
+// Auto-detection (default)
+using (var archive = ZipArchive.OpenArchive("file.zip"))  // Uses UTF8 by default
+{
+    // May show corrupted characters if archive uses different encoding
+}
+
+// Explicit encoding (more reliable)
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
+};
+using (var archive = ZipArchive.OpenArchive("file.zip", options))
+{
+    // Correct characters displayed
+}
+```
+
+### When Manual Override is Needed
+
+| Situation | Solution |
+|-----------|----------|
+| Archive shows corrupted characters | Specify the encoding explicitly |
+| Archives from specific region | Use that region's encoding |
+| Mixed encodings in archive | Use CustomDecoder |
+| Testing with international files | Try different encodings |
+
+---
+
+## Custom Decoder
+
+For complex scenarios where a single encoding isn't sufficient:
+
+### Basic Custom Decoder
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding
+    {
+        CustomDecoder = (data, offset, length) =>
+        {
+            // Custom decoding logic
+            var bytes = new byte[length];
+            Array.Copy(data, offset, bytes, 0, length);
+            
+            // Try UTF8 first
+            try
+            {
+                return Encoding.UTF8.GetString(bytes);
+            }
+            catch
+            {
+                // Fallback to cp932 if UTF8 fails
+                return Encoding.GetEncoding(932).GetString(bytes);
+            }
+        }
+    }
+};
+
+using (var archive = ZipArchive.OpenArchive("mixed.zip", options))
+{
+    foreach (var entry in archive.Entries)
+    {
+        Console.WriteLine(entry.Key);  // Uses custom decoder
+    }
+}
+```
+
+### Advanced: Detect Encoding by Content
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding
+    {
+        CustomDecoder = DetectAndDecode
+    }
+};
+
+private static string DetectAndDecode(byte[] data, int offset, int length)
+{
+    var bytes = new byte[length];
+    Array.Copy(data, offset, bytes, 0, length);
+    
+    // Try UTF8 (most modern archives)
+    try
+    {
+        var str = Encoding.UTF8.GetString(bytes);
+        // Verify it decoded correctly (no replacement characters)
+        if (!str.Contains('\uFFFD'))
+            return str;
+    }
+    catch { }
+    
+    // Try cp932 (Japanese)
+    try
+    {
+        var str = Encoding.GetEncoding(932).GetString(bytes);
+        if (!str.Contains('\uFFFD'))
+            return str;
+    }
+    catch { }
+    
+    // Fallback to iso-8859-1 (always succeeds)
+    return Encoding.GetEncoding("iso-8859-1").GetString(bytes);
+}
+```
+
+---
+
+## Code Examples
+
+### Extract Archive with Japanese Filenames
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding(932)  // cp932
+    }
+};
+
+using (var archive = ZipArchive.OpenArchive("japanese_files.zip", options))
+{
+    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
+    {
+        ExtractFullPath = true,
+        Overwrite = true
+    });
+}
+// Files extracted with correct Japanese names
+```
+
+### Extract Archive with Western European Filenames
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("iso-8859-1")
+    }
+};
+
+using (var archive = ZipArchive.OpenArchive("french_files.zip", options))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+// Accented characters (é, è, ê, etc.) display correctly
+```
+
+### Extract Archive with Chinese Filenames
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("gbk")  // Simplified Chinese
+    }
+};
+
+using (var archive = ZipArchive.OpenArchive("chinese_files.zip", options))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+```
+
+### Extract Archive with Russian Filenames
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("cp1251")  // Windows Cyrillic
+    }
+};
+
+using (var archive = ZipArchive.OpenArchive("russian_files.zip", options))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+```
+
+### Reader API with Encoding
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding(932)
+    }
+};
+
+using (var stream = File.OpenRead("japanese.zip"))
+using (var reader = ReaderFactory.OpenReader(stream, options))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            Console.WriteLine(reader.Entry.Key);  // Correct characters
+            reader.WriteEntryToDirectory(@"C:\output");
+        }
+    }
+}
+```
+
+---
+
+## Creating Archives with Correct Encoding
+
+When creating archives, SharpCompress uses UTF8 by default (recommended):
+
+```csharp
+// Create with UTF8 (default, recommended)
+using (var archive = ZipArchive.CreateArchive())
+{
+    archive.AddAllFromDirectory(@"D:\my_files");
+    archive.SaveTo("output.zip", CompressionType.Deflate);
+    // Archives created with UTF8 encoding
+}
+```
+
+If you need to create archives for systems that expect specific encodings:
+
+```csharp
+// Note: SharpCompress Writer API uses UTF8 for encoding
+// To create archives with other encodings, consider:
+// 1. Let users on those systems create archives
+// 2. Use system tools (7-Zip, WinRAR) with desired encoding
+// 3. Post-process archives if absolutely necessary
+
+// For now, recommend modern UTF8-based archives
+```
+
+---
+
+## Troubleshooting Encoding Issues
+
+### Filenames Show Question Marks (?)
+
+```
+✗ Wrong encoding detected
+test文件.txt → test???.txt
+```
+
+**Solution:** Specify correct encoding explicitly
+
+```csharp
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding 
+    { 
+        Default = Encoding.GetEncoding("gbk")  // Try different encodings
+    }
+};
+```
+
+### Filenames Show Replacement Character (￿)
+
+```
+✗ Invalid bytes for selected encoding
+café.txt → caf￿.txt
+```
+
+**Solution:**
+1. Try a different encoding (see Common Encodings table)
+2. Use CustomDecoder with fallback encoding
+3. Archive might be corrupted
+
+### Mixed Encodings in Single Archive
+
+```csharp
+// Use CustomDecoder to handle mixed encodings
+var options = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding
+    {
+        CustomDecoder = (data, offset, length) =>
+        {
+            // Try multiple encodings in priority order
+            var bytes = new byte[length];
+            Array.Copy(data, offset, bytes, 0, length);
+            
+            foreach (var encoding in new[] 
+            {
+                Encoding.UTF8,
+                Encoding.GetEncoding(932),
+                Encoding.GetEncoding("iso-8859-1")
+            })
+            {
+                try
+                {
+                    var str = encoding.GetString(bytes);
+                    if (!str.Contains('\uFFFD'))
+                        return str;
+                }
+                catch { }
+            }
+            
+            // Final fallback
+            return Encoding.GetEncoding("iso-8859-1").GetString(bytes);
+        }
+    }
+};
+```
+
+---
+
+## Encoding Reference Table
+
+| Encoding | Code | Use Case |
+|----------|------|----------|
+| UTF-8 | (default) | Modern archives, recommended |
+| cp932 | 932 | Japanese Windows |
+| gb2312 | "gb2312" | Simplified Chinese |
+| gbk | "gbk" | Extended Simplified Chinese |
+| big5 | "big5" | Traditional Chinese |
+| iso-8859-1 | "iso-8859-1" | Western European |
+| cp1252 | "cp1252" | Windows Western European |
+| cp1251 | "cp1251" | Russian/Cyrillic |
+| euc-jp | "euc-jp" | Japanese Unix |
+| euc-kr | "euc-kr" | Korean |
+
+---
+
+## Best Practices
+
+1. **Use UTF-8 for new archives** - Most modern systems support it
+2. **Ask the archive creator** - When receiving archives with corrupted names
+3. **Provide encoding options** - If your app handles user archives
+4. **Document your assumption** - Tell users what encoding you're using
+5. **Test with international files** - Before releasing production code
+
+---
+
+## Related Documentation
+
+- [USAGE.md](USAGE.md#extract-zip-which-has-non-utf8-encoded-filenamycp932) - Usage examples

docs/PERFORMANCE.md

@@ -0,0 +1,474 @@
+# SharpCompress Performance Guide
+
+This guide helps you optimize SharpCompress for performance in various scenarios.
+
+## API Selection Guide
+
+### Archive API vs Reader API
+
+Choose the right API based on your use case:
+
+| Aspect | Archive API | Reader API |
+|--------|------------|-----------|
+| **Stream Type** | Seekable only | Non-seekable OK |
+| **Memory Usage** | All entries in memory | One entry at a time |
+| **Random Access** | ✓ Yes | ✗ No |
+| **Best For** | Small-to-medium archives | Large or streaming data |
+| **Performance** | Fast for random access | Better for large files |
+
+### Archive API (Fast for Random Access)
+
+```csharp
+// Use when:
+// - Archive fits in memory
+// - You need random access to entries
+// - Stream is seekable (file, MemoryStream)
+
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
+{
+    // Random access - all entries available
+    var specific = archive.Entries.FirstOrDefault(e => e.Key == "file.txt");
+    if (specific != null)
+    {
+        specific.WriteToFile(@"C:\output\file.txt");
+    }
+}
+```
+
+**Performance Characteristics:**
+- ✓ Instant entry lookup
+- ✓ Parallel extraction possible
+- ✗ Entire archive in memory
+- ✗ Can't process while downloading
+
+### Reader API (Best for Large Files)
+
+```csharp
+// Use when:
+// - Processing large archives (>100 MB)
+// - Streaming from network/pipe
+// - Memory is constrained
+// - Forward-only processing is acceptable
+
+using (var stream = File.OpenRead("large.zip"))
+using (var reader = ReaderFactory.OpenReader(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        // Process one entry at a time
+        reader.WriteEntryToDirectory(@"C:\output");
+    }
+}
+```
+
+**Performance Characteristics:**
+- ✓ Minimal memory footprint
+- ✓ Works with non-seekable streams
+- ✓ Can process while downloading
+- ✗ Forward-only (no random access)
+- ✗ Entry lookup requires iteration
+
+---
+
+## Buffer Sizing
+
+### Understanding Buffers
+
+SharpCompress uses internal buffers for reading compressed data. Buffer size affects:
+- **Speed:** Larger buffers = fewer I/O operations = faster
+- **Memory:** Larger buffers = higher memory usage
+
+### Recommended Buffer Sizes
+
+| Scenario | Size | Notes |
+|----------|------|-------|
+| Embedded/IoT devices | 4-8 KB | Minimal memory usage |
+| Memory-constrained | 16-32 KB | Conservative default |
+| Standard use (default) | 64 KB | Recommended default |
+| Large file streaming | 256 KB | Better throughput |
+| High-speed SSD | 512 KB - 1 MB | Maximum throughput |
+
+### How Buffer Size Affects Performance
+
+```csharp
+// SharpCompress manages buffers internally
+// You can't directly set buffer size, but you can:
+
+// 1. Use Stream.CopyTo with explicit buffer size
+using (var entryStream = reader.OpenEntryStream())
+using (var fileStream = File.Create(@"C:\output\file.txt"))
+{
+    // 64 KB buffer (default)
+    entryStream.CopyTo(fileStream);
+    
+    // Or specify larger buffer for faster copy
+    entryStream.CopyTo(fileStream, bufferSize: 262144);  // 256 KB
+}
+
+// 2. Use custom buffer for writing
+using (var entryStream = reader.OpenEntryStream())
+using (var fileStream = File.Create(@"C:\output\file.txt"))
+{
+    byte[] buffer = new byte[262144];  // 256 KB
+    int bytesRead;
+    while ((bytesRead = entryStream.Read(buffer, 0, buffer.Length)) > 0)
+    {
+        fileStream.Write(buffer, 0, bytesRead);
+    }
+}
+```
+
+---
+
+## Streaming Large Files
+
+### Non-Seekable Stream Patterns
+
+For processing archives from downloads or pipes:
+
+```csharp
+// Download stream (non-seekable)
+using (var httpStream = await httpClient.GetStreamAsync(url))
+using (var reader = ReaderFactory.OpenReader(httpStream))
+{
+    // Process entries as they arrive
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            reader.WriteEntryToDirectory(@"C:\output");
+        }
+    }
+}
+```
+
+**Performance Tips:**
+- Don't try to buffer the entire stream
+- Process entries immediately
+- Use async APIs for better responsiveness
+
+### Download-Then-Extract vs Streaming
+
+Choose based on your constraints:
+
+| Approach | When to Use |
+|----------|------------|
+| **Download then extract** | Moderate size, need random access |
+| **Stream during download** | Large files, bandwidth limited, memory constrained |
+
+```csharp
+// Download then extract (requires disk space)
+var archivePath = await DownloadFile(url, @"C:\temp\archive.zip");
+using (var archive = ZipArchive.OpenArchive(archivePath))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+
+// Stream during download (on-the-fly extraction)
+using (var httpStream = await httpClient.GetStreamAsync(url))
+using (var reader = ReaderFactory.OpenReader(httpStream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        reader.WriteEntryToDirectory(@"C:\output");
+    }
+}
+```
+
+---
+
+## Solid Archive Optimization
+
+### Why Solid Archives Are Slow
+
+Solid archives (Rar, 7Zip) group files together in a single compressed stream:
+
+```
+Solid Archive Layout:
+[Header] [Compressed Stream] [Footer]
+         ├─ File1 compressed data
+         ├─ File2 compressed data
+         ├─ File3 compressed data
+         └─ File4 compressed data
+```
+
+Extracting File3 requires decompressing File1 and File2 first.
+
+### Sequential vs Random Extraction
+
+**Random Extraction (Slow):**
+```csharp
+using (var archive = RarArchive.OpenArchive("solid.rar"))
+{
+    foreach (var entry in archive.Entries)
+    {
+        entry.WriteToFile(@"C:\output\" + entry.Key);  // ✗ Slow!
+        // Each entry triggers full decompression from start
+    }
+}
+```
+
+**Sequential Extraction (Fast):**
+```csharp
+using (var archive = RarArchive.OpenArchive("solid.rar"))
+{
+    // Method 1: Use WriteToDirectory (recommended)
+    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
+    {
+        ExtractFullPath = true,
+        Overwrite = true
+    });
+    
+    // Method 2: Use ExtractAllEntries
+    archive.ExtractAllEntries();
+    
+    // Method 3: Use Reader API (also sequential)
+    using (var reader = RarReader.Open(File.OpenRead("solid.rar")))
+    {
+        while (reader.MoveToNextEntry())
+        {
+            reader.WriteEntryToDirectory(@"C:\output");
+        }
+    }
+}
+```
+
+**Performance Impact:**
+- Random extraction: O(n²) - very slow for many files
+- Sequential extraction: O(n) - 10-100x faster
+
+### Best Practices for Solid Archives
+
+1. **Always extract sequentially** when possible
+2. **Use Reader API** for large solid archives
+3. **Process entries in order** from the archive
+4. **Consider using 7Zip command-line** for scripted extractions
+
+---
+
+## Compression Level Trade-offs
+
+### Deflate/GZip Levels
+
+```csharp
+// Level 1 = Fastest, largest size
+// Level 6 = Default (balanced)
+// Level 9 = Slowest, best compression
+
+// Write with different compression levels
+using (var archive = ZipArchive.CreateArchive())
+{
+    archive.AddAllFromDirectory(@"D:\data");
+    
+    // Fast compression (level 1)
+    archive.SaveTo("fast.zip", new WriterOptions(CompressionType.Deflate)
+    {
+        CompressionLevel = 1
+    });
+    
+    // Default compression (level 6)
+    archive.SaveTo("default.zip", CompressionType.Deflate);
+    
+    // Best compression (level 9)
+    archive.SaveTo("best.zip", new WriterOptions(CompressionType.Deflate)
+    {
+        CompressionLevel = 9
+    });
+}
+```
+
+**Speed vs Size:**
+| Level | Speed | Size | Use Case |
+|-------|-------|------|----------|
+| 1 | 10x | 90% | Network, streaming |
+| 6 | 1x | 75% | Default (good balance) |
+| 9 | 0.1x | 65% | Archival, static storage |
+
+### BZip2 Block Size
+
+```csharp
+// BZip2 block size affects memory and compression
+// 100K to 900K (default 900K)
+
+// Smaller block size = lower memory, faster
+// Larger block size = better compression, slower
+
+using (var archive = TarArchive.CreateArchive())
+{
+    archive.AddAllFromDirectory(@"D:\data");
+    
+    // These are preset in WriterOptions via CompressionLevel
+    archive.SaveTo("archive.tar.bz2", CompressionType.BZip2);
+}
+```
+
+### LZMA Settings
+
+LZMA compression is very powerful but memory-intensive:
+
+```csharp
+// LZMA (7Zip, .tar.lzma):
+// - Dictionary size: 16 KB to 1 GB (default 32 MB)
+// - Faster preset: smaller dictionary
+// - Better compression: larger dictionary
+
+// Preset via CompressionType
+using (var archive = TarArchive.CreateArchive())
+{
+    archive.AddAllFromDirectory(@"D:\data");
+    archive.SaveTo("archive.tar.xz", CompressionType.LZMA);  // Default settings
+}
+```
+
+---
+
+## Async Performance
+
+### When Async Helps
+
+Async is beneficial when:
+- **Long I/O operations** (network, slow disks)
+- **UI responsiveness** needed (Windows Forms, WPF, Blazor)
+- **Server applications** (ASP.NET, multiple concurrent operations)
+
+```csharp
+// Async extraction (non-blocking)
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
+{
+    await archive.WriteToDirectoryAsync(
+        @"C:\output",
+        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
+        cancellationToken
+    );
+}
+// Thread can handle other work while I/O happens
+```
+
+### When Async Doesn't Help
+
+Async doesn't improve performance for:
+- **CPU-bound operations** (already fast)
+- **Local SSD I/O** (I/O is fast enough)
+- **Single-threaded scenarios** (no parallelism benefit)
+
+```csharp
+// Sync extraction (simpler, same performance on fast I/O)
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
+{
+    archive.WriteToDirectory(
+        @"C:\output",
+        new ExtractionOptions { ExtractFullPath = true, Overwrite = true }
+    );
+}
+// Simple and fast - no async needed
+```
+
+### Cancellation Pattern
+
+```csharp
+var cts = new CancellationTokenSource();
+
+// Cancel after 5 minutes
+cts.CancelAfter(TimeSpan.FromMinutes(5));
+
+try
+{
+    using (var archive = ZipArchive.OpenArchive("archive.zip"))
+    {
+        await archive.WriteToDirectoryAsync(
+            @"C:\output",
+            new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
+            cts.Token
+        );
+    }
+}
+catch (OperationCanceledException)
+{
+    Console.WriteLine("Extraction cancelled");
+    // Clean up partial extraction if needed
+}
+```
+
+---
+
+## Practical Performance Tips
+
+### 1. Choose the Right API
+
+| Scenario | API | Why |
+|----------|-----|-----|
+| Small archives | Archive | Faster random access |
+| Large archives | Reader | Lower memory |
+| Streaming | Reader | Works on non-seekable streams |
+| Download streams | Reader | Async extraction while downloading |
+
+### 2. Batch Operations
+
+```csharp
+// ✗ Slow - opens each archive separately
+foreach (var file in files)
+{
+    using (var archive = ZipArchive.OpenArchive("archive.zip"))
+    {
+        archive.WriteToDirectory(@"C:\output");
+    }
+}
+
+// ✓ Better - process multiple entries at once
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+```
+
+### 3. Profile Your Code
+
+```csharp
+var sw = Stopwatch.StartNew();
+using (var archive = ZipArchive.OpenArchive("large.zip"))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+sw.Stop();
+
+Console.WriteLine($"Extraction took {sw.ElapsedMilliseconds}ms");
+
+// Measure memory before/after
+var beforeMem = GC.GetTotalMemory(true);
+// ... do work ...
+var afterMem = GC.GetTotalMemory(true);
+Console.WriteLine($"Memory used: {(afterMem - beforeMem) / 1024 / 1024}MB");
+```
+
+---
+
+## Troubleshooting Performance
+
+### Extraction is Slow
+
+1. **Check if solid archive** → Use sequential extraction
+2. **Check API** → Reader API might be faster for large files
+3. **Check compression level** → Higher levels are slower to decompress
+4. **Check I/O** → Network drives are much slower than SSD
+5. **Check buffer size** → May need larger buffers for network
+
+### High Memory Usage
+
+1. **Use Reader API** instead of Archive API
+2. **Process entries immediately** rather than buffering
+3. **Reduce compression level** if writing
+4. **Check for memory leaks** in your code
+
+### CPU Usage at 100%
+
+1. **Normal for compression** - especially with high compression levels
+2. **Consider lower level** for faster processing
+3. **Reduce parallelism** if processing multiple archives
+4. **Check if awaiting properly** in async code
+
+---
+
+## Related Documentation
+
+- [PERFORMANCE.md](USAGE.md) - Usage examples with performance considerations
+- [FORMATS.md](FORMATS.md) - Format-specific performance notes

docs/USAGE.md

@@ -1,6 +1,6 @@
 # SharpCompress Usage
 
-## Async/Await Support
+## Async/Await Support (Beta)
 
 SharpCompress now provides full async/await support for all I/O operations. All `Read`, `Write`, and extraction operations have async equivalents ending in `Async` that accept an optional `CancellationToken`. This enables better performance and scalability for I/O-bound operations.
 
@@ -13,7 +13,7 @@ SharpCompress now provides full async/await support for all I/O operations. All
 
 See [Async Examples](#async-examples) section below for usage patterns.
 
-## Stream Rules (changed with 0.21)
+## Stream Rules
 
 When dealing with Streams, the rule should be that you don't close a stream you didn't create. This, in effect, should mean you should always put a Stream in a using block to dispose it. 
 
@@ -48,7 +48,7 @@ Also, look over the tests for more thorough [examples](https://github.com/adamha
 
 ### Create Zip Archive from multiple files
 ```C#
-using(var archive = ZipArchive.Create())
+using(var archive = ZipArchive.CreateArchive())
 {
     archive.AddEntry("file01.txt", "C:\\file01.txt");
     archive.AddEntry("file02.txt", "C:\\file02.txt");
@@ -61,7 +61,7 @@ using(var archive = ZipArchive.Create())
 ### Create Zip Archive from all files in a directory to a file
 
 ```C#
-using (var archive = ZipArchive.Create())
+using (var archive = ZipArchive.CreateArchive())
 {
     archive.AddAllFromDirectory("D:\\temp");
     archive.SaveTo("C:\\temp.zip", CompressionType.Deflate);
@@ -72,7 +72,7 @@ using (var archive = ZipArchive.Create())
 
 ```C#
 var memoryStream = new MemoryStream();
-using (var archive = ZipArchive.Create())
+using (var archive = ZipArchive.CreateArchive())
 {
     archive.AddAllFromDirectory("D:\\temp");
     archive.SaveTo(memoryStream, new WriterOptions(CompressionType.Deflate)
@@ -90,7 +90,7 @@ Note: Extracting a solid rar or 7z file needs to be done in sequential order to
 `ExtractAllEntries` is primarily intended for solid archives (like solid Rar) or 7Zip archives, where sequential extraction provides the best performance. For general/simple extraction with any supported archive type, use `archive.WriteToDirectory()` instead.
 
 ```C#
-using (var archive = RarArchive.Open("Test.rar"))
+using (var archive = RarArchive.OpenArchive("Test.rar"))
 {
     // Simple extraction with RarArchive; this WriteToDirectory pattern works for all archive types
     archive.WriteToDirectory(@"D:\temp", new ExtractionOptions()
@@ -104,7 +104,7 @@ using (var archive = RarArchive.Open("Test.rar"))
 ### Iterate over all files from a Rar file using RarArchive
 
 ```C#
-using (var archive = RarArchive.Open("Test.rar"))
+using (var archive = RarArchive.OpenArchive("Test.rar"))
 {
     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
     {
@@ -126,7 +126,7 @@ var progress = new Progress<ProgressReport>(report =>
     Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
 });
 
-using (var archive = RarArchive.Open("archive.rar", new ReaderOptions { Progress = progress })) // Must be solid Rar or 7Zip
+using (var archive = RarArchive.OpenArchive("archive.rar", new ReaderOptions { Progress = progress })) // Must be solid Rar or 7Zip
 {
     archive.WriteToDirectory(@"D:\output", new ExtractionOptions()
     {
@@ -140,7 +140,7 @@ using (var archive = RarArchive.Open("archive.rar", new ReaderOptions { Progress
 
 ```C#
 using (Stream stream = File.OpenRead("Tar.tar.bz2"))
-using (var reader = ReaderFactory.Open(stream))
+using (var reader = ReaderFactory.OpenReader(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -161,7 +161,7 @@ using (var reader = ReaderFactory.Open(stream))
 
 ```C#
 using (Stream stream = File.OpenRead("Tar.tar.bz2"))
-using (var reader = ReaderFactory.Open(stream))
+using (var reader = ReaderFactory.OpenReader(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -180,7 +180,7 @@ using (var reader = ReaderFactory.Open(stream))
 
 ```C#
 using (Stream stream = File.OpenWrite("C:\\temp.tgz"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
                                                 {
                                                     LeaveOpenStream = true
                                                 }))
@@ -199,7 +199,7 @@ opts.ArchiveEncoding.CustomDecoder = (data, x, y) =>
 {
     return encoding.GetString(data);
 };
-var tr = SharpCompress.Archives.Zip.ZipArchive.Open("test.zip", opts);
+var tr = SharpCompress.Archives.Zip.ZipArchive.OpenArchive("test.zip", opts);
 foreach(var entry in tr.Entries)
 {
     Console.WriteLine($"{entry.Key}");
@@ -213,7 +213,7 @@ foreach(var entry in tr.Entries)
 **Extract single entry asynchronously:**
 ```C#
 using (Stream stream = File.OpenRead("archive.zip"))
-using (var reader = ReaderFactory.Open(stream))
+using (var reader = ReaderFactory.OpenReader(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -234,7 +234,7 @@ using (var reader = ReaderFactory.Open(stream))
 **Extract all entries asynchronously:**
 ```C#
 using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.Open(stream))
+using (var reader = ReaderFactory.OpenReader(stream))
 {
     await reader.WriteAllToDirectoryAsync(
         @"D:\temp",
@@ -250,7 +250,7 @@ using (var reader = ReaderFactory.Open(stream))
 
 **Open and process entry stream asynchronously:**
 ```C#
-using (var archive = ZipArchive.Open("archive.zip"))
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
 {
     foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
     {
@@ -268,7 +268,7 @@ using (var archive = ZipArchive.Open("archive.zip"))
 **Write single file asynchronously:**
 ```C#
 using (Stream archiveStream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
+using (var writer = WriterFactory.OpenWriter(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
 {
     using (Stream fileStream = File.OpenRead("input.txt"))
     {
@@ -280,7 +280,7 @@ using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, Compressi
 **Write entire directory asynchronously:**
 ```C#
 using (Stream stream = File.OpenWrite("backup.tar.gz"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
 {
     await writer.WriteAllAsync(
         @"D:\files",
@@ -299,7 +299,7 @@ var cts = new CancellationTokenSource();
 cts.CancelAfter(TimeSpan.FromMinutes(5));
 
 using (Stream stream = File.OpenWrite("archive.zip"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
+using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
 {
     try
     {
@@ -316,7 +316,7 @@ using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.
 
 **Extract from archive asynchronously:**
 ```C#
-using (var archive = ZipArchive.Open("archive.zip"))
+using (var archive = ZipArchive.OpenArchive("archive.zip"))
 {
     // Simple async extraction - works for all archive types
     await archive.WriteToDirectoryAsync(

src/SharpCompress/Algorithms/Adler32.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1 && !NETFRAMEWORK
+#if !LEGACY_DOTNET
 #define SUPPORTS_RUNTIME_INTRINSICS
 #define SUPPORTS_HOTPATH
 #endif

src/SharpCompress/Archives/AbstractArchive.Async.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+public abstract partial class AbstractArchive<TEntry, TVolume>
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
+{
+    #region Async Support
+
+    // Async properties
+    public virtual IAsyncEnumerable<TEntry> EntriesAsync => _lazyEntriesAsync;
+
+    public IAsyncEnumerable<TVolume> VolumesAsync => _lazyVolumesAsync;
+
+    protected virtual async IAsyncEnumerable<TEntry> LoadEntriesAsync(
+        IAsyncEnumerable<TVolume> volumes
+    )
+    {
+        foreach (var item in LoadEntries(await volumes.ToListAsync()))
+        {
+            yield return item;
+        }
+    }
+
+    public virtual async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            await foreach (var v in _lazyVolumesAsync)
+            {
+                v.Dispose();
+            }
+            foreach (var v in _lazyEntriesAsync.GetLoaded().Cast<Entry>())
+            {
+                v.Close();
+            }
+            _sourceStream?.Dispose();
+
+            _disposed = true;
+        }
+    }
+
+    private async ValueTask EnsureEntriesLoadedAsync()
+    {
+        await _lazyEntriesAsync.EnsureFullyLoaded();
+        await _lazyVolumesAsync.EnsureFullyLoaded();
+    }
+
+    private async IAsyncEnumerable<IArchiveEntry> EntriesAsyncCast()
+    {
+        await foreach (var entry in EntriesAsync)
+        {
+            yield return entry;
+        }
+    }
+
+    IAsyncEnumerable<IArchiveEntry> IAsyncArchive.EntriesAsync => EntriesAsyncCast();
+
+    IAsyncEnumerable<IVolume> IAsyncArchive.VolumesAsync => VolumesAsyncCast();
+
+    private async IAsyncEnumerable<IVolume> VolumesAsyncCast()
+    {
+        await foreach (var volume in _lazyVolumesAsync)
+        {
+            yield return volume;
+        }
+    }
+
+    public async ValueTask<IAsyncReader> ExtractAllEntriesAsync()
+    {
+        if (!await IsSolidAsync() && Type != ArchiveType.SevenZip)
+        {
+            throw new SharpCompressException(
+                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
+            );
+        }
+        await EnsureEntriesLoadedAsync();
+        return await CreateReaderForSolidExtractionAsync();
+    }
+
+    public virtual ValueTask<bool> IsSolidAsync() => new(false);
+
+    public async ValueTask<bool> IsCompleteAsync()
+    {
+        await EnsureEntriesLoadedAsync();
+        return await EntriesAsync.AllAsync(x => x.IsComplete);
+    }
+
+    public async ValueTask<long> TotalSizeAsync() =>
+        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
+
+    public async ValueTask<long> TotalUncompressedSizeAsync() =>
+        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.Size);
+
+    public ValueTask<bool> IsEncryptedAsync() => new(IsEncrypted);
+
+    #endregion
+}

src/SharpCompress/Archives/AbstractArchive.cs

@@ -7,7 +7,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
+public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -16,6 +16,10 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     private bool _disposed;
     private readonly SourceStream? _sourceStream;
 
+    // Async fields - kept in original file per refactoring rules
+    private readonly LazyAsyncReadOnlyCollection<TVolume> _lazyVolumesAsync;
+    private readonly LazyAsyncReadOnlyCollection<TEntry> _lazyEntriesAsync;
+
     protected ReaderOptions ReaderOptions { get; }
 
     internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
@@ -68,7 +72,7 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     /// <summary>
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
-    public virtual long TotalUncompressSize =>
+    public virtual long TotalUncompressedSize =>
         Entries.Aggregate(0L, (total, cf) => total + cf.Size);
 
     protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
@@ -77,16 +81,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     protected virtual IAsyncEnumerable<TVolume> LoadVolumesAsync(SourceStream sourceStream) =>
         LoadVolumes(sourceStream).ToAsyncEnumerable();
 
-    protected virtual async IAsyncEnumerable<TEntry> LoadEntriesAsync(
-        IAsyncEnumerable<TVolume> volumes
-    )
-    {
-        foreach (var item in LoadEntries(await volumes.ToListAsync()))
-        {
-            yield return item;
-        }
-    }
-
     IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
 
     IEnumerable<IVolume> IArchive.Volumes => _lazyVolumes.Cast<IVolume>();
@@ -156,67 +150,4 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
             return Entries.All(x => x.IsComplete);
         }
     }
-
-    #region Async Support
-
-    private readonly LazyAsyncReadOnlyCollection<TVolume> _lazyVolumesAsync;
-    private readonly LazyAsyncReadOnlyCollection<TEntry> _lazyEntriesAsync;
-
-    public virtual async ValueTask DisposeAsync()
-    {
-        if (!_disposed)
-        {
-            await foreach (var v in _lazyVolumesAsync)
-            {
-                v.Dispose();
-            }
-            foreach (var v in _lazyEntriesAsync.GetLoaded().Cast<Entry>())
-            {
-                v.Close();
-            }
-            _sourceStream?.Dispose();
-
-            _disposed = true;
-        }
-    }
-
-    private async ValueTask EnsureEntriesLoadedAsync()
-    {
-        await _lazyEntriesAsync.EnsureFullyLoaded();
-        await _lazyVolumesAsync.EnsureFullyLoaded();
-    }
-
-    public virtual IAsyncEnumerable<TEntry> EntriesAsync => _lazyEntriesAsync;
-    IAsyncEnumerable<IArchiveEntry> IAsyncArchive.EntriesAsync =>
-        EntriesAsync.Cast<TEntry, IArchiveEntry>();
-
-    public IAsyncEnumerable<IVolume> VolumesAsync => _lazyVolumesAsync.Cast<TVolume, IVolume>();
-
-    public async ValueTask<IAsyncReader> ExtractAllEntriesAsync()
-    {
-        if (!IsSolid && Type != ArchiveType.SevenZip)
-        {
-            throw new SharpCompressException(
-                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
-            );
-        }
-        await EnsureEntriesLoadedAsync();
-        return await CreateReaderForSolidExtractionAsync();
-    }
-
-    public virtual ValueTask<bool> IsSolidAsync() => new(false);
-
-    public async ValueTask<bool> IsCompleteAsync()
-    {
-        await EnsureEntriesLoadedAsync();
-        return await EntriesAsync.All(x => x.IsComplete);
-    }
-
-    public async ValueTask<long> TotalSizeAsync() =>
-        await EntriesAsync.Aggregate(0L, (total, cf) => total + cf.CompressedSize);
-
-    public async ValueTask<long> TotalUncompressSizeAsync() =>
-        await EntriesAsync.Aggregate(0L, (total, cf) => total + cf.Size);
-
-    #endregion
 }

src/SharpCompress/Archives/AbstractWritableArchive.Async.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Writers;
+
+namespace SharpCompress.Archives;
+
+public abstract partial class AbstractWritableArchive<TEntry, TVolume>
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
+{
+    // Async property moved from main file
+    private IAsyncEnumerable<TEntry> OldEntriesAsync =>
+        base.EntriesAsync.Where(x => !removedEntries.Contains(x));
+
+    private async ValueTask RebuildModifiedCollectionAsync()
+    {
+        if (pauseRebuilding)
+        {
+            return;
+        }
+        hasModifications = true;
+        newEntries.RemoveAll(v => removedEntries.Contains(v));
+        modifiedEntries.Clear();
+        await foreach (var entry in OldEntriesAsync)
+        {
+            modifiedEntries.Add(entry);
+        }
+        modifiedEntries.AddRange(newEntries);
+    }
+
+    public async ValueTask RemoveEntryAsync(TEntry entry)
+    {
+        if (!removedEntries.Contains(entry))
+        {
+            removedEntries.Add(entry);
+            await RebuildModifiedCollectionAsync();
+        }
+    }
+
+    private async ValueTask<bool> DoesKeyMatchExistingAsync(
+        string key,
+        CancellationToken cancellationToken
+    )
+    {
+        await foreach (
+            var entry in EntriesAsync.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            var path = entry.Key;
+            if (path is null)
+            {
+                continue;
+            }
+            var p = path.Replace('/', '\\');
+            if (p.Length > 0 && p[0] == '\\')
+            {
+                p = p.Substring(1);
+            }
+            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+        }
+        return false;
+    }
+
+    public async ValueTask<TEntry> AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateEntry(key, source, size, modified, closeStream);
+        newEntries.Add(entry);
+        await RebuildModifiedCollectionAsync();
+        return entry;
+    }
+
+    public async ValueTask<TEntry> AddDirectoryEntryAsync(
+        string key,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateDirectoryEntry(key, modified);
+        newEntries.Add(entry);
+        await RebuildModifiedCollectionAsync();
+        return entry;
+    }
+
+    public async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        //reset streams of new entries
+        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+        await SaveToAsync(stream, options, OldEntriesAsync, newEntries, cancellationToken)
+            .ConfigureAwait(false);
+    }
+}

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -10,9 +10,10 @@ using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public abstract class AbstractWritableArchive<TEntry, TVolume>
+public abstract partial class AbstractWritableArchive<TEntry, TVolume>
     : AbstractArchive<TEntry, TVolume>,
-        IWritableArchive
+        IWritableArchive,
+        IWritableAsyncArchive
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -139,6 +140,24 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return false;
     }
 
+    ValueTask IWritableAsyncArchive.RemoveEntryAsync(IArchiveEntry entry) =>
+        RemoveEntryAsync((TEntry)entry);
+
+    async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size,
+        DateTime? modified,
+        CancellationToken cancellationToken
+    ) => await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken);
+
+    async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddDirectoryEntryAsync(
+        string key,
+        DateTime? modified,
+        CancellationToken cancellationToken
+    ) => await AddDirectoryEntryAsync(key, modified, cancellationToken);
+
     public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
     {
         if (key.Length > 0 && key[0] is '/' or '\\')
@@ -162,18 +181,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         SaveTo(stream, options, OldEntries, newEntries);
     }
 
-    public async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        //reset streams of new entries
-        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        await SaveToAsync(stream, options, OldEntries, newEntries, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     protected TEntry CreateEntry(
         string key,
         Stream source,
@@ -211,7 +218,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
     protected abstract ValueTask SaveToAsync(
         Stream stream,
         WriterOptions options,
-        IEnumerable<TEntry> oldEntries,
+        IAsyncEnumerable<TEntry> oldEntries,
         IEnumerable<TEntry> newEntries,
         CancellationToken cancellationToken = default
     );

src/SharpCompress/Archives/ArchiveFactory.Async.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Factories;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+public static partial class ArchiveFactory
+{
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        readerOptions ??= new ReaderOptions();
+        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken);
+        return factory.OpenAsyncArchive(stream, readerOptions);
+    }
+
+    public static ValueTask<IAsyncArchive> OpenAsyncArchive(
+        string filePath,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenAsyncArchive(new FileInfo(filePath), options, cancellationToken);
+    }
+
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken);
+        return factory.OpenAsyncArchive(fileInfo, options);
+    }
+
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var filesArray = fileInfos.ToArray();
+        if (filesArray.Length == 0)
+        {
+            throw new InvalidOperationException("No files to open");
+        }
+
+        var fileInfo = filesArray[0];
+        if (filesArray.Length == 1)
+        {
+            return await OpenAsyncArchive(fileInfo, options, cancellationToken);
+        }
+
+        fileInfo.NotNull(nameof(fileInfo));
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken);
+        return factory.OpenAsyncArchive(filesArray, options, cancellationToken);
+    }
+
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        streams.NotNull(nameof(streams));
+        var streamsArray = streams.ToArray();
+        if (streamsArray.Length == 0)
+        {
+            throw new InvalidOperationException("No streams");
+        }
+
+        var firstStream = streamsArray[0];
+        if (streamsArray.Length == 1)
+        {
+            return await OpenAsyncArchive(firstStream, options, cancellationToken);
+        }
+
+        firstStream.NotNull(nameof(firstStream));
+        options ??= new ReaderOptions();
+
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken);
+        return factory.OpenAsyncArchive(streamsArray, options);
+    }
+
+    public static ValueTask<T> FindFactoryAsync<T>(
+        string path,
+        CancellationToken cancellationToken = default
+    )
+        where T : IFactory
+    {
+        path.NotNullOrEmpty(nameof(path));
+        return FindFactoryAsync<T>(new FileInfo(path), cancellationToken);
+    }
+
+    private static async ValueTask<T> FindFactoryAsync<T>(
+        FileInfo finfo,
+        CancellationToken cancellationToken
+    )
+        where T : IFactory
+    {
+        finfo.NotNull(nameof(finfo));
+        using Stream stream = finfo.OpenRead();
+        return await FindFactoryAsync<T>(stream, cancellationToken);
+    }
+
+    private static async ValueTask<T> FindFactoryAsync<T>(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+        where T : IFactory
+    {
+        stream.NotNull(nameof(stream));
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var factories = Factory.Factories.OfType<T>();
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in factories)
+        {
+            stream.Seek(startPosition, SeekOrigin.Begin);
+
+            if (await factory.IsArchiveAsync(stream, cancellationToken: cancellationToken))
+            {
+                stream.Seek(startPosition, SeekOrigin.Begin);
+
+                return factory;
+            }
+        }
+
+        var extensions = string.Join(", ", factories.Select(item => item.Name));
+
+        throw new InvalidOperationException(
+            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
+        );
+    }
+}

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -11,44 +11,15 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public static class ArchiveFactory
+public static partial class ArchiveFactory
 {
-    /// <summary>
-    /// Opens an Archive for random access
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <returns></returns>
-    public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
-        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
+        return FindFactory<IArchiveFactory>(stream).OpenArchive(stream, readerOptions);
     }
 
-    /// <summary>
-    /// Opens an Archive for random access asynchronously
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    /// <returns></returns>
-    public static async ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
-        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken)
-            .ConfigureAwait(false);
-        return await factory
-            .OpenAsync(stream, readerOptions, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    public static IWritableArchive Create(ArchiveType type)
+    public static IWritableArchive CreateArchive(ArchiveType type)
     {
         var factory = Factory
             .Factories.OfType<IWriteableArchiveFactory>()
@@ -56,106 +27,28 @@ public static class ArchiveFactory
 
         if (factory != null)
         {
-            return factory.CreateWriteableArchive();
+            return factory.CreateArchive();
         }
 
         throw new NotSupportedException("Cannot create Archives of type: " + type);
     }
 
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(string filePath, ReaderOptions? options = null)
+    public static IArchive OpenArchive(string filePath, ReaderOptions? options = null)
     {
         filePath.NotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), options);
+        return OpenArchive(new FileInfo(filePath), options);
     }
 
-    /// <summary>
-    /// Opens an Archive from a filepath asynchronously.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="options"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        string filePath,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenAsync(new FileInfo(filePath), options, cancellationToken);
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+    public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
     {
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-        return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
+        return FindFactory<IArchiveFactory>(fileInfo).OpenArchive(fileInfo, options);
     }
 
-    /// <summary>
-    /// Opens an Archive from a FileInfo object asynchronously.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="options"></param>
-    /// <param name="cancellationToken"></param>
-    public static async ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken)
-            .ConfigureAwait(false);
-        return await factory.OpenAsync(fileInfo, options, cancellationToken).ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Constructor with IEnumerable FileInfo objects, multi and split support.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var filesArray = fileInfos.ToArray();
-        if (filesArray.Length == 0)
-        {
-            throw new InvalidOperationException("No files to open");
-        }
-
-        var fileInfo = filesArray[0];
-        if (filesArray.Length == 1)
-        {
-            return Open(fileInfo, options);
-        }
-
-        fileInfo.NotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
-    }
-
-    /// <summary>
-    /// Opens a multi-part archive from files asynchronously.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="options"></param>
-    /// <param name="cancellationToken"></param>
-    public static async ValueTask<IAsyncArchive> OpenAsync(
+    public static IArchive OpenArchive(
         IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? options = null
     )
     {
         fileInfos.NotNull(nameof(fileInfos));
@@ -168,24 +61,16 @@ public static class ArchiveFactory
         var fileInfo = filesArray[0];
         if (filesArray.Length == 1)
         {
-            return await OpenAsync(fileInfo, options, cancellationToken).ConfigureAwait(false);
+            return OpenArchive(fileInfo, options);
         }
 
         fileInfo.NotNull(nameof(fileInfo));
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-        var factory = FindFactory<IMultiArchiveFactory>(fileInfo);
-        return await factory
-            .OpenAsync(filesArray, options, cancellationToken)
-            .ConfigureAwait(false);
+        return FindFactory<IMultiArchiveFactory>(fileInfo).OpenArchive(filesArray, options);
     }
 
-    /// <summary>
-    /// Constructor with IEnumerable FileInfo objects, multi and split support.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
+    public static IArchive OpenArchive(IEnumerable<Stream> streams, ReaderOptions? options = null)
     {
         streams.NotNull(nameof(streams));
         var streamsArray = streams.ToArray();
@@ -197,64 +82,34 @@ public static class ArchiveFactory
         var firstStream = streamsArray[0];
         if (streamsArray.Length == 1)
         {
-            return Open(firstStream, options);
+            return OpenArchive(firstStream, options);
         }
 
         firstStream.NotNull(nameof(firstStream));
         options ??= new ReaderOptions();
 
-        return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
+        return FindFactory<IMultiArchiveFactory>(firstStream).OpenArchive(streamsArray, options);
     }
 
-    /// <summary>
-    /// Opens a multi-part archive from streams asynchronously.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="options"></param>
-    /// <param name="cancellationToken"></param>
-    public static async ValueTask<IAsyncArchive> OpenAsync(
-        IEnumerable<Stream> streams,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        streams.NotNull(nameof(streams));
-        var streamsArray = streams.ToArray();
-        if (streamsArray.Length == 0)
-        {
-            throw new InvalidOperationException("No streams");
-        }
-
-        var firstStream = streamsArray[0];
-        if (streamsArray.Length == 1)
-        {
-            return await OpenAsync(firstStream, options, cancellationToken).ConfigureAwait(false);
-        }
-
-        firstStream.NotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
-
-        var factory = FindFactory<IMultiArchiveFactory>(firstStream);
-        return await factory
-            .OpenAsync(streamsArray, options, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    /// <summary>
-    /// Extract to specific directory, retaining filename
-    /// </summary>
     public static void WriteToDirectory(
         string sourceArchive,
         string destinationDirectory,
         ExtractionOptions? options = null
     )
     {
-        using var archive = Open(sourceArchive);
+        using var archive = OpenArchive(sourceArchive);
         archive.WriteToDirectory(destinationDirectory, options);
     }
 
-    private static T FindFactory<T>(FileInfo finfo)
+    public static T FindFactory<T>(string path)
+        where T : IFactory
+    {
+        path.NotNullOrEmpty(nameof(path));
+        using Stream stream = File.OpenRead(path);
+        return FindFactory<T>(stream);
+    }
+
+    public static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
         finfo.NotNull(nameof(finfo));
@@ -262,7 +117,7 @@ public static class ArchiveFactory
         return FindFactory<T>(stream);
     }
 
-    private static T FindFactory<T>(Stream stream)
+    public static T FindFactory<T>(Stream stream)
         where T : IFactory
     {
         stream.NotNull(nameof(stream));
@@ -294,68 +149,14 @@ public static class ArchiveFactory
         );
     }
 
-    private static async ValueTask<T> FindFactoryAsync<T>(
-        FileInfo finfo,
-        CancellationToken cancellationToken
-    )
-        where T : IFactory
-    {
-        finfo.NotNull(nameof(finfo));
-        using Stream stream = finfo.OpenRead();
-        return await FindFactoryAsync<T>(stream, cancellationToken);
-    }
-
-    private static async ValueTask<T> FindFactoryAsync<T>(
-        Stream stream,
-        CancellationToken cancellationToken
-    )
-        where T : IFactory
-    {
-        stream.NotNull(nameof(stream));
-        if (!stream.CanRead || !stream.CanSeek)
-        {
-            throw new ArgumentException("Stream should be readable and seekable");
-        }
-
-        var factories = Factory.Factories.OfType<T>();
-
-        var startPosition = stream.Position;
-
-        foreach (var factory in factories)
-        {
-            stream.Seek(startPosition, SeekOrigin.Begin);
-
-            if (await factory.IsArchiveAsync(stream, cancellationToken: cancellationToken))
-            {
-                stream.Seek(startPosition, SeekOrigin.Begin);
-
-                return factory;
-            }
-        }
-
-        var extensions = string.Join(", ", factories.Select(item => item.Name));
-
-        throw new InvalidOperationException(
-            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
-        );
-    }
-
-    public static bool IsArchive(
-        string filePath,
-        out ArchiveType? type,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
+    public static bool IsArchive(string filePath, out ArchiveType? type)
     {
         filePath.NotNullOrEmpty(nameof(filePath));
         using Stream s = File.OpenRead(filePath);
-        return IsArchive(s, out type, bufferSize);
+        return IsArchive(s, out type);
     }
 
-    public static bool IsArchive(
-        Stream stream,
-        out ArchiveType? type,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
+    public static bool IsArchive(Stream stream, out ArchiveType? type)
     {
         type = null;
         stream.NotNull(nameof(stream));
@@ -382,22 +183,12 @@ public static class ArchiveFactory
         return false;
     }
 
-    /// <summary>
-    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
-    /// </summary>
-    /// <param name="part1"></param>
-    /// <returns></returns>
     public static IEnumerable<string> GetFileParts(string part1)
     {
         part1.NotNullOrEmpty(nameof(part1));
         return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
     }
 
-    /// <summary>
-    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
-    /// </summary>
-    /// <param name="part1"></param>
-    /// <returns></returns>
     public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
     {
         part1.NotNull(nameof(part1));
@@ -411,7 +202,7 @@ public static class ArchiveFactory
             if (part != null)
             {
                 yield return part;
-                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
+                while ((part = factory.GetFilePart(i++, part1)) != null)
                 {
                     yield return part;
                 }
@@ -420,6 +211,4 @@ public static class ArchiveFactory
             }
         }
     }
-
-    public static IArchiveFactory AutoFactory { get; } = new AutoArchiveFactory();
 }

src/SharpCompress/Archives/ArchiveVolumeFactory.cs

@@ -13,6 +13,7 @@ internal abstract class ArchiveVolumeFactory
         //split 001, 002 ...
         var m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
         if (m.Success)
+        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -22,9 +23,13 @@ internal abstract class ArchiveVolumeFactory
                     )
                 )
             );
+        }
 
         if (item != null && item.Exists)
+        {
             return item;
+        }
+
         return null;
     }
 }

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-internal class AutoArchiveFactory : IArchiveFactory
-{
-    public string Name => nameof(AutoArchiveFactory);
-
-    public ArchiveType? KnownArchiveType => null;
-
-    public IEnumerable<string> GetSupportedExtensions() => throw new NotSupportedException();
-
-    public bool IsArchive(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    ) => throw new NotSupportedException();
-
-    public ValueTask<bool> IsArchiveAsync(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
-        CancellationToken cancellationToken = default
-    ) => throw new NotSupportedException();
-
-    public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
-
-    public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
-        ArchiveFactory.Open(stream, readerOptions);
-
-    public async ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    ) => await ArchiveFactory.OpenAsync(stream, readerOptions, cancellationToken);
-
-    public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
-        ArchiveFactory.Open(fileInfo, readerOptions);
-
-    public async ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    ) => await ArchiveFactory.OpenAsync(fileInfo, readerOptions, cancellationToken);
-}

src/SharpCompress/Archives/GZip/GZipArchive.Async.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.GZip;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.GZip;
+using SharpCompress.Writers;
+using SharpCompress.Writers.GZip;
+
+namespace SharpCompress.Archives.GZip;
+
+public partial class GZipArchive
+{
+    public ValueTask SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
+        SaveToAsync(new FileInfo(filePath), cancellationToken);
+
+    public async ValueTask SaveToAsync(
+        FileInfo fileInfo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    protected override async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IAsyncEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (Entries.Count > 1)
+        {
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
+        }
+        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        await foreach (
+            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            if (!entry.IsDirectory)
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+        foreach (var entry in newEntries.Where(x => !x.IsDirectory))
+        {
+            using var entryStream = entry.OpenEntryStream();
+            await writer
+                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
+    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return new((IAsyncReader)GZipReader.OpenReader(stream));
+    }
+
+    protected override async IAsyncEnumerable<GZipArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<GZipVolume> volumes
+    )
+    {
+        var stream = (await volumes.SingleAsync()).Stream;
+        yield return new GZipArchiveEntry(
+            this,
+            await GZipFilePart.CreateAsync(stream, ReaderOptions.ArchiveEncoding)
+        );
+    }
+}

src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs

@@ -0,0 +1,201 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.GZip;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.GZip;
+using SharpCompress.Writers;
+using SharpCompress.Writers.GZip;
+
+namespace SharpCompress.Archives.GZip;
+
+public partial class GZipArchive
+#if NET8_0_OR_GREATER
+    : IWritableArchiveOpenable,
+        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
+#endif
+{
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        string path,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        path.NotNullOrEmpty(nameof(path));
+        return (IWritableAsyncArchive)OpenArchive(
+            new FileInfo(path),
+            readerOptions ?? new ReaderOptions()
+        );
+    }
+
+    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    public static IWritableArchive OpenArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new GZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new GZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new GZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new GZipArchive(
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
+    }
+
+    public static IWritableArchive CreateArchive() => new GZipArchive();
+
+    public static IWritableAsyncArchive CreateAsyncArchive() => new GZipArchive();
+
+    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
+
+    public static bool IsGZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+
+        using Stream stream = fileInfo.OpenRead();
+        return IsGZipFile(stream);
+    }
+
+    public static bool IsGZipFile(Stream stream)
+    {
+        Span<byte> header = stackalloc byte[10];
+
+        if (!stream.ReadFully(header))
+        {
+            return false;
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static async ValueTask<bool> IsGZipFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var header = ArrayPool<byte>.Shared.Rent(10);
+        try
+        {
+            await stream.ReadFullyAsync(header, 0, 10, cancellationToken).ConfigureAwait(false);
+
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            {
+                return false;
+            }
+
+            return true;
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(header);
+        }
+    }
+}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -14,186 +14,20 @@ using SharpCompress.Writers.GZip;
 
 namespace SharpCompress.Archives.GZip;
 
-public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
 {
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new GZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new GZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new GZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new GZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(stream, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfo, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(streams, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a GZipArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfos, readerOptions));
-    }
-
-    public static GZipArchive Create() => new();
-
-    /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
-    /// </summary>
-    /// <param name="sourceStream"></param>
     private GZipArchive(SourceStream sourceStream)
         : base(ArchiveType.GZip, sourceStream) { }
 
+    internal GZipArchive()
+        : base(ArchiveType.GZip) { }
+
     protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream sourceStream)
     {
         sourceStream.LoadAllParts();
         return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0));
     }
 
-    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
-
-    public static bool IsGZipFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-
-        using Stream stream = fileInfo.OpenRead();
-        return IsGZipFile(stream);
-    }
-
     public void SaveTo(string filePath) => SaveTo(new FileInfo(filePath));
 
     public void SaveTo(FileInfo fileInfo)
@@ -202,63 +36,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         SaveTo(stream, new WriterOptions(CompressionType.GZip));
     }
 
-    public ValueTask SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
-        SaveToAsync(new FileInfo(filePath), cancellationToken);
-
-    public async ValueTask SaveToAsync(
-        FileInfo fileInfo,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
-            .ConfigureAwait(false);
-    }
-
-    public static bool IsGZipFile(Stream stream)
-    {
-        // read the header on the first read
-        Span<byte> header = stackalloc byte[10];
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (!stream.ReadFully(header))
-        {
-            return false;
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
-    public static async ValueTask<bool> IsGZipFileAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        // read the header on the first read
-        byte[] header = new byte[10];
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (!await stream.ReadFullyAsync(header, cancellationToken).ConfigureAwait(false))
-        {
-            return false;
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
-    internal GZipArchive()
-        : base(ArchiveType.GZip) { }
-
     protected override GZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -302,34 +79,12 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         }
     }
 
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<GZipArchiveEntry> oldEntries,
-        IEnumerable<GZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (Entries.Count > 1)
-        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-        }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
-        {
-            using var entryStream = entry.OpenEntryStream();
-            await writer
-                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-
     protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
     {
         var stream = volumes.Single().Stream;
         yield return new GZipArchiveEntry(
             this,
-            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
+            GZipFilePart.Create(stream, ReaderOptions.ArchiveEncoding)
         );
     }
 
@@ -337,13 +92,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return GZipReader.Open(stream);
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new(GZipReader.Open(stream));
+        return GZipReader.OpenReader(stream);
     }
 }

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -23,12 +23,10 @@ public class GZipArchiveEntry : GZipEntry, IArchiveEntry
         return Parts.Single().GetCompressedStream().NotNull();
     }
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
+    public ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
     {
         // GZip synchronous implementation is fast enough, just wrap it
-        return OpenEntryStream();
+        return new(OpenEntryStream());
     }
 
     #region IArchiveEntry Members

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -58,7 +58,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Archives/IArchive.cs

@@ -38,5 +38,10 @@ public interface IArchive : IDisposable
     /// <summary>
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
-    long TotalUncompressSize { get; }
+    long TotalUncompressedSize { get; }
+
+    /// <summary>
+    /// Returns whether the archive is encrypted.
+    /// </summary>
+    bool IsEncrypted { get; }
 }

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -9,8 +9,6 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveEntryExtensions
 {
-    private const int BufferSize = 81920;
-
     /// <param name="archiveEntry">The archive entry to extract.</param>
     extension(IArchiveEntry archiveEntry)
     {
@@ -28,7 +26,7 @@ public static class IArchiveEntryExtensions
 
             using var entryStream = archiveEntry.OpenEntryStream();
             var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
-            sourceStream.CopyTo(streamToWriteTo, BufferSize);
+            sourceStream.CopyTo(streamToWriteTo, Constants.BufferSize);
         }
 
         /// <summary>
@@ -48,10 +46,16 @@ public static class IArchiveEntryExtensions
                 throw new ExtractionException("Entry is a file directory and cannot be extracted.");
             }
 
+#if LEGACY_DOTNET
             using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
+#else
+            await using var entryStream = await archiveEntry.OpenEntryStreamAsync(
+                cancellationToken
+            );
+#endif
             var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
             await sourceStream
-                .CopyToAsync(streamToWriteTo, BufferSize, cancellationToken)
+                .CopyToAsync(streamToWriteTo, Constants.BufferSize, cancellationToken)
                 .ConfigureAwait(false);
         }
     }

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -8,7 +8,6 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveExtensions
 {
-    /// <param name="archive">The archive to extract.</param>
     extension(IArchive archive)
     {
         /// <summary>
@@ -23,7 +22,6 @@ public static class IArchiveExtensions
             IProgress<ProgressReport>? progress = null
         )
         {
-            // For solid archives (Rar, 7Zip), use the optimized reader-based approach
             if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
             {
                 using var reader = archive.ExtractAllEntries();
@@ -31,7 +29,6 @@ public static class IArchiveExtensions
             }
             else
             {
-                // For non-solid archives, extract entries directly
                 archive.WriteToDirectoryInternal(destinationDirectory, options, progress);
             }
         }
@@ -42,14 +39,10 @@ public static class IArchiveExtensions
             IProgress<ProgressReport>? progress
         )
         {
-            // Prepare for progress reporting
-            var totalBytes = archive.TotalUncompressSize;
+            var totalBytes = archive.TotalUncompressedSize;
             var bytesRead = 0L;
-
-            // Tracking for created directories.
             var seenDirectories = new HashSet<string>();
 
-            // Extract
             foreach (var entry in archive.Entries)
             {
                 if (entry.IsDirectory)
@@ -68,10 +61,8 @@ public static class IArchiveExtensions
                     continue;
                 }
 
-                // Use the entry's WriteToDirectory method which respects ExtractionOptions
                 entry.WriteToDirectory(destinationDirectory, options);
 
-                // Update progress
                 bytesRead += entry.Size;
                 progress?.Report(
                     new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -1,6 +1,5 @@
 using System.IO;
 using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -26,26 +25,21 @@ public interface IArchiveFactory : IFactory
     /// </summary>
     /// <param name="stream">An open, readable and seekable stream.</param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
+    IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Opens an Archive for random access asynchronously.
     /// </summary>
     /// <param name="stream">An open, readable and seekable stream.</param>
     /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
+    IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
     /// <param name="fileInfo">the file to open.</param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
+    IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Opens an Archive from a FileInfo object asynchronously.
@@ -53,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>
-    ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
+    IAsyncArchive OpenAsyncArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null);
 }

src/SharpCompress/Archives/IArchiveOpenable.cs

@@ -0,0 +1,40 @@
+#if NET8_0_OR_GREATER
+using System.IO;
+using System.Threading;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+public interface IArchiveOpenable<TSync, TASync>
+    where TSync : IArchive
+    where TASync : IAsyncArchive
+{
+    public static abstract TSync OpenArchive(string filePath, ReaderOptions? readerOptions = null);
+
+    public static abstract TSync OpenArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null
+    );
+
+    public static abstract TSync OpenArchive(Stream stream, ReaderOptions? readerOptions = null);
+
+    public static abstract TASync OpenAsyncArchive(
+        string path,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
+    public static abstract TASync OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
+    public static abstract TASync OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+}
+
+#endif

src/SharpCompress/Archives/IAsyncArchive.cs

@@ -39,5 +39,10 @@ public interface IAsyncArchive : IAsyncDisposable
     /// <summary>
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
-    ValueTask<long> TotalUncompressSizeAsync();
+    ValueTask<long> TotalUncompressedSizeAsync();
+
+    /// <summary>
+    /// Returns whether the archive is encrypted.
+    /// </summary>
+    ValueTask<bool> IsEncryptedAsync();
 }

src/SharpCompress/Archives/IAsyncArchiveExtensions.cs

@@ -10,84 +10,83 @@ namespace SharpCompress.Archives;
 
 public static class IAsyncArchiveExtensions
 {
-    /// <summary>
-    /// Extract to specific directory asynchronously with progress reporting and cancellation support
-    /// </summary>
-    /// <param name="archive">The archive to extract.</param>
-    /// <param name="destinationDirectory">The folder to extract into.</param>
-    /// <param name="options">Extraction options.</param>
-    /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-    /// <param name="cancellationToken">Optional cancellation token.</param>
-    public static async Task WriteToDirectoryAsync(
-        this IAsyncArchive archive,
-        string destinationDirectory,
-        ExtractionOptions? options = null,
-        IProgress<ProgressReport>? progress = null,
-        CancellationToken cancellationToken = default
-    )
+    extension(IAsyncArchive archive)
     {
-        // For solid archives (Rar, 7Zip), use the optimized reader-based approach
-        if (await archive.IsSolidAsync() || archive.Type == ArchiveType.SevenZip)
+        /// <summary>
+        /// Extract to specific directory asynchronously with progress reporting and cancellation support
+        /// </summary>
+        /// <param name="archive">The archive to extract.</param>
+        /// <param name="destinationDirectory">The folder to extract into.</param>
+        /// <param name="options">Extraction options.</param>
+        /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
+        /// <param name="cancellationToken">Optional cancellation token.</param>
+        public async ValueTask WriteToDirectoryAsync(
+            string destinationDirectory,
+            ExtractionOptions? options = null,
+            IProgress<ProgressReport>? progress = null,
+            CancellationToken cancellationToken = default
+        )
         {
-            await using var reader = await archive.ExtractAllEntriesAsync();
-            await reader.WriteAllToDirectoryAsync(destinationDirectory, options, cancellationToken);
-        }
-        else
-        {
-            // For non-solid archives, extract entries directly
-            await archive.WriteToDirectoryAsyncInternal(
-                destinationDirectory,
-                options,
-                progress,
-                cancellationToken
-            );
-        }
-    }
-
-    private static async Task WriteToDirectoryAsyncInternal(
-        this IAsyncArchive archive,
-        string destinationDirectory,
-        ExtractionOptions? options,
-        IProgress<ProgressReport>? progress,
-        CancellationToken cancellationToken
-    )
-    {
-        // Prepare for progress reporting
-        var totalBytes = await archive.TotalUncompressSizeAsync();
-        var bytesRead = 0L;
-
-        // Tracking for created directories.
-        var seenDirectories = new HashSet<string>();
-
-        // Extract
-        await foreach (var entry in archive.EntriesAsync.WithCancellation(cancellationToken))
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            if (entry.IsDirectory)
+            if (await archive.IsSolidAsync() || archive.Type == ArchiveType.SevenZip)
             {
-                var dirPath = Path.Combine(
+                await using var reader = await archive.ExtractAllEntriesAsync();
+                await reader.WriteAllToDirectoryAsync(
                     destinationDirectory,
-                    entry.Key.NotNull("Entry Key is null")
+                    options,
+                    cancellationToken
                 );
-                if (
-                    Path.GetDirectoryName(dirPath + "/") is { } parentDirectory
-                    && seenDirectories.Add(dirPath)
-                )
-                {
-                    Directory.CreateDirectory(parentDirectory);
-                }
-                continue;
             }
+            else
+            {
+                await archive.WriteToDirectoryAsyncInternal(
+                    destinationDirectory,
+                    options,
+                    progress,
+                    cancellationToken
+                );
+            }
+        }
 
-            // Use the entry's WriteToDirectoryAsync method which respects ExtractionOptions
-            await entry
-                .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken)
-                .ConfigureAwait(false);
+        private async ValueTask WriteToDirectoryAsyncInternal(
+            string destinationDirectory,
+            ExtractionOptions? options,
+            IProgress<ProgressReport>? progress,
+            CancellationToken cancellationToken
+        )
+        {
+            var totalBytes = await archive.TotalUncompressedSizeAsync();
+            var bytesRead = 0L;
+            var seenDirectories = new HashSet<string>();
 
-            // Update progress
-            bytesRead += entry.Size;
-            progress?.Report(new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes));
+            await foreach (var entry in archive.EntriesAsync.WithCancellation(cancellationToken))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                if (entry.IsDirectory)
+                {
+                    var dirPath = Path.Combine(
+                        destinationDirectory,
+                        entry.Key.NotNull("Entry Key is null")
+                    );
+                    if (
+                        Path.GetDirectoryName(dirPath + "/") is { } parentDirectory
+                        && seenDirectories.Add(dirPath)
+                    )
+                    {
+                        Directory.CreateDirectory(parentDirectory);
+                    }
+                    continue;
+                }
+
+                await entry
+                    .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken)
+                    .ConfigureAwait(false);
+
+                bytesRead += entry.Size;
+                progress?.Report(
+                    new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)
+                );
+            }
         }
     }
 }

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -27,18 +26,16 @@ public interface IMultiArchiveFactory : IFactory
     /// </summary>
     /// <param name="streams"></param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
+    IArchive OpenArchive(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Opens a multi-part archive from streams asynchronously.
     /// </summary>
     /// <param name="streams"></param>
     /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    ValueTask<IAsyncArchive> OpenAsync(
+    IAsyncArchive OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     );
 
     /// <summary>
@@ -46,7 +43,7 @@ public interface IMultiArchiveFactory : IFactory
     /// </summary>
     /// <param name="fileInfos"></param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
+    IArchive OpenArchive(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Opens a multi-part archive from files asynchronously.
@@ -54,7 +51,7 @@ public interface IMultiArchiveFactory : IFactory
     /// <param name="fileInfos"></param>
     /// <param name="readerOptions">reading options.</param>
     /// <param name="cancellationToken">Cancellation token.</param>
-    ValueTask<IAsyncArchive> OpenAsync(
+    IAsyncArchive OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
         ReaderOptions? readerOptions = null,
         CancellationToken cancellationToken = default

src/SharpCompress/Archives/IMultiArchiveOpenable.cs

@@ -0,0 +1,35 @@
+#if NET8_0_OR_GREATER
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+public interface IMultiArchiveOpenable<TSync, TASync>
+    where TSync : IArchive
+    where TASync : IAsyncArchive
+{
+    public static abstract TSync OpenArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    );
+
+    public static abstract TSync OpenArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    );
+
+    public static abstract TASync OpenAsyncArchive(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
+    public static abstract TASync OpenAsyncArchive(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+}
+#endif

src/SharpCompress/Archives/IWritableArchive.cs

@@ -6,10 +6,17 @@ using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public interface IWritableArchive : IArchive
+public interface IWritableArchiveCommon
 {
-    void RemoveEntry(IArchiveEntry entry);
+    /// <summary>
+    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
+    /// </summary>
+    /// <returns>IDisposeable to resume entry rebuilding</returns>
+    IDisposable PauseEntryRebuilding();
+}
 
+public interface IWritableArchive : IArchive, IWritableArchiveCommon
+{
     IArchiveEntry AddEntry(
         string key,
         Stream source,
@@ -20,8 +27,22 @@ public interface IWritableArchive : IArchive
 
     IArchiveEntry AddDirectoryEntry(string key, DateTime? modified = null);
 
+    /// <summary>
+    /// Saves the archive to the specified stream using the given writer options.
+    /// </summary>
     void SaveTo(Stream stream, WriterOptions options);
 
+    /// <summary>
+    /// Removes the specified entry from the archive.
+    /// </summary>
+    void RemoveEntry(IArchiveEntry entry);
+}
+
+public interface IWritableAsyncArchive : IAsyncArchive, IWritableArchiveCommon
+{
+    /// <summary>
+    /// Asynchronously saves the archive to the specified stream using the given writer options.
+    /// </summary>
     ValueTask SaveToAsync(
         Stream stream,
         WriterOptions options,
@@ -29,8 +50,28 @@ public interface IWritableArchive : IArchive
     );
 
     /// <summary>
-    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
+    /// Asynchronously adds an entry to the archive with the specified key, source stream, and options.
     /// </summary>
-    /// <returns>IDisposeable to resume entry rebuilding</returns>
-    IDisposable PauseEntryRebuilding();
+    ValueTask<IArchiveEntry> AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    );
+
+    /// <summary>
+    /// Asynchronously adds a directory entry to the archive with the specified key and modification time.
+    /// </summary>
+    ValueTask<IArchiveEntry> AddDirectoryEntryAsync(
+        string key,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    );
+
+    /// <summary>
+    /// Removes the specified entry from the archive.
+    /// </summary>
+    ValueTask RemoveEntryAsync(IArchiveEntry entry);
 }

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,106 +1,70 @@
-using System;
+using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
+using SharpCompress.Common;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
 public static class IWritableArchiveExtensions
 {
-    public static void AddEntry(
-        this IWritableArchive writableArchive,
-        string entryPath,
-        string filePath
-    )
+    extension(IWritableArchive writableArchive)
     {
-        var fileInfo = new FileInfo(filePath);
-        if (!fileInfo.Exists)
+        public void AddAllFromDirectory(
+            string filePath,
+            string searchPattern = "*.*",
+            SearchOption searchOption = SearchOption.AllDirectories
+        )
         {
-            throw new FileNotFoundException("Could not AddEntry: " + filePath);
-        }
-        writableArchive.AddEntry(
-            entryPath,
-            new FileInfo(filePath).OpenRead(),
-            true,
-            fileInfo.Length,
-            fileInfo.LastWriteTime
-        );
-    }
-
-    public static void SaveTo(
-        this IWritableArchive writableArchive,
-        string filePath,
-        WriterOptions options
-    ) => writableArchive.SaveTo(new FileInfo(filePath), options);
-
-    public static void SaveTo(
-        this IWritableArchive writableArchive,
-        FileInfo fileInfo,
-        WriterOptions options
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        writableArchive.SaveTo(stream, options);
-    }
-
-    public static ValueTask SaveToAsync(
-        this IWritableArchive writableArchive,
-        string filePath,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    ) => writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
-
-    public static async ValueTask SaveToAsync(
-        this IWritableArchive writableArchive,
-        FileInfo fileInfo,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await writableArchive.SaveToAsync(stream, options, cancellationToken).ConfigureAwait(false);
-    }
-
-    public static void AddAllFromDirectory(
-        this IWritableArchive writableArchive,
-        string filePath,
-        string searchPattern = "*.*",
-        SearchOption searchOption = SearchOption.AllDirectories
-    )
-    {
-        using (writableArchive.PauseEntryRebuilding())
-        {
-            foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
+            using (writableArchive.PauseEntryRebuilding())
             {
-                var fileInfo = new FileInfo(path);
-                writableArchive.AddEntry(
-                    path.Substring(filePath.Length),
-                    fileInfo.OpenRead(),
-                    true,
-                    fileInfo.Length,
-                    fileInfo.LastWriteTime
-                );
+                foreach (
+                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
+                )
+                {
+                    var fileInfo = new FileInfo(path);
+                    writableArchive.AddEntry(
+                        path.Substring(filePath.Length),
+                        fileInfo.OpenRead(),
+                        true,
+                        fileInfo.Length,
+                        fileInfo.LastWriteTime
+                    );
+                }
             }
         }
-    }
 
-    public static IArchiveEntry AddEntry(
-        this IWritableArchive writableArchive,
-        string key,
-        FileInfo fileInfo
-    )
-    {
-        if (!fileInfo.Exists)
+        public IArchiveEntry AddEntry(string key, string file) =>
+            writableArchive.AddEntry(key, new FileInfo(file));
+
+        public IArchiveEntry AddEntry(
+            string key,
+            Stream source,
+            long size = 0,
+            DateTime? modified = null
+        ) => writableArchive.AddEntry(key, source, false, size, modified);
+
+        public IArchiveEntry AddEntry(string key, FileInfo fileInfo)
         {
-            throw new ArgumentException("FileInfo does not exist.");
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("FileInfo does not exist.");
+            }
+            return writableArchive.AddEntry(
+                key,
+                fileInfo.OpenRead(),
+                true,
+                fileInfo.Length,
+                fileInfo.LastWriteTime
+            );
+        }
+
+        public void SaveTo(string filePath, WriterOptions? options = null) =>
+            writableArchive.SaveTo(new FileInfo(filePath), options ?? new(CompressionType.Deflate));
+
+        public void SaveTo(FileInfo fileInfo, WriterOptions? options = null)
+        {
+            using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+            writableArchive.SaveTo(stream, options ?? new(CompressionType.Deflate));
         }
-        return writableArchive.AddEntry(
-            key,
-            fileInfo.OpenRead(),
-            true,
-            fileInfo.Length,
-            fileInfo.LastWriteTime
-        );
     }
 }

src/SharpCompress/Archives/IWritableArchiveOpenable.cs

@@ -0,0 +1,10 @@
+#if NET8_0_OR_GREATER
+namespace SharpCompress.Archives;
+
+public interface IWritableArchiveOpenable
+    : IArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
+{
+    public static abstract IWritableArchive CreateArchive();
+    public static abstract IWritableAsyncArchive CreateAsyncArchive();
+}
+#endif

src/SharpCompress/Archives/IWritableAsyncArchiveExtensions.cs

@@ -0,0 +1,86 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Writers;
+
+namespace SharpCompress.Archives;
+
+public static class IWritableAsyncArchiveExtensions
+{
+    extension(IWritableAsyncArchive writableArchive)
+    {
+        public async ValueTask AddAllFromDirectoryAsync(
+            string filePath,
+            string searchPattern = "*.*",
+            SearchOption searchOption = SearchOption.AllDirectories
+        )
+        {
+            using (writableArchive.PauseEntryRebuilding())
+            {
+                foreach (
+                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
+                )
+                {
+                    var fileInfo = new FileInfo(path);
+                    await writableArchive.AddEntryAsync(
+                        path.Substring(filePath.Length),
+                        fileInfo.OpenRead(),
+                        true,
+                        fileInfo.Length,
+                        fileInfo.LastWriteTime
+                    );
+                }
+            }
+        }
+
+        public ValueTask<IArchiveEntry> AddEntryAsync(string key, string file) =>
+            writableArchive.AddEntryAsync(key, new FileInfo(file));
+
+        public ValueTask<IArchiveEntry> AddEntryAsync(
+            string key,
+            Stream source,
+            long size = 0,
+            DateTime? modified = null
+        ) => writableArchive.AddEntryAsync(key, source, false, size, modified);
+
+        public ValueTask<IArchiveEntry> AddEntryAsync(string key, FileInfo fileInfo)
+        {
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("FileInfo does not exist.");
+            }
+            return writableArchive.AddEntryAsync(
+                key,
+                fileInfo.OpenRead(),
+                true,
+                fileInfo.Length,
+                fileInfo.LastWriteTime
+            );
+        }
+
+        public ValueTask SaveToAsync(
+            string filePath,
+            WriterOptions? options = null,
+            CancellationToken cancellationToken = default
+        ) =>
+            writableArchive.SaveToAsync(
+                new FileInfo(filePath),
+                options ?? new(CompressionType.Deflate),
+                cancellationToken
+            );
+
+        public async ValueTask SaveToAsync(
+            FileInfo fileInfo,
+            WriterOptions? options = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+            await writableArchive
+                .SaveToAsync(stream, options ?? new(CompressionType.Deflate), cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+}

src/SharpCompress/Archives/IWriteableArchiveFactory.cs

@@ -16,5 +16,5 @@ public interface IWriteableArchiveFactory : Factories.IFactory
     /// Creates a new, empty archive, ready to be written.
     /// </summary>
     /// <returns></returns>
-    IWritableArchive CreateWriteableArchive();
+    IWritableArchive CreateArchive();
 }

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -36,4 +36,7 @@ internal class FileInfoRarArchiveVolume : RarVolume
         new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => FileParts;
+
+    internal override IAsyncEnumerable<RarFilePart> ReadFilePartsAsync() =>
+        FileParts.ToAsyncEnumerable();
 }

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

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Archives.Rar;
+using SharpCompress.Common;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Rar;
+
+namespace SharpCompress.Archives.Rar;
+
+public partial class RarArchive
+{
+    public override async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
+            {
+                unpackV1.Dispose();
+            }
+
+            _disposed = true;
+            await base.DisposeAsync();
+        }
+    }
+
+    protected override async ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
+    {
+        if (await this.IsMultipartVolumeAsync())
+        {
+            var streams = await VolumesAsync
+                .Select(volume =>
+                {
+                    volume.Stream.Position = 0;
+                    return volume.Stream;
+                })
+                .ToListAsync();
+            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
+        }
+
+        var stream = (await VolumesAsync.FirstAsync()).Stream;
+        stream.Position = 0;
+        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
+    }
+
+    public override async ValueTask<bool> IsSolidAsync() =>
+        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsSolidArchiveAsync();
+}

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

@@ -1,18 +1,36 @@
-using System.Linq;
+using System.Linq;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
 
 namespace SharpCompress.Archives.Rar;
 
 public static class RarArchiveExtensions
 {
-    /// <summary>
-    /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
-    /// </summary>
-    public static bool IsFirstVolume(this RarArchive archive) =>
-        archive.Volumes.First().IsFirstVolume;
+    extension(IRarArchive archive)
+    {
+        /// <summary>
+        /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
+        /// </summary>
+        public bool IsFirstVolume() => archive.Volumes.Cast<RarVolume>().First().IsFirstVolume;
 
-    /// <summary>
-    /// RarArchive is part of a multi-part archive.
-    /// </summary>
-    public static bool IsMultipartVolume(this RarArchive archive) =>
-        archive.Volumes.First().IsMultiVolume;
+        /// <summary>
+        /// RarArchive is part of a multi-part archive.
+        /// </summary>
+        public bool IsMultipartVolume() => archive.Volumes.Cast<RarVolume>().First().IsMultiVolume;
+    }
+
+    extension(IRarAsyncArchive archive)
+    {
+        /// <summary>
+        /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
+        /// </summary>
+        public async ValueTask<bool> IsFirstVolumeAsync() =>
+            (await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsFirstVolume;
+
+        /// <summary>
+        /// RarArchive is part of a multi-part archive.
+        /// </summary>
+        public async ValueTask<bool> IsMultipartVolumeAsync() =>
+            (await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsMultiVolume;
+    }
 }

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

@@ -0,0 +1,187 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Rar;
+using SharpCompress.Common.Rar.Headers;
+using SharpCompress.Compressors.Rar;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Rar;
+
+namespace SharpCompress.Archives.Rar;
+
+public partial class RarArchive
+#if NET8_0_OR_GREATER
+    : IArchiveOpenable<IRarArchive, IRarAsyncArchive>,
+        IMultiArchiveOpenable<IRarArchive, IRarAsyncArchive>
+#endif
+{
+    public static IRarAsyncArchive OpenAsyncArchive(
+        string path,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        path.NotNullOrEmpty(nameof(path));
+        return (IRarAsyncArchive)OpenArchive(new FileInfo(path), readerOptions);
+    }
+
+    public static IRarArchive OpenArchive(string filePath, ReaderOptions? options = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        var fileInfo = new FileInfo(filePath);
+        return new RarArchive(
+            new SourceStream(
+                fileInfo,
+                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                options ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IRarArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new RarArchive(
+            new SourceStream(
+                fileInfo,
+                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                options ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IRarArchive OpenArchive(Stream stream, ReaderOptions? options = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
+    }
+
+    public static IRarArchive OpenArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new RarArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IRarArchive OpenArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new RarArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IRarAsyncArchive OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IRarAsyncArchive)OpenArchive(stream, readerOptions);
+    }
+
+    public static IRarAsyncArchive OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IRarAsyncArchive)OpenArchive(fileInfo, readerOptions);
+    }
+
+    public static IRarAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IRarAsyncArchive)OpenArchive(streams, readerOptions);
+    }
+
+    public static IRarAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IRarAsyncArchive)OpenArchive(fileInfos, readerOptions);
+    }
+
+    public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
+
+    public static bool IsRarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsRarFile(stream);
+    }
+
+    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
+    {
+        try
+        {
+            MarkHeader.Read(stream, true, false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static async ValueTask<bool> IsRarFileAsync(
+        Stream stream,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        try
+        {
+            await MarkHeader
+                .ReadAsync(stream, true, false, cancellationToken)
+                .ConfigureAwait(false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -14,17 +14,26 @@ using SharpCompress.Readers.Rar;
 
 namespace SharpCompress.Archives.Rar;
 
-public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
+public interface IRarArchiveCommon
+{
+    int MinVersion { get; }
+    int MaxVersion { get; }
+}
+
+public interface IRarArchive : IArchive, IRarArchiveCommon { }
+
+public interface IRarAsyncArchive : IAsyncArchive, IRarArchiveCommon { }
+
+public partial class RarArchive
+    : AbstractArchive<RarArchiveEntry, RarVolume>,
+        IRarArchive,
+        IRarAsyncArchive
 {
     private bool _disposed;
     internal Lazy<IRarUnpack> UnpackV2017 { get; } =
         new(() => new Compressors.Rar.UnpackV2017.Unpack());
     internal Lazy<IRarUnpack> UnpackV1 { get; } = new(() => new Compressors.Rar.UnpackV1.Unpack());
 
-    /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
-    /// </summary>
-    /// <param name="sourceStream"></param>
     private RarArchive(SourceStream sourceStream)
         : base(ArchiveType.Rar, sourceStream) { }
 
@@ -45,12 +54,17 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
         RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
 
+    // Simple async property - kept in original file
+    protected override IAsyncEnumerable<RarArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<RarVolume> volumes
+    ) => RarArchiveEntryFactory.GetEntriesAsync(this, volumes, ReaderOptions);
+
     protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
     {
-        sourceStream.LoadAllParts(); //request all streams
+        sourceStream.LoadAllParts();
         var streams = sourceStream.Streams.ToArray();
         var i = 0;
-        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
+        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions))
         {
             sourceStream.IsVolumes = true;
             streams[1].Position = 0;
@@ -63,17 +77,10 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
             ));
         }
 
-        //split mode or single file
         return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
     }
 
-    protected override IReader CreateReaderForSolidExtraction() =>
-        CreateReaderForSolidExtractionInternal();
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync() =>
-        new(CreateReaderForSolidExtractionInternal());
-
-    private RarReader CreateReaderForSolidExtractionInternal()
+    protected override IReader CreateReaderForSolidExtraction()
     {
         if (this.IsMultipartVolume())
         {
@@ -82,12 +89,12 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
                 volume.Stream.Position = 0;
                 return volume.Stream;
             });
-            return RarReader.Open(streams, ReaderOptions);
+            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
         }
 
         var stream = Volumes.First().Stream;
         stream.Position = 0;
-        return RarReader.Open(stream, ReaderOptions);
+        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
     }
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
@@ -95,188 +102,6 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
 
     public virtual int MinVersion => Volumes.First().MinVersion;
+
     public virtual int MaxVersion => Volumes.First().MaxVersion;
-
-    #region Creation
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="options"></param>
-    public static RarArchive Open(string filePath, ReaderOptions? options = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        var fileInfo = new FileInfo(filePath);
-        return new RarArchive(
-            new SourceStream(
-                fileInfo,
-                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                options ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="options"></param>
-    public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new RarArchive(
-            new SourceStream(
-                fileInfo,
-                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                options ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="options"></param>
-    public static RarArchive Open(Stream stream, ReaderOptions? options = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static RarArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new RarArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new RarArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(stream, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfo, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(streams, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a RarArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfos, readerOptions));
-    }
-
-    public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
-
-    public static bool IsRarFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsRarFile(stream);
-    }
-
-    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
-    {
-        try
-        {
-            MarkHeader.Read(stream, true, false);
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    #endregion
 }

src/SharpCompress/Archives/Rar/RarArchiveEntry.Async.cs

@@ -0,0 +1,43 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Rar;
+using SharpCompress.Common.Rar.Headers;
+using SharpCompress.Compressors.Rar;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.Rar;
+
+public partial class RarArchiveEntry
+{
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        RarStream stream;
+        if (IsRarV3)
+        {
+            stream = new RarStream(
+                archive.UnpackV1.Value,
+                FileHeader,
+                await MultiVolumeReadOnlyAsyncStream.Create(
+                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
+                )
+            );
+        }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                await MultiVolumeReadOnlyAsyncStream.Create(
+                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
+                )
+            );
+        }
+
+        await stream.InitializeAsync(cancellationToken);
+        return stream;
+    }
+}

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -12,7 +12,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.Rar;
 
-public class RarArchiveEntry : RarEntry, IArchiveEntry
+public partial class RarArchiveEntry : RarEntry, IArchiveEntry
 {
     private readonly ICollection<RarFilePart> parts;
     private readonly RarArchive archive;
@@ -92,32 +92,6 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
         return stream;
     }
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        RarStream stream;
-        if (IsRarV3)
-        {
-            stream = new RarStream(
-                archive.UnpackV1.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
-            );
-        }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
-            );
-        }
-
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
-    }
-
     public bool IsComplete
     {
         get

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

@@ -17,6 +17,19 @@ internal static class RarArchiveEntryFactory
         }
     }
 
+    private static async IAsyncEnumerable<RarFilePart> GetFilePartsAsync(
+        IAsyncEnumerable<RarVolume> parts
+    )
+    {
+        await foreach (var rarPart in parts)
+        {
+            await foreach (var fp in rarPart.ReadFilePartsAsync())
+            {
+                yield return fp;
+            }
+        }
+    }
+
     private static IEnumerable<IEnumerable<RarFilePart>> GetMatchedFileParts(
         IEnumerable<RarVolume> parts
     )
@@ -38,6 +51,27 @@ internal static class RarArchiveEntryFactory
         }
     }
 
+    private static async IAsyncEnumerable<IEnumerable<RarFilePart>> GetMatchedFilePartsAsync(
+        IAsyncEnumerable<RarVolume> parts
+    )
+    {
+        var groupedParts = new List<RarFilePart>();
+        await foreach (var fp in GetFilePartsAsync(parts))
+        {
+            groupedParts.Add(fp);
+
+            if (!fp.FileHeader.IsSplitAfter)
+            {
+                yield return groupedParts;
+                groupedParts = new List<RarFilePart>();
+            }
+        }
+        if (groupedParts.Count > 0)
+        {
+            yield return groupedParts;
+        }
+    }
+
     internal static IEnumerable<RarArchiveEntry> GetEntries(
         RarArchive archive,
         IEnumerable<RarVolume> rarParts,
@@ -49,4 +83,16 @@ internal static class RarArchiveEntryFactory
             yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
         }
     }
+
+    internal static async IAsyncEnumerable<RarArchiveEntry> GetEntriesAsync(
+        RarArchive archive,
+        IAsyncEnumerable<RarVolume> rarParts,
+        ReaderOptions readerOptions
+    )
+    {
+        await foreach (var groupedParts in GetMatchedFilePartsAsync(rarParts))
+        {
+            yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
+        }
+    }
 }

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -13,6 +13,7 @@ internal static class RarArchiveVolumeFactory
         //new style rar - ..part1 | /part01 | part001 ....
         var m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
         if (m.Success)
+        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -23,11 +24,13 @@ internal static class RarArchiveVolumeFactory
                     )
                 )
             );
+        }
         else
         {
             //old style - ...rar, .r00, .r01 ...
             m = Regex.Match(part1.Name, @"^(.*\.)([r-z{])(ar|[0-9]+)$", RegexOptions.IgnoreCase);
             if (m.Success)
+            {
                 item = new FileInfo(
                     Path.Combine(
                         part1.DirectoryName!,
@@ -40,12 +43,17 @@ internal static class RarArchiveVolumeFactory
                         )
                     )
                 );
+            }
             else //split .001, .002 ....
+            {
                 return ArchiveVolumeFactory.GetFilePart(index, part1);
+            }
         }
 
         if (item != null && item.Exists)
+        {
             return item;
+        }
 
         return null; //no more items
     }

src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs

@@ -14,6 +14,9 @@ internal class StreamRarArchiveVolume : RarVolume
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
 
+    internal override IAsyncEnumerable<RarFilePart> ReadFilePartsAsync() =>
+        GetVolumeFilePartsAsync();
+
     internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
         new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
 }

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

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.SevenZip;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.SevenZip;
+
+public partial class SevenZipArchive
+{
+    private async ValueTask LoadFactoryAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_database is null)
+        {
+            stream.Position = 0;
+            var reader = new ArchiveReader();
+            await reader.OpenAsync(
+                stream,
+                lookForHeader: ReaderOptions.LookForHeader,
+                cancellationToken
+            );
+            _database = await reader.ReadDatabaseAsync(
+                new PasswordProvider(ReaderOptions.Password),
+                cancellationToken
+            );
+        }
+    }
+
+    protected override async IAsyncEnumerable<SevenZipArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<SevenZipVolume> volumes
+    )
+    {
+        var stream = (await volumes.SingleAsync()).Stream;
+        await LoadFactoryAsync(stream);
+        if (_database is null)
+        {
+            yield break;
+        }
+        var entries = new SevenZipArchiveEntry[_database._files.Count];
+        for (var i = 0; i < _database._files.Count; i++)
+        {
+            var file = _database._files[i];
+            entries[i] = new SevenZipArchiveEntry(
+                this,
+                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
+            );
+        }
+        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+        {
+            var isSolid = false;
+            foreach (var entry in group)
+            {
+                entry.IsSolid = isSolid;
+                isSolid = true;
+            }
+        }
+
+        foreach (var entry in entries)
+        {
+            yield return entry;
+        }
+    }
+
+    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync() =>
+        new(new SevenZipReader(ReaderOptions, this));
+}

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

@@ -0,0 +1,210 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.SevenZip;
+
+public partial class SevenZipArchive
+#if NET8_0_OR_GREATER
+    : IArchiveOpenable<IArchive, IAsyncArchive>,
+        IMultiArchiveOpenable<IArchive, IAsyncArchive>
+#endif
+{
+    public static IAsyncArchive OpenAsyncArchive(
+        string path,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        path.NotNullOrEmpty("path");
+        return (IAsyncArchive)OpenArchive(new FileInfo(path), readerOptions ?? new ReaderOptions());
+    }
+
+    public static IArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty("filePath");
+        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull("fileInfo");
+        return new SevenZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IArchive OpenArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new SevenZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IArchive OpenArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new SevenZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull("stream");
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new SevenZipArchive(
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static IAsyncArchive OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IAsyncArchive)OpenArchive(stream, readerOptions);
+    }
+
+    public static IAsyncArchive OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IAsyncArchive)OpenArchive(fileInfo, readerOptions);
+    }
+
+    public static IAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IAsyncArchive)OpenArchive(streams, readerOptions);
+    }
+
+    public static IAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IAsyncArchive)OpenArchive(fileInfos, readerOptions);
+    }
+
+    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
+
+    public static bool IsSevenZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsSevenZipFile(stream);
+    }
+
+    public static bool IsSevenZipFile(Stream stream)
+    {
+        try
+        {
+            return SignatureMatch(stream);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static async ValueTask<bool> IsSevenZipFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        try
+        {
+            return await SignatureMatchAsync(stream, cancellationToken);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static ReadOnlySpan<byte> Signature => [(byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C];
+
+    private static bool SignatureMatch(Stream stream)
+    {
+        var buffer = ArrayPool<byte>.Shared.Rent(6);
+        try
+        {
+            stream.ReadExact(buffer, 0, 6);
+            return buffer.AsSpan().Slice(0, 6).SequenceEqual(Signature);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+    }
+
+    private static async ValueTask<bool> SignatureMatchAsync(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = ArrayPool<byte>.Shared.Rent(6);
+        try
+        {
+            if (!await stream.ReadFullyAsync(buffer, 0, 6, cancellationToken).ConfigureAwait(false))
+            {
+                return false;
+            }
+
+            return buffer.AsSpan().Slice(0, 6).SequenceEqual(Signature);
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+    }
+}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -12,163 +12,10 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.SevenZip;
 
-public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
+public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
 {
     private ArchiveDatabase? _database;
 
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty("filePath");
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.NotNull("fileInfo");
-        return new SevenZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new SevenZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(
-        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new SevenZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull("stream");
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new SevenZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(stream, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfo, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(streams, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a SevenZipArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfos, readerOptions));
-    }
-
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
@@ -182,18 +29,6 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         return new SevenZipVolume(sourceStream, ReaderOptions, 0).AsEnumerable(); //simple single volume or split, multivolume not supported
     }
 
-    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
-
-    public static bool IsSevenZipFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsSevenZipFile(stream);
-    }
-
     internal SevenZipArchive()
         : base(ArchiveType.SevenZip) { }
 
@@ -201,32 +36,45 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         IEnumerable<SevenZipVolume> volumes
     )
     {
-        var stream = volumes.Single().Stream;
-        LoadFactory(stream);
-        if (_database is null)
+        foreach (var volume in volumes)
         {
-            return Enumerable.Empty<SevenZipArchiveEntry>();
-        }
-        var entries = new SevenZipArchiveEntry[_database._files.Count];
-        for (var i = 0; i < _database._files.Count; i++)
-        {
-            var file = _database._files[i];
-            entries[i] = new SevenZipArchiveEntry(
-                this,
-                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
-            );
-        }
-        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
-        {
-            var isSolid = false;
-            foreach (var entry in group)
+            LoadFactory(volume.Stream);
+            if (_database is null)
             {
-                entry.IsSolid = isSolid;
-                isSolid = true; //mark others in this group as solid - same as rar behaviour.
+                yield break;
+            }
+            var entries = new SevenZipArchiveEntry[_database._files.Count];
+            for (var i = 0; i < _database._files.Count; i++)
+            {
+                var file = _database._files[i];
+                entries[i] = new SevenZipArchiveEntry(
+                    this,
+                    new SevenZipFilePart(
+                        volume.Stream,
+                        _database,
+                        i,
+                        file,
+                        ReaderOptions.ArchiveEncoding
+                    )
+                );
+            }
+            foreach (
+                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
+            )
+            {
+                var isSolid = false;
+                foreach (var entry in group)
+                {
+                    entry.IsSolid = isSolid;
+                    isSolid = true;
+                }
+            }
+
+            foreach (var entry in entries)
+            {
+                yield return entry;
             }
         }
-
-        return entries;
     }
 
     private void LoadFactory(Stream stream)
@@ -240,34 +88,9 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         }
     }
 
-    public static bool IsSevenZipFile(Stream stream)
-    {
-        try
-        {
-            return SignatureMatch(stream);
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    private static ReadOnlySpan<byte> Signature =>
-        new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
-
-    private static bool SignatureMatch(Stream stream)
-    {
-        var reader = new BinaryReader(stream);
-        ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
-        return signatureBytes.SequenceEqual(Signature);
-    }
-
     protected override IReader CreateReaderForSolidExtraction() =>
         new SevenZipReader(ReaderOptions, this);
 
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync() =>
-        new(new SevenZipReader(ReaderOptions, this));
-
     public override bool IsSolid =>
         Entries
             .Where(x => !x.IsDirectory)
@@ -279,13 +102,34 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
     public override long TotalSize =>
         _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;
 
-    private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+    internal sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
     {
         private readonly SevenZipArchive _archive;
         private SevenZipEntry? _currentEntry;
+        private Stream? _currentFolderStream;
+        private CFolder? _currentFolder;
+
+        /// <summary>
+        /// Enables internal diagnostics for tests.
+        /// When disabled (default), diagnostics properties return null to avoid exposing internal state.
+        /// </summary>
+        internal bool DiagnosticsEnabled { get; set; }
+
+        /// <summary>
+        /// Current folder instance used to decide whether the solid folder stream should be reused.
+        /// Only available when <see cref="DiagnosticsEnabled"/> is true.
+        /// </summary>
+        internal object? DiagnosticsCurrentFolder => DiagnosticsEnabled ? _currentFolder : null;
+
+        /// <summary>
+        /// Current shared folder stream instance.
+        /// Only available when <see cref="DiagnosticsEnabled"/> is true.
+        /// </summary>
+        internal Stream? DiagnosticsCurrentFolderStream =>
+            DiagnosticsEnabled ? _currentFolderStream : null;
 
         internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-            : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive;
+            : base(readerOptions, ArchiveType.SevenZip, false) => this._archive = archive;
 
         public override SevenZipVolume Volume => _archive.Volumes.Single();
 
@@ -298,9 +142,10 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
                 _currentEntry = dir;
                 yield return dir;
             }
-            // For non-directory entries, yield them without creating shared streams
-            // Each call to GetEntryStream() will create a fresh decompression stream
-            // to avoid state corruption issues with async operations
+            // For solid archives (entries in the same folder share a compressed stream),
+            // we must iterate entries sequentially and maintain the folder stream state
+            // across entries in the same folder to avoid recreating the decompression
+            // stream for each file, which breaks contiguous streaming.
             foreach (var entry in entries.Where(x => !x.IsDirectory))
             {
                 _currentEntry = entry;
@@ -310,19 +155,46 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
 
         protected override EntryStream GetEntryStream()
         {
-            // Create a fresh decompression stream for each file (no state sharing).
-            // However, the LZMA decoder has bugs in its async implementation that cause
-            // state corruption even on fresh streams. The SyncOnlyStream wrapper
-            // works around these bugs by forcing async operations to use sync equivalents.
-            //
-            // TODO: Fix the LZMA decoder async bugs (in LzmaStream, Decoder, OutWindow)
-            // so this wrapper is no longer necessary.
             var entry = _currentEntry.NotNull("currentEntry is not null");
             if (entry.IsDirectory)
             {
                 return CreateEntryStream(Stream.Null);
             }
-            return CreateEntryStream(new SyncOnlyStream(entry.FilePart.GetCompressedStream()));
+
+            var folder = entry.FilePart.Folder;
+
+            // Check if we're starting a new folder - dispose old folder stream if needed
+            if (folder != _currentFolder)
+            {
+                _currentFolderStream?.Dispose();
+                _currentFolderStream = null;
+                _currentFolder = folder;
+            }
+
+            // Create the folder stream once per folder
+            if (_currentFolderStream is null)
+            {
+                _currentFolderStream = _archive._database!.GetFolderStream(
+                    _archive.Volumes.Single().Stream,
+                    folder!,
+                    _archive._database.PasswordProvider
+                );
+            }
+
+            // Wrap with SyncOnlyStream to work around LZMA async bugs
+            // Return a ReadOnlySubStream that reads from the shared folder stream
+            return CreateEntryStream(
+                new SyncOnlyStream(
+                    new ReadOnlySubStream(_currentFolderStream, entry.Size, leaveOpen: true)
+                )
+            );
+        }
+
+        public override void Dispose()
+        {
+            _currentFolderStream?.Dispose();
+            _currentFolderStream = null;
+            base.Dispose();
         }
     }
 
@@ -395,7 +267,7 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
             return Task.CompletedTask;
         }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
+#if !LEGACY_DOTNET
         public override ValueTask<int> ReadAsync(
             Memory<byte> buffer,
             CancellationToken cancellationToken = default

src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs

@@ -14,7 +14,7 @@ public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 
     public async ValueTask<Stream> OpenEntryStreamAsync(
         CancellationToken cancellationToken = default
-    ) => OpenEntryStream();
+    ) => (await FilePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
 
     public IArchive Archive { get; }
 

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

@@ -0,0 +1,161 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Tar;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Tar;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Tar;
+
+namespace SharpCompress.Archives.Tar;
+
+public partial class TarArchive
+{
+    protected override async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IAsyncEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<TarArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        await foreach (
+            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        entry.LastModifiedTime,
+                        entry.Size,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+        foreach (var entry in newEntries)
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        entry.LastModifiedTime,
+                        entry.Size,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return new((IAsyncReader)TarReader.OpenReader(stream));
+    }
+
+    protected override async IAsyncEnumerable<TarArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<TarVolume> volumes
+    )
+    {
+        var stream = (await volumes.SingleAsync()).Stream;
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        // Always use async header reading in LoadEntriesAsync for consistency
+        {
+            // Use async header reading for async-only streams
+            TarHeader? previousHeader = null;
+            await foreach (
+                var header in TarHeaderFactory.ReadHeaderAsync(
+                    StreamingMode.Seekable,
+                    stream,
+                    ReaderOptions.ArchiveEncoding
+                )
+            )
+            {
+                if (header != null)
+                {
+                    if (header.EntryType == EntryType.LongName)
+                    {
+                        previousHeader = header;
+                    }
+                    else
+                    {
+                        if (previousHeader != null)
+                        {
+                            var entry = new TarArchiveEntry(
+                                this,
+                                new TarFilePart(previousHeader, stream),
+                                CompressionType.None
+                            );
+
+                            var oldStreamPos = stream.Position;
+
+                            using (var entryStream = entry.OpenEntryStream())
+                            {
+                                using var memoryStream = new MemoryStream();
+                                await entryStream.CopyToAsync(memoryStream);
+                                memoryStream.Position = 0;
+                                var bytes = memoryStream.ToArray();
+
+                                header.Name = ReaderOptions
+                                    .ArchiveEncoding.Decode(bytes)
+                                    .TrimNulls();
+                            }
+
+                            stream.Position = oldStreamPos;
+
+                            previousHeader = null;
+                        }
+                        yield return new TarArchiveEntry(
+                            this,
+                            new TarFilePart(header, stream),
+                            CompressionType.None
+                        );
+                    }
+                }
+                else
+                {
+                    throw new IncompleteArchiveException("Failed to read TAR header");
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,202 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.Tar;
+
+public partial class TarArchive
+#if NET8_0_OR_GREATER
+    : IWritableArchiveOpenable,
+        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
+#endif
+{
+    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenArchive(new FileInfo(filePath), readerOptions);
+    }
+
+    public static IWritableArchive OpenArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new TarArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new TarArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new TarArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new TarArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        string path,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(new FileInfo(path), readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
+    }
+
+    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
+
+    public static bool IsTarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsTarFile(stream);
+    }
+
+    public static bool IsTarFile(Stream stream)
+    {
+        try
+        {
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+            var reader = new BinaryReader(stream, Encoding.UTF8, false);
+            var readSucceeded = tarHeader.Read(reader);
+            var isEmptyArchive =
+                tarHeader.Name?.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
+        }
+        catch (Exception)
+        {
+            // Catch all exceptions during tar header reading to determine if this is a valid tar file
+            // Invalid tar files or corrupted streams will throw various exceptions
+            return false;
+        }
+    }
+
+    public static async ValueTask<bool> IsTarFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        try
+        {
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+#if NET8_0_OR_GREATER
+            await using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
+#else
+            using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
+#endif
+            var readSucceeded = await tarHeader.ReadAsync(reader);
+            var isEmptyArchive =
+                tarHeader.Name?.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
+        }
+        catch (Exception)
+        {
+            // Catch all exceptions during tar header reading to determine if this is a valid tar file
+            // Invalid tar files or corrupted streams will throw various exceptions
+            return false;
+        }
+    }
+
+    public static IWritableArchive CreateArchive() => new TarArchive();
+
+    public static IWritableAsyncArchive CreateAsyncArchive() => new TarArchive();
+}

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -15,196 +15,14 @@ using SharpCompress.Writers.Tar;
 
 namespace SharpCompress.Archives.Tar;
 
-public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
 {
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new TarArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new TarArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new TarArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new TarArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(stream, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfo, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(streams, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a TarArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfos, readerOptions));
-    }
-
-    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
-
-    public static bool IsTarFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsTarFile(stream);
-    }
-
-    public static bool IsTarFile(Stream stream)
-    {
-        try
-        {
-            var tarHeader = new TarHeader(new ArchiveEncoding());
-            var readSucceeded = tarHeader.Read(new BinaryReader(stream));
-            var isEmptyArchive =
-                tarHeader.Name?.Length == 0
-                && tarHeader.Size == 0
-                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
-            return readSucceeded || isEmptyArchive;
-        }
-        catch { }
-        return false;
-    }
-
     protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
     {
-        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
-        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable(); //simple single volume or split, multivolume not supported
+        sourceStream.NotNull("SourceStream is null").LoadAllParts();
+        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable();
     }
 
-    /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
-    /// </summary>
-    /// <param name="sourceStream"></param>
     private TarArchive(SourceStream sourceStream)
         : base(ArchiveType.Tar, sourceStream) { }
 
@@ -214,6 +32,10 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
     {
         var stream = volumes.Single().Stream;
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
         TarHeader? previousHeader = null;
         foreach (
             var header in TarHeaderFactory.ReadHeader(
@@ -244,7 +66,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                         using (var entryStream = entry.OpenEntryStream())
                         {
                             using var memoryStream = new MemoryStream();
-                            entryStream.CopyTo(memoryStream);
+                            entryStream.CopyTo(memoryStream, Constants.BufferSize);
                             memoryStream.Position = 0;
                             var bytes = memoryStream.ToArray();
 
@@ -269,8 +91,6 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         }
     }
 
-    public static TarArchive Create() => new();
-
     protected override TarArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -323,54 +143,10 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         }
     }
 
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TarArchiveEntry> oldEntries,
-        IEnumerable<TarArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return TarReader.Open(stream);
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new(TarReader.Open(stream));
+        return TarReader.OpenReader(stream);
     }
 }

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -16,7 +16,7 @@ public class TarArchiveEntry : TarEntry, IArchiveEntry
 
     public async ValueTask<Stream> OpenEntryStreamAsync(
         CancellationToken cancellationToken = default
-    ) => OpenEntryStream();
+    ) => (await Parts.Single().GetCompressedStreamAsync(cancellationToken)).NotNull();
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -79,7 +79,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Archives/Zip/ZipArchive.Async.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Zip;
+using SharpCompress.Common.Zip.Headers;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Zip;
+
+namespace SharpCompress.Archives.Zip;
+
+public partial class ZipArchive
+{
+    protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<ZipVolume> volumes
+    )
+    {
+        var vols = await volumes.ToListAsync();
+        var volsArray = vols.ToArray();
+
+        await foreach (
+            var h in headerFactory.NotNull().ReadSeekableHeaderAsync(volsArray.Last().Stream)
+        )
+        {
+            if (h != null)
+            {
+                switch (h.ZipHeaderType)
+                {
+                    case ZipHeaderType.DirectoryEntry:
+                        {
+                            var deh = (DirectoryEntryHeader)h;
+                            Stream s;
+                            if (
+                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
+                                > volsArray[deh.DiskNumberStart].Stream.Length
+                            )
+                            {
+                                var v = volsArray.Skip(deh.DiskNumberStart).ToArray();
+                                s = new SourceStream(
+                                    v[0].Stream,
+                                    i => i < v.Length ? v[i].Stream : null,
+                                    new ReaderOptions() { LeaveStreamOpen = true }
+                                );
+                            }
+                            else
+                            {
+                                s = volsArray[deh.DiskNumberStart].Stream;
+                            }
+
+                            yield return new ZipArchiveEntry(
+                                this,
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                            );
+                        }
+                        break;
+                    case ZipHeaderType.DirectoryEnd:
+                    {
+                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
+                        volsArray.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                        yield break;
+                    }
+                }
+            }
+        }
+    }
+
+    protected override async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IAsyncEnumerable<ZipArchiveEntry> oldEntries,
+        IEnumerable<ZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        await foreach (
+            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+        foreach (var entry in newEntries)
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+}

src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs

@@ -0,0 +1,287 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Zip;
+using SharpCompress.Common.Zip.Headers;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.Zip;
+
+public partial class ZipArchive
+#if NET8_0_OR_GREATER
+    : IWritableArchiveOpenable,
+        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
+#endif
+{
+    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenArchive(new FileInfo(filePath), readerOptions);
+    }
+
+    public static IWritableArchive OpenArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new ZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new ZipArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        string path,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(path, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
+    }
+
+    public static IWritableAsyncArchive OpenAsyncArchive(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
+    }
+
+    public static bool IsZipFile(string filePath, string? password = null) =>
+        IsZipFile(new FileInfo(filePath), password);
+
+    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsZipFile(stream, password);
+    }
+
+    public static bool IsZipFile(Stream stream, string? password = null)
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                return false;
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsZipMulti(Stream stream, string? password = null)
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                if (stream.CanSeek)
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static async ValueTask<bool> IsZipFileAsync(
+        Stream stream,
+        string? password = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            var header = await headerFactory
+                .ReadStreamHeaderAsync(stream)
+                .Where(x => x.ZipHeaderType != ZipHeaderType.Split)
+                .FirstOrDefaultAsync(cancellationToken);
+            if (header is null)
+            {
+                return false;
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static IWritableArchive CreateArchive() => new ZipArchive();
+
+    public static IWritableAsyncArchive CreateAsyncArchive() => new ZipArchive();
+
+    public static async ValueTask<bool> IsZipMultiAsync(
+        Stream stream,
+        string? password = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                if (stream.CanSeek)
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    ZipHeader? x = null;
+                    await foreach (
+                        var h in z.ReadSeekableHeaderAsync(stream)
+                            .WithCancellation(cancellationToken)
+                    )
+                    {
+                        x = h;
+                        break;
+                    }
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+}

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -16,21 +16,12 @@ using SharpCompress.Writers.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
     private readonly SeekableZipHeaderFactory? headerFactory;
 
-    /// <summary>
-    /// Gets or sets the compression level applied to files added to the archive,
-    /// if the compression method is set to deflate
-    /// </summary>
     public CompressionLevel DeflateCompressionLevel { get; set; }
 
-    /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
-    /// </summary>
-    /// <param name="sourceStream"></param>
-    /// <param name="options"></param>
     internal ZipArchive(SourceStream sourceStream)
         : base(ArchiveType.Zip, sourceStream) =>
         headerFactory = new SeekableZipHeaderFactory(
@@ -38,377 +29,43 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
             sourceStream.ReaderOptions.ArchiveEncoding
         );
 
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.NotNull(nameof(fileInfo));
-        return new ZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new ZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.NotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new ZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new ZipArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from a stream.
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(stream, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from a FileInfo.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfo, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from multiple streams.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(streams, readerOptions));
-    }
-
-    /// <summary>
-    /// Opens a ZipArchive asynchronously from multiple FileInfo objects.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    /// <param name="cancellationToken"></param>
-    public static ValueTask<IAsyncArchive> OpenAsync(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return new(Open(fileInfos, readerOptions));
-    }
-
-    public static bool IsZipFile(
-        string filePath,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    ) => IsZipFile(new FileInfo(filePath), password, bufferSize);
-
-    public static bool IsZipFile(
-        FileInfo fileInfo,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
-    {
-        if (!fileInfo.Exists)
-        {
-            return false;
-        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password, bufferSize);
-    }
-
-    public static bool IsZipFile(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
-    {
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            if (stream is not SharpCompressStream)
-            {
-                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
-            }
-
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                return false;
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static bool IsZipMulti(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
-    {
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            if (stream is not SharpCompressStream)
-            {
-                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
-            }
-
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
-                {
-                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    var x = z.ReadSeekableHeader(stream, useSync: true).FirstOrDefault();
-                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async ValueTask<bool> IsZipFileAsync(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            if (stream is not SharpCompressStream)
-            {
-                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
-            }
-
-            var header = await headerFactory
-                .ReadStreamHeaderAsync(stream)
-                .Where(x => x.ZipHeaderType != ZipHeaderType.Split)
-                .FirstOrDefaultAsync();
-            if (header is null)
-            {
-                return false;
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    public static async ValueTask<bool> IsZipMultiAsync(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
-        {
-            if (stream is not SharpCompressStream)
-            {
-                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
-            }
-
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
-            {
-                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
-                {
-                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    ZipHeader? x = null;
-                    await foreach (
-                        var h in z.ReadSeekableHeaderAsync(stream)
-                            .WithCancellation(cancellationToken)
-                    )
-                    {
-                        x = h;
-                        break;
-                    }
-                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
-                }
-                else
-                {
-                    return false;
-                }
-            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
+    internal ZipArchive()
+        : base(ArchiveType.Zip) { }
 
     protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
     {
-        stream.LoadAllParts(); //request all streams
-        stream.Position = 0;
+        stream.LoadAllParts();
+        //stream.Position = 0;
 
         var streams = stream.Streams.ToList();
         var idx = 0;
-        if (streams.Count() > 1) //test part 2 - true = multipart not split
+        if (streams.Count() > 1)
         {
-            streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
-            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
-            streams[1].Position -= 4;
+            //check if second stream is zip header without changing position
+            var headerProbeStream = streams[1];
+            var startPosition = headerProbeStream.Position;
+            headerProbeStream.Position = startPosition + 4;
+            var isZip = IsZipFile(headerProbeStream, ReaderOptions.Password);
+            headerProbeStream.Position = startPosition;
             if (isZip)
             {
                 stream.IsVolumes = true;
 
-                var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
+                var tmp = streams[0];
                 streams.RemoveAt(0);
                 streams.Add(tmp);
 
-                //streams[0].Position = 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
                 return streams.Select(a => new ZipVolume(a, ReaderOptions, idx++));
             }
         }
 
-        //split mode or single file
         return new ZipVolume(stream, ReaderOptions, idx++).AsEnumerable();
     }
 
-    internal ZipArchive()
-        : base(ArchiveType.Zip) { }
-
     protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
     {
         var vols = volumes.ToArray();
-        foreach (
-            var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream, useSync: true)
-        )
+        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
         {
             if (h != null)
             {
@@ -452,59 +109,6 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
-    protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<ZipVolume> volumes
-    )
-    {
-        var vols = await volumes.ToListAsync();
-        var volsArray = vols.ToArray();
-
-        await foreach (
-            var h in headerFactory.NotNull().ReadSeekableHeaderAsync(volsArray.Last().Stream)
-        )
-        {
-            if (h != null)
-            {
-                switch (h.ZipHeaderType)
-                {
-                    case ZipHeaderType.DirectoryEntry:
-                        {
-                            var deh = (DirectoryEntryHeader)h;
-                            Stream s;
-                            if (
-                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
-                                > volsArray[deh.DiskNumberStart].Stream.Length
-                            )
-                            {
-                                var v = volsArray.Skip(deh.DiskNumberStart).ToArray();
-                                s = new SourceStream(
-                                    v[0].Stream,
-                                    i => i < v.Length ? v[i].Stream : null,
-                                    new ReaderOptions() { LeaveStreamOpen = true }
-                                );
-                            }
-                            else
-                            {
-                                s = volsArray[deh.DiskNumberStart].Stream;
-                            }
-
-                            yield return new ZipArchiveEntry(
-                                this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
-                            );
-                        }
-                        break;
-                    case ZipHeaderType.DirectoryEnd:
-                    {
-                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                        volsArray.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                        yield break;
-                    }
-                }
-            }
-        }
-    }
-
     public void SaveTo(Stream stream) => SaveTo(stream, new WriterOptions(CompressionType.Deflate));
 
     protected override void SaveTo(
@@ -536,41 +140,6 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<ZipArchiveEntry> oldEntries,
-        IEnumerable<ZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     protected override ZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -584,19 +153,17 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         DateTime? modified
     ) => new ZipWritableArchiveEntry(this, directoryPath, modified);
 
-    public static ZipArchive Create() => new();
-
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
-        ((IStreamStack)stream).StackSeek(0);
-        return ZipReader.Open(stream, ReaderOptions, Entries);
+        //stream.Position = 0;
+        return ZipReader.OpenReader(stream, ReaderOptions, Entries);
     }
 
     protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return new(ZipReader.Open(stream));
+        return new((IAsyncReader)ZipReader.OpenReader(stream));
     }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.Async.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Zip;
+
+namespace SharpCompress.Archives.Zip;
+
+public partial class ZipArchiveEntry
+{
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        var part = Parts.Single();
+        if (part is SeekableZipFilePart seekablePart)
+        {
+            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
+        }
+        return OpenEntryStream();
+    }
+}

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -6,25 +6,13 @@ using SharpCompress.Common.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public class ZipArchiveEntry : ZipEntry, IArchiveEntry
+public partial class ZipArchiveEntry : ZipEntry, IArchiveEntry
 {
     internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
         : base(part) => Archive = archive;
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        var part = Parts.Single();
-        if (part is SeekableZipFilePart seekablePart)
-        {
-            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
-        }
-        return OpenEntryStream();
-    }
-
     #region IArchiveEntry Members
 
     public IArchive Archive { get; }

src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs

@@ -14,6 +14,7 @@ internal static class ZipArchiveVolumeFactory
         //new style .zip, z01.. | .zipx, zx01 - if the numbers go beyond 99 then they use 100 ...1000 etc
         var m = Regex.Match(part1.Name, @"^(.*\.)(zipx?|zx?[0-9]+)$", RegexOptions.IgnoreCase);
         if (m.Success)
+        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -24,11 +25,16 @@ internal static class ZipArchiveVolumeFactory
                     )
                 )
             );
+        }
         else //split - 001, 002 ...
+        {
             return ArchiveVolumeFactory.GetFilePart(index, part1);
+        }
 
         if (item != null && item.Exists)
+        {
             return item;
+        }
 
         return null; //no more items
     }

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -80,7 +80,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Common/Ace/AceCrc.cs

@@ -4,58 +4,61 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceCrc
 {
-    public class AceCrc
+    // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected)
+    private static readonly uint[] Crc32Table = GenerateTable();
+
+    private static uint[] GenerateTable()
     {
-        // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected)
-        private static readonly uint[] Crc32Table = GenerateTable();
+        var table = new uint[256];
 
-        private static uint[] GenerateTable()
+        for (int i = 0; i < 256; i++)
         {
-            var table = new uint[256];
+            uint crc = (uint)i;
 
-            for (int i = 0; i < 256; i++)
+            for (int j = 0; j < 8; j++)
             {
-                uint crc = (uint)i;
-
-                for (int j = 0; j < 8; j++)
+                if ((crc & 1) != 0)
                 {
-                    if ((crc & 1) != 0)
-                        crc = (crc >> 1) ^ 0xEDB88320u;
-                    else
-                        crc >>= 1;
+                    crc = (crc >> 1) ^ 0xEDB88320u;
+                }
+                else
+                {
+                    crc >>= 1;
                 }
-
-                table[i] = crc;
             }
 
-            return table;
+            table[i] = crc;
         }
 
-        /// <summary>
-        /// Calculate ACE CRC-32 checksum.
-        /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected)
-        /// with init=0xFFFFFFFF but NO final XOR.
-        /// </summary>
-        public static uint AceCrc32(ReadOnlySpan<byte> data)
+        return table;
+    }
+
+    /// <summary>
+    /// Calculate ACE CRC-32 checksum.
+    /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected)
+    /// with init=0xFFFFFFFF but NO final XOR.
+    /// </summary>
+    public static uint AceCrc32(ReadOnlySpan<byte> data)
+    {
+        uint crc = 0xFFFFFFFFu;
+
+        foreach (byte b in data)
         {
-            uint crc = 0xFFFFFFFFu;
-
-            foreach (byte b in data)
-            {
-                crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
-            }
-
-            return crc; // No final XOR for ACE
+            crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
         }
 
-        /// <summary>
-        /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32.
-        /// </summary>
-        public static ushort AceCrc16(ReadOnlySpan<byte> data)
-        {
-            return (ushort)(AceCrc32(data) & 0xFFFF);
-        }
+        return crc; // No final XOR for ACE
+    }
+
+    /// <summary>
+    /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32.
+    /// </summary>
+    public static ushort AceCrc16(ReadOnlySpan<byte> data)
+    {
+        return (ushort)(AceCrc32(data) & 0xFFFF);
     }
 }

src/SharpCompress/Common/Ace/AceEntry.cs

@@ -6,63 +6,62 @@ using System.Text;
 using System.Threading.Tasks;
 using SharpCompress.Common.Ace.Headers;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceEntry : Entry
 {
-    public class AceEntry : Entry
+    private readonly AceFilePart _filePart;
+
+    internal AceEntry(AceFilePart filePart)
     {
-        private readonly AceFilePart _filePart;
-
-        internal AceEntry(AceFilePart filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override long Crc
-        {
-            get
-            {
-                if (_filePart == null)
-                {
-                    return 0;
-                }
-                return _filePart.Header.Crc32;
-            }
-        }
-
-        public override string? Key => _filePart?.Header.Filename;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => _filePart?.Header.PackedSize ?? 0;
-
-        public override CompressionType CompressionType
-        {
-            get
-            {
-                if (_filePart.Header.CompressionType == Headers.CompressionType.Stored)
-                {
-                    return CompressionType.None;
-                }
-                return CompressionType.AceLZ77;
-            }
-        }
-
-        public override long Size => _filePart?.Header.OriginalSize ?? 0;
-
-        public override DateTime? LastModifiedTime => _filePart.Header.DateTime;
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => _filePart.Header.IsFileEncrypted;
-
-        public override bool IsDirectory => _filePart.Header.IsDirectory;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+        _filePart = filePart;
     }
+
+    public override long Crc
+    {
+        get
+        {
+            if (_filePart == null)
+            {
+                return 0;
+            }
+            return _filePart.Header.Crc32;
+        }
+    }
+
+    public override string? Key => _filePart?.Header.Filename;
+
+    public override string? LinkTarget => null;
+
+    public override long CompressedSize => _filePart?.Header.PackedSize ?? 0;
+
+    public override CompressionType CompressionType
+    {
+        get
+        {
+            if (_filePart.Header.CompressionType == Headers.CompressionType.Stored)
+            {
+                return CompressionType.None;
+            }
+            return CompressionType.AceLZ77;
+        }
+    }
+
+    public override long Size => _filePart?.Header.OriginalSize ?? 0;
+
+    public override DateTime? LastModifiedTime => _filePart.Header.DateTime;
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => _filePart.Header.IsFileEncrypted;
+
+    public override bool IsDirectory => _filePart.Header.IsDirectory;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 }

src/SharpCompress/Common/Ace/AceFilePart.cs

@@ -7,46 +7,45 @@ using System.Threading.Tasks;
 using SharpCompress.Common.Ace.Headers;
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceFilePart : FilePart
 {
-    public class AceFilePart : FilePart
+    private readonly Stream _stream;
+    internal AceFileHeader Header { get; set; }
+
+    internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream)
+        : base(localAceHeader.ArchiveEncoding)
     {
-        private readonly Stream _stream;
-        internal AceFileHeader Header { get; set; }
-
-        internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream)
-            : base(localAceHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localAceHeader;
-        }
-
-        internal override string? FilePartName => Header.Filename;
-
-        internal override Stream GetCompressedStream()
-        {
-            if (_stream != null)
-            {
-                Stream compressedStream;
-                switch (Header.CompressionType)
-                {
-                    case Headers.CompressionType.Stored:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.PackedSize
-                        );
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionQuality
-                        );
-                }
-                return compressedStream;
-            }
-            return _stream.NotNull();
-        }
-
-        internal override Stream? GetRawStream() => _stream;
+        _stream = seekableStream;
+        Header = localAceHeader;
     }
+
+    internal override string? FilePartName => Header.Filename;
+
+    internal override Stream GetCompressedStream()
+    {
+        if (_stream != null)
+        {
+            Stream compressedStream;
+            switch (Header.CompressionType)
+            {
+                case Headers.CompressionType.Stored:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.PackedSize
+                    );
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionQuality
+                    );
+            }
+            return compressedStream;
+        }
+        return _stream.NotNull();
+    }
+
+    internal override Stream? GetRawStream() => _stream;
 }

src/SharpCompress/Common/Ace/AceVolume.cs

@@ -7,29 +7,28 @@ using System.Threading.Tasks;
 using SharpCompress.Common.Arj;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceVolume : Volume
 {
-    public class AceVolume : Volume
+    public AceVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+        : base(stream, readerOptions, index) { }
+
+    public override bool IsFirstVolume
     {
-        public AceVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
+        get { return true; }
+    }
 
-        public override bool IsFirstVolume
-        {
-            get { return true; }
-        }
+    /// <summary>
+    /// ArjArchive is part of a multi-part archive.
+    /// </summary>
+    public override bool IsMultiVolume
+    {
+        get { return false; }
+    }
 
-        /// <summary>
-        /// ArjArchive is part of a multi-part archive.
-        /// </summary>
-        public override bool IsMultiVolume
-        {
-            get { return false; }
-        }
-
-        internal IEnumerable<AceFilePart> GetVolumeFileParts()
-        {
-            return new List<AceFilePart>();
-        }
+    internal IEnumerable<AceFilePart> GetVolumeFileParts()
+    {
+        return new List<AceFilePart>();
     }
 }

src/SharpCompress/Common/Ace/Headers/AceFileHeader.Async.cs

@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Arc;
+
+namespace SharpCompress.Common.Ace.Headers;
+
+public sealed partial class AceFileHeader
+{
+    /// <summary>
+    /// Asynchronously reads the next file entry header from the stream.
+    /// Returns null if no more entries or end of archive.
+    /// Supports both ACE 1.0 and ACE 2.0 formats.
+    /// </summary>
+    public override async ValueTask<AceHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var headerData = await ReadHeaderAsync(stream, cancellationToken);
+        if (headerData.Length == 0)
+        {
+            return null;
+        }
+        int offset = 0;
+
+        // Header type (1 byte)
+        HeaderType = headerData[offset++];
+
+        // Skip recovery record headers (ACE 2.0 feature)
+        if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
+        {
+            // Skip to next header
+            return null;
+        }
+
+        if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
+        {
+            // Unknown header type - skip
+            return null;
+        }
+
+        // Header flags (2 bytes)
+        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Packed size (4 bytes)
+        PackedSize = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // Original size (4 bytes)
+        OriginalSize = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // File date/time in DOS format (4 bytes)
+        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
+        DateTime = ConvertDosDateTime(dosDateTime);
+        offset += 4;
+
+        // File attributes (4 bytes)
+        Attributes = (int)BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // CRC32 (4 bytes)
+        Crc32 = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // Compression type (1 byte)
+        byte compressionType = headerData[offset++];
+        CompressionType = GetCompressionType(compressionType);
+
+        // Compression quality/parameter (1 byte)
+        byte compressionQuality = headerData[offset++];
+        CompressionQuality = GetCompressionQuality(compressionQuality);
+
+        // Parameters (2 bytes)
+        Parameters = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Reserved (2 bytes) - skip
+        offset += 2;
+
+        // Filename length (2 bytes)
+        var filenameLength = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Filename
+        if (offset + filenameLength <= headerData.Length)
+        {
+            Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
+            offset += filenameLength;
+        }
+
+        // Handle comment if present
+        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
+        {
+            // Comment length (2 bytes)
+            if (offset + 2 <= headerData.Length)
+            {
+                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
+                offset += 2 + commentLength; // Skip comment
+            }
+        }
+
+        // Store the data start position
+        DataStartPosition = stream.Position;
+
+        return this;
+    }
+}

src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs

@@ -2,170 +2,173 @@ using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using System.Xml.Linq;
 using SharpCompress.Common.Arc;
 
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// ACE file entry header
+/// </summary>
+public sealed partial class AceFileHeader : AceHeader
 {
+    public long DataStartPosition { get; private set; }
+    public long PackedSize { get; set; }
+    public long OriginalSize { get; set; }
+    public DateTime DateTime { get; set; }
+    public int Attributes { get; set; }
+    public uint Crc32 { get; set; }
+    public CompressionType CompressionType { get; set; }
+    public CompressionQuality CompressionQuality { get; set; }
+    public ushort Parameters { get; set; }
+    public string Filename { get; set; } = string.Empty;
+    public List<byte> Comment { get; set; } = new();
+
     /// <summary>
-    /// ACE file entry header
+    /// File data offset in the archive
     /// </summary>
-    public sealed class AceFileHeader : AceHeader
+    public ulong DataOffset { get; set; }
+
+    public bool IsDirectory => (Attributes & 0x10) != 0;
+
+    public bool IsContinuedFromPrev =>
+        (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_PREV) != 0;
+
+    public bool IsContinuedToNext =>
+        (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_NEXT) != 0;
+
+    public int DictionarySize
     {
-        public long DataStartPosition { get; private set; }
-        public long PackedSize { get; set; }
-        public long OriginalSize { get; set; }
-        public DateTime DateTime { get; set; }
-        public int Attributes { get; set; }
-        public uint Crc32 { get; set; }
-        public CompressionType CompressionType { get; set; }
-        public CompressionQuality CompressionQuality { get; set; }
-        public ushort Parameters { get; set; }
-        public string Filename { get; set; } = string.Empty;
-        public List<byte> Comment { get; set; } = new();
-
-        /// <summary>
-        /// File data offset in the archive
-        /// </summary>
-        public ulong DataOffset { get; set; }
-
-        public bool IsDirectory => (Attributes & 0x10) != 0;
-
-        public bool IsContinuedFromPrev =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_PREV) != 0;
-
-        public bool IsContinuedToNext =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.CONTINUED_NEXT) != 0;
-
-        public int DictionarySize
+        get
         {
-            get
-            {
-                int bits = Parameters & 0x0F;
-                return bits < 10 ? 1024 : 1 << bits;
-            }
+            int bits = Parameters & 0x0F;
+            return bits < 10 ? 1024 : 1 << bits;
         }
-
-        public AceFileHeader(IArchiveEncoding archiveEncoding)
-            : base(archiveEncoding, AceHeaderType.FILE) { }
-
-        /// <summary>
-        /// Reads the next file entry header from the stream.
-        /// Returns null if no more entries or end of archive.
-        /// Supports both ACE 1.0 and ACE 2.0 formats.
-        /// </summary>
-        public override AceHeader? Read(Stream stream)
-        {
-            var headerData = ReadHeader(stream);
-            if (headerData.Length == 0)
-            {
-                return null;
-            }
-            int offset = 0;
-
-            // Header type (1 byte)
-            HeaderType = headerData[offset++];
-
-            // Skip recovery record headers (ACE 2.0 feature)
-            if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
-            {
-                // Skip to next header
-                return null;
-            }
-
-            if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
-            {
-                // Unknown header type - skip
-                return null;
-            }
-
-            // Header flags (2 bytes)
-            HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Packed size (4 bytes)
-            PackedSize = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // Original size (4 bytes)
-            OriginalSize = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // File date/time in DOS format (4 bytes)
-            var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-            DateTime = ConvertDosDateTime(dosDateTime);
-            offset += 4;
-
-            // File attributes (4 bytes)
-            Attributes = (int)BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // CRC32 (4 bytes)
-            Crc32 = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // Compression type (1 byte)
-            byte compressionType = headerData[offset++];
-            CompressionType = GetCompressionType(compressionType);
-
-            // Compression quality/parameter (1 byte)
-            byte compressionQuality = headerData[offset++];
-            CompressionQuality = GetCompressionQuality(compressionQuality);
-
-            // Parameters (2 bytes)
-            Parameters = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Reserved (2 bytes) - skip
-            offset += 2;
-
-            // Filename length (2 bytes)
-            var filenameLength = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Filename
-            if (offset + filenameLength <= headerData.Length)
-            {
-                Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
-                offset += filenameLength;
-            }
-
-            // Handle comment if present
-            if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-            {
-                // Comment length (2 bytes)
-                if (offset + 2 <= headerData.Length)
-                {
-                    ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                    offset += 2 + commentLength; // Skip comment
-                }
-            }
-
-            // Store the data start position
-            DataStartPosition = stream.Position;
-
-            return this;
-        }
-
-        public CompressionType GetCompressionType(byte value) =>
-            value switch
-            {
-                0 => CompressionType.Stored,
-                1 => CompressionType.Lz77,
-                2 => CompressionType.Blocked,
-                _ => CompressionType.Unknown,
-            };
-
-        public CompressionQuality GetCompressionQuality(byte value) =>
-            value switch
-            {
-                0 => CompressionQuality.None,
-                1 => CompressionQuality.Fastest,
-                2 => CompressionQuality.Fast,
-                3 => CompressionQuality.Normal,
-                4 => CompressionQuality.Good,
-                5 => CompressionQuality.Best,
-                _ => CompressionQuality.Unknown,
-            };
     }
+
+    public AceFileHeader(IArchiveEncoding archiveEncoding)
+        : base(archiveEncoding, AceHeaderType.FILE) { }
+
+    /// <summary>
+    /// Reads the next file entry header from the stream.
+    /// Returns null if no more entries or end of archive.
+    /// Supports both ACE 1.0 and ACE 2.0 formats.
+    /// </summary>
+    public override AceHeader? Read(Stream stream)
+    {
+        var headerData = ReadHeader(stream);
+        if (headerData.Length == 0)
+        {
+            return null;
+        }
+        int offset = 0;
+
+        // Header type (1 byte)
+        HeaderType = headerData[offset++];
+
+        // Skip recovery record headers (ACE 2.0 feature)
+        if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
+        {
+            // Skip to next header
+            return null;
+        }
+
+        if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
+        {
+            // Unknown header type - skip
+            return null;
+        }
+
+        // Header flags (2 bytes)
+        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Packed size (4 bytes)
+        PackedSize = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // Original size (4 bytes)
+        OriginalSize = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // File date/time in DOS format (4 bytes)
+        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
+        DateTime = ConvertDosDateTime(dosDateTime);
+        offset += 4;
+
+        // File attributes (4 bytes)
+        Attributes = (int)BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // CRC32 (4 bytes)
+        Crc32 = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // Compression type (1 byte)
+        byte compressionType = headerData[offset++];
+        CompressionType = GetCompressionType(compressionType);
+
+        // Compression quality/parameter (1 byte)
+        byte compressionQuality = headerData[offset++];
+        CompressionQuality = GetCompressionQuality(compressionQuality);
+
+        // Parameters (2 bytes)
+        Parameters = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Reserved (2 bytes) - skip
+        offset += 2;
+
+        // Filename length (2 bytes)
+        var filenameLength = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Filename
+        if (offset + filenameLength <= headerData.Length)
+        {
+            Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
+            offset += filenameLength;
+        }
+
+        // Handle comment if present
+        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
+        {
+            // Comment length (2 bytes)
+            if (offset + 2 <= headerData.Length)
+            {
+                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
+                offset += 2 + commentLength; // Skip comment
+            }
+        }
+
+        // Store the data start position
+        DataStartPosition = stream.Position;
+
+        return this;
+    }
+
+    // ReadAsync moved to AceFileHeader.Async.cs
+
+    public CompressionType GetCompressionType(byte value) =>
+        value switch
+        {
+            0 => CompressionType.Stored,
+            1 => CompressionType.Lz77,
+            2 => CompressionType.Blocked,
+            _ => CompressionType.Unknown,
+        };
+
+    public CompressionQuality GetCompressionQuality(byte value) =>
+        value switch
+        {
+            0 => CompressionQuality.None,
+            1 => CompressionQuality.Fastest,
+            2 => CompressionQuality.Fast,
+            3 => CompressionQuality.Normal,
+            4 => CompressionQuality.Good,
+            5 => CompressionQuality.Best,
+            _ => CompressionQuality.Unknown,
+        };
 }

src/SharpCompress/Common/Ace/Headers/AceHeader.Async.cs

@@ -0,0 +1,69 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Ace.Headers;
+
+public abstract partial class AceHeader
+{
+    public abstract ValueTask<AceHeader?> ReadAsync(
+        Stream reader,
+        CancellationToken cancellationToken = default
+    );
+
+    public async ValueTask<byte[]> ReadHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Read header CRC (2 bytes) and header size (2 bytes)
+        var headerBytes = new byte[4];
+        if (!await stream.ReadFullyAsync(headerBytes, 0, 4, cancellationToken))
+        {
+            return Array.Empty<byte>();
+        }
+
+        HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation
+        HeaderSize = BitConverter.ToUInt16(headerBytes, 2);
+        if (HeaderSize == 0)
+        {
+            return Array.Empty<byte>();
+        }
+
+        // Read the header data
+        var body = new byte[HeaderSize];
+        if (!await stream.ReadFullyAsync(body, 0, HeaderSize, cancellationToken))
+        {
+            return Array.Empty<byte>();
+        }
+
+        // Verify crc
+        var checksum = AceCrc.AceCrc16(body);
+        if (checksum != HeaderCrc)
+        {
+            throw new InvalidDataException("Header checksum is invalid");
+        }
+        return body;
+    }
+
+    /// <summary>
+    /// Asynchronously checks if the stream is an ACE archive
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>True if the stream is an ACE archive, false otherwise</returns>
+    public static async ValueTask<bool> IsArchiveAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var bytes = new byte[14];
+        if (!await stream.ReadFullyAsync(bytes, 0, 14, cancellationToken))
+        {
+            return false;
+        }
+
+        return CheckMagicBytes(bytes, 7);
+    }
+}

src/SharpCompress/Common/Ace/Headers/AceHeader.cs

@@ -1,153 +1,156 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Arj.Headers;
 using SharpCompress.Crypto;
 
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// Header type constants
+/// </summary>
+public enum AceHeaderType
 {
-    /// <summary>
-    /// Header type constants
-    /// </summary>
-    public enum AceHeaderType
+    MAIN = 0,
+    FILE = 1,
+    RECOVERY32 = 2,
+    RECOVERY64A = 3,
+    RECOVERY64B = 4,
+}
+
+public abstract partial class AceHeader
+{
+    // ACE signature: bytes at offset 7 should be "**ACE**"
+    private static readonly byte[] AceSignature =
+    [
+        (byte)'*',
+        (byte)'*',
+        (byte)'A',
+        (byte)'C',
+        (byte)'E',
+        (byte)'*',
+        (byte)'*',
+    ];
+
+    public AceHeader(IArchiveEncoding archiveEncoding, AceHeaderType type)
     {
-        MAIN = 0,
-        FILE = 1,
-        RECOVERY32 = 2,
-        RECOVERY64A = 3,
-        RECOVERY64B = 4,
+        AceHeaderType = type;
+        ArchiveEncoding = archiveEncoding;
     }
 
-    public abstract class AceHeader
+    public IArchiveEncoding ArchiveEncoding { get; }
+    public AceHeaderType AceHeaderType { get; }
+
+    public ushort HeaderFlags { get; set; }
+    public ushort HeaderCrc { get; set; }
+    public ushort HeaderSize { get; set; }
+    public byte HeaderType { get; set; }
+
+    public bool IsFileEncrypted =>
+        (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.FILE_ENCRYPTED) != 0;
+    public bool Is64Bit =>
+        (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MEMORY_64BIT) != 0;
+
+    public bool IsSolid =>
+        (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.SOLID_MAIN) != 0;
+
+    public bool IsMultiVolume =>
+        (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MULTIVOLUME) != 0;
+
+    public abstract AceHeader? Read(Stream reader);
+
+    // Async methods moved to AceHeader.Async.cs
+
+    public byte[] ReadHeader(Stream stream)
     {
-        // ACE signature: bytes at offset 7 should be "**ACE**"
-        private static readonly byte[] AceSignature =
-        [
-            (byte)'*',
-            (byte)'*',
-            (byte)'A',
-            (byte)'C',
-            (byte)'E',
-            (byte)'*',
-            (byte)'*',
-        ];
-
-        public AceHeader(IArchiveEncoding archiveEncoding, AceHeaderType type)
+        // Read header CRC (2 bytes) and header size (2 bytes)
+        var headerBytes = new byte[4];
+        if (!stream.ReadFully(headerBytes))
         {
-            AceHeaderType = type;
-            ArchiveEncoding = archiveEncoding;
+            return Array.Empty<byte>();
         }
 
-        public IArchiveEncoding ArchiveEncoding { get; }
-        public AceHeaderType AceHeaderType { get; }
-
-        public ushort HeaderFlags { get; set; }
-        public ushort HeaderCrc { get; set; }
-        public ushort HeaderSize { get; set; }
-        public byte HeaderType { get; set; }
-
-        public bool IsFileEncrypted =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.FILE_ENCRYPTED) != 0;
-        public bool Is64Bit =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MEMORY_64BIT) != 0;
-
-        public bool IsSolid =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.SOLID_MAIN) != 0;
-
-        public bool IsMultiVolume =>
-            (HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.MULTIVOLUME) != 0;
-
-        public abstract AceHeader? Read(Stream reader);
-
-        public byte[] ReadHeader(Stream stream)
+        HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation
+        HeaderSize = BitConverter.ToUInt16(headerBytes, 2);
+        if (HeaderSize == 0)
         {
-            // Read header CRC (2 bytes) and header size (2 bytes)
-            var headerBytes = new byte[4];
-            if (stream.Read(headerBytes, 0, 4) != 4)
-            {
-                return Array.Empty<byte>();
-            }
-
-            HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation
-            HeaderSize = BitConverter.ToUInt16(headerBytes, 2);
-            if (HeaderSize == 0)
-            {
-                return Array.Empty<byte>();
-            }
-
-            // Read the header data
-            var body = new byte[HeaderSize];
-            if (stream.Read(body, 0, HeaderSize) != HeaderSize)
-            {
-                return Array.Empty<byte>();
-            }
-
-            // Verify crc
-            var checksum = AceCrc.AceCrc16(body);
-            if (checksum != HeaderCrc)
-            {
-                throw new InvalidDataException("Header checksum is invalid");
-            }
-            return body;
+            return Array.Empty<byte>();
         }
 
-        public static bool IsArchive(Stream stream)
+        // Read the header data
+        var body = new byte[HeaderSize];
+        if (!stream.ReadFully(body))
         {
-            // ACE files have a specific signature
-            // First two bytes are typically 0x60 0xEA (signature bytes)
-            // At offset 7, there should be "**ACE**" (7 bytes)
-            var bytes = new byte[14];
-            if (stream.Read(bytes, 0, 14) != 14)
+            return Array.Empty<byte>();
+        }
+
+        // Verify crc
+        var checksum = AceCrc.AceCrc16(body);
+        if (checksum != HeaderCrc)
+        {
+            throw new InvalidDataException("Header checksum is invalid");
+        }
+        return body;
+    }
+
+    public static bool IsArchive(Stream stream)
+    {
+        // ACE files have a specific signature
+        // First two bytes are typically 0x60 0xEA (signature bytes)
+        // At offset 7, there should be "**ACE**" (7 bytes)
+        var bytes = new byte[14];
+        if (stream.Read(bytes, 0, 14) != 14)
+        {
+            return false;
+        }
+
+        // Check for "**ACE**" at offset 7
+        return CheckMagicBytes(bytes, 7);
+    }
+
+    protected static bool CheckMagicBytes(byte[] headerBytes, int offset)
+    {
+        // Check for "**ACE**" at specified offset
+        for (int i = 0; i < AceSignature.Length; i++)
+        {
+            if (headerBytes[offset + i] != AceSignature[i])
             {
                 return false;
             }
-
-            // Check for "**ACE**" at offset 7
-            return CheckMagicBytes(bytes, 7);
         }
+        return true;
+    }
 
-        protected static bool CheckMagicBytes(byte[] headerBytes, int offset)
+    protected DateTime ConvertDosDateTime(uint dosDateTime)
+    {
+        try
         {
-            // Check for "**ACE**" at specified offset
-            for (int i = 0; i < AceSignature.Length; i++)
-            {
-                if (headerBytes[offset + i] != AceSignature[i])
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
+            int second = (int)(dosDateTime & 0x1F) * 2;
+            int minute = (int)((dosDateTime >> 5) & 0x3F);
+            int hour = (int)((dosDateTime >> 11) & 0x1F);
+            int day = (int)((dosDateTime >> 16) & 0x1F);
+            int month = (int)((dosDateTime >> 21) & 0x0F);
+            int year = (int)((dosDateTime >> 25) & 0x7F) + 1980;
 
-        protected DateTime ConvertDosDateTime(uint dosDateTime)
-        {
-            try
-            {
-                int second = (int)(dosDateTime & 0x1F) * 2;
-                int minute = (int)((dosDateTime >> 5) & 0x3F);
-                int hour = (int)((dosDateTime >> 11) & 0x1F);
-                int day = (int)((dosDateTime >> 16) & 0x1F);
-                int month = (int)((dosDateTime >> 21) & 0x0F);
-                int year = (int)((dosDateTime >> 25) & 0x7F) + 1980;
-
-                if (
-                    day < 1
-                    || day > 31
-                    || month < 1
-                    || month > 12
-                    || hour > 23
-                    || minute > 59
-                    || second > 59
-                )
-                {
-                    return DateTime.MinValue;
-                }
-
-                return new DateTime(year, month, day, hour, minute, second);
-            }
-            catch
+            if (
+                day < 1
+                || day > 31
+                || month < 1
+                || month > 12
+                || hour > 23
+                || minute > 59
+                || second > 59
+            )
             {
                 return DateTime.MinValue;
             }
+
+            return new DateTime(year, month, day, hour, minute, second);
+        }
+        catch
+        {
+            return DateTime.MinValue;
         }
     }
 }

src/SharpCompress/Common/Ace/Headers/AceMainHeader.Async.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Ace.Headers;
+
+public sealed partial class AceMainHeader
+{
+    /// <summary>
+    /// Asynchronously reads the main archive header from the stream.
+    /// Returns header if this is a valid ACE archive.
+    /// Supports both ACE 1.0 and ACE 2.0 formats.
+    /// </summary>
+    public override async ValueTask<AceHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var headerData = await ReadHeaderAsync(stream, cancellationToken);
+        if (headerData.Length == 0)
+        {
+            return null;
+        }
+        int offset = 0;
+
+        // Header type should be 0 for main header
+        if (headerData[offset++] != HeaderType)
+        {
+            return null;
+        }
+
+        // Header flags (2 bytes)
+        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Skip signature "**ACE**" (7 bytes)
+        if (!CheckMagicBytes(headerData, offset))
+        {
+            throw new InvalidDataException("Invalid ACE archive signature.");
+        }
+        offset += 7;
+
+        // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0
+        AceVersion = headerData[offset++];
+        ExtractVersion = headerData[offset++];
+
+        // Host OS (1 byte)
+        if (offset < headerData.Length)
+        {
+            var hostOsByte = headerData[offset++];
+            HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
+        }
+        // Volume number (1 byte)
+        VolumeNumber = headerData[offset++];
+
+        // Creation date/time (4 bytes)
+        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
+        DateTime = ConvertDosDateTime(dosDateTime);
+        offset += 4;
+
+        // Reserved fields (8 bytes)
+        if (offset + 8 <= headerData.Length)
+        {
+            offset += 8;
+        }
+
+        // Skip additional fields based on flags
+        // Handle comment if present
+        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
+        {
+            if (offset + 2 <= headerData.Length)
+            {
+                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
+                offset += 2 + commentLength;
+            }
+        }
+
+        return this;
+    }
+}

src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs

@@ -2,96 +2,99 @@ using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Ace.Headers;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Crypto;
 
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// ACE main archive header
+/// </summary>
+public sealed partial class AceMainHeader : AceHeader
 {
+    public byte ExtractVersion { get; set; }
+    public byte CreatorVersion { get; set; }
+    public HostOS HostOS { get; set; }
+    public byte VolumeNumber { get; set; }
+    public DateTime DateTime { get; set; }
+    public string Advert { get; set; } = string.Empty;
+    public List<byte> Comment { get; set; } = new();
+    public byte AceVersion { get; private set; }
+
+    public AceMainHeader(IArchiveEncoding archiveEncoding)
+        : base(archiveEncoding, AceHeaderType.MAIN) { }
+
     /// <summary>
-    /// ACE main archive header
+    /// Reads the main archive header from the stream.
+    /// Returns header if this is a valid ACE archive.
+    /// Supports both ACE 1.0 and ACE 2.0 formats.
     /// </summary>
-    public sealed class AceMainHeader : AceHeader
+    public override AceHeader? Read(Stream stream)
     {
-        public byte ExtractVersion { get; set; }
-        public byte CreatorVersion { get; set; }
-        public HostOS HostOS { get; set; }
-        public byte VolumeNumber { get; set; }
-        public DateTime DateTime { get; set; }
-        public string Advert { get; set; } = string.Empty;
-        public List<byte> Comment { get; set; } = new();
-        public byte AceVersion { get; private set; }
-
-        public AceMainHeader(IArchiveEncoding archiveEncoding)
-            : base(archiveEncoding, AceHeaderType.MAIN) { }
-
-        /// <summary>
-        /// Reads the main archive header from the stream.
-        /// Returns header if this is a valid ACE archive.
-        /// Supports both ACE 1.0 and ACE 2.0 formats.
-        /// </summary>
-        public override AceHeader? Read(Stream stream)
+        var headerData = ReadHeader(stream);
+        if (headerData.Length == 0)
         {
-            var headerData = ReadHeader(stream);
-            if (headerData.Length == 0)
-            {
-                return null;
-            }
-            int offset = 0;
-
-            // Header type should be 0 for main header
-            if (headerData[offset++] != HeaderType)
-            {
-                return null;
-            }
-
-            // Header flags (2 bytes)
-            HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Skip signature "**ACE**" (7 bytes)
-            if (!CheckMagicBytes(headerData, offset))
-            {
-                throw new InvalidDataException("Invalid ACE archive signature.");
-            }
-            offset += 7;
-
-            // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0
-            AceVersion = headerData[offset++];
-            ExtractVersion = headerData[offset++];
-
-            // Host OS (1 byte)
-            if (offset < headerData.Length)
-            {
-                var hostOsByte = headerData[offset++];
-                HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
-            }
-            // Volume number (1 byte)
-            VolumeNumber = headerData[offset++];
-
-            // Creation date/time (4 bytes)
-            var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-            DateTime = ConvertDosDateTime(dosDateTime);
-            offset += 4;
-
-            // Reserved fields (8 bytes)
-            if (offset + 8 <= headerData.Length)
-            {
-                offset += 8;
-            }
-
-            // Skip additional fields based on flags
-            // Handle comment if present
-            if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-            {
-                if (offset + 2 <= headerData.Length)
-                {
-                    ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                    offset += 2 + commentLength;
-                }
-            }
-
-            return this;
+            return null;
         }
+        int offset = 0;
+
+        // Header type should be 0 for main header
+        if (headerData[offset++] != HeaderType)
+        {
+            return null;
+        }
+
+        // Header flags (2 bytes)
+        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Skip signature "**ACE**" (7 bytes)
+        if (!CheckMagicBytes(headerData, offset))
+        {
+            throw new InvalidDataException("Invalid ACE archive signature.");
+        }
+        offset += 7;
+
+        // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0
+        AceVersion = headerData[offset++];
+        ExtractVersion = headerData[offset++];
+
+        // Host OS (1 byte)
+        if (offset < headerData.Length)
+        {
+            var hostOsByte = headerData[offset++];
+            HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
+        }
+        // Volume number (1 byte)
+        VolumeNumber = headerData[offset++];
+
+        // Creation date/time (4 bytes)
+        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
+        DateTime = ConvertDosDateTime(dosDateTime);
+        offset += 4;
+
+        // Reserved fields (8 bytes)
+        if (offset + 8 <= headerData.Length)
+        {
+            offset += 8;
+        }
+
+        // Skip additional fields based on flags
+        // Handle comment if present
+        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
+        {
+            if (offset + 2 <= headerData.Length)
+            {
+                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
+                offset += 2 + commentLength;
+            }
+        }
+
+        return this;
     }
+
+    // ReadAsync moved to AceMainHeader.Async.cs
 }

src/SharpCompress/Common/Ace/Headers/CompressionQuality.cs

@@ -1,16 +1,15 @@
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// Compression quality
+/// </summary>
+public enum CompressionQuality
 {
-    /// <summary>
-    /// Compression quality
-    /// </summary>
-    public enum CompressionQuality
-    {
-        None,
-        Fastest,
-        Fast,
-        Normal,
-        Good,
-        Best,
-        Unknown,
-    }
+    None,
+    Fastest,
+    Fast,
+    Normal,
+    Good,
+    Best,
+    Unknown,
 }

src/SharpCompress/Common/Ace/Headers/CompressionType.cs

@@ -1,13 +1,12 @@
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// Compression types
+/// </summary>
+public enum CompressionType
 {
-    /// <summary>
-    /// Compression types
-    /// </summary>
-    public enum CompressionType
-    {
-        Stored,
-        Lz77,
-        Blocked,
-        Unknown,
-    }
+    Stored,
+    Lz77,
+    Blocked,
+    Unknown,
 }

src/SharpCompress/Common/Ace/Headers/HeaderFlags.cs

@@ -1,33 +1,32 @@
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// Header flags (main + file, overlapping meanings)
+/// </summary>
+public static class HeaderFlags
 {
-    /// <summary>
-    /// Header flags (main + file, overlapping meanings)
-    /// </summary>
-    public static class HeaderFlags
-    {
-        // Shared / low bits
-        public const ushort ADDSIZE = 0x0001; // extra size field present
-        public const ushort COMMENT = 0x0002; // comment present
-        public const ushort MEMORY_64BIT = 0x0004;
-        public const ushort AV_STRING = 0x0008; // AV string present
-        public const ushort SOLID = 0x0010; // solid file
-        public const ushort LOCKED = 0x0020;
-        public const ushort PROTECTED = 0x0040;
+    // Shared / low bits
+    public const ushort ADDSIZE = 0x0001; // extra size field present
+    public const ushort COMMENT = 0x0002; // comment present
+    public const ushort MEMORY_64BIT = 0x0004;
+    public const ushort AV_STRING = 0x0008; // AV string present
+    public const ushort SOLID = 0x0010; // solid file
+    public const ushort LOCKED = 0x0020;
+    public const ushort PROTECTED = 0x0040;
 
-        // Main header specific
-        public const ushort V20FORMAT = 0x0100;
-        public const ushort SFX = 0x0200;
-        public const ushort LIMITSFXJR = 0x0400;
-        public const ushort MULTIVOLUME = 0x0800;
-        public const ushort ADVERT = 0x1000;
-        public const ushort RECOVERY = 0x2000;
-        public const ushort LOCKED_MAIN = 0x4000;
-        public const ushort SOLID_MAIN = 0x8000;
+    // Main header specific
+    public const ushort V20FORMAT = 0x0100;
+    public const ushort SFX = 0x0200;
+    public const ushort LIMITSFXJR = 0x0400;
+    public const ushort MULTIVOLUME = 0x0800;
+    public const ushort ADVERT = 0x1000;
+    public const ushort RECOVERY = 0x2000;
+    public const ushort LOCKED_MAIN = 0x4000;
+    public const ushort SOLID_MAIN = 0x8000;
 
-        // File header specific (same bits, different meaning)
-        public const ushort NTSECURITY = 0x0400;
-        public const ushort CONTINUED_PREV = 0x1000;
-        public const ushort CONTINUED_NEXT = 0x2000;
-        public const ushort FILE_ENCRYPTED = 0x4000; // file encrypted (file header)
-    }
+    // File header specific (same bits, different meaning)
+    public const ushort NTSECURITY = 0x0400;
+    public const ushort CONTINUED_PREV = 0x1000;
+    public const ushort CONTINUED_NEXT = 0x2000;
+    public const ushort FILE_ENCRYPTED = 0x4000; // file encrypted (file header)
 }

src/SharpCompress/Common/Ace/Headers/HostOS.cs

@@ -1,22 +1,21 @@
-namespace SharpCompress.Common.Ace.Headers
+namespace SharpCompress.Common.Ace.Headers;
+
+/// <summary>
+/// Host OS type
+/// </summary>
+public enum HostOS
 {
-    /// <summary>
-    /// Host OS type
-    /// </summary>
-    public enum HostOS
-    {
-        MsDos = 0,
-        Os2,
-        Windows,
-        Unix,
-        MacOs,
-        WinNt,
-        Primos,
-        AppleGs,
-        Atari,
-        Vax,
-        Amiga,
-        Next,
-        Unknown,
-    }
+    MsDos = 0,
+    Os2,
+    Windows,
+    Unix,
+    MacOs,
+    WinNt,
+    Primos,
+    AppleGs,
+    Atari,
+    Vax,
+    Amiga,
+    Next,
+    Unknown,
 }

src/SharpCompress/Common/Arc/ArcEntry.cs

@@ -7,54 +7,53 @@ using System.Threading.Tasks;
 using SharpCompress.Common.GZip;
 using SharpCompress.Common.Tar;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcEntry : Entry
 {
-    public class ArcEntry : Entry
+    private readonly ArcFilePart? _filePart;
+
+    internal ArcEntry(ArcFilePart? filePart)
     {
-        private readonly ArcFilePart? _filePart;
-
-        internal ArcEntry(ArcFilePart? filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override long Crc
-        {
-            get
-            {
-                if (_filePart == null)
-                {
-                    return 0;
-                }
-                return _filePart.Header.Crc16;
-            }
-        }
-
-        public override string? Key => _filePart?.Header.Name;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
-
-        public override CompressionType CompressionType =>
-            _filePart?.Header.CompressionMethod ?? CompressionType.Unknown;
-
-        public override long Size => throw new NotImplementedException();
-
-        public override DateTime? LastModifiedTime => null;
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => false;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+        _filePart = filePart;
     }
+
+    public override long Crc
+    {
+        get
+        {
+            if (_filePart == null)
+            {
+                return 0;
+            }
+            return _filePart.Header.Crc16;
+        }
+    }
+
+    public override string? Key => _filePart?.Header.Name;
+
+    public override string? LinkTarget => null;
+
+    public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
+
+    public override CompressionType CompressionType =>
+        _filePart?.Header.CompressionMethod ?? CompressionType.Unknown;
+
+    public override long Size => throw new NotImplementedException();
+
+    public override DateTime? LastModifiedTime => null;
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => false;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 }

src/SharpCompress/Common/Arc/ArcEntryHeader.cs

@@ -2,75 +2,93 @@ using System;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcEntryHeader
 {
-    public class ArcEntryHeader
+    public IArchiveEncoding ArchiveEncoding { get; }
+    public CompressionType CompressionMethod { get; private set; }
+    public string? Name { get; private set; }
+    public long CompressedSize { get; private set; }
+    public DateTime DateTime { get; private set; }
+    public int Crc16 { get; private set; }
+    public long OriginalSize { get; private set; }
+    public long DataStartPosition { get; private set; }
+
+    public ArcEntryHeader(IArchiveEncoding archiveEncoding)
     {
-        public IArchiveEncoding ArchiveEncoding { get; }
-        public CompressionType CompressionMethod { get; private set; }
-        public string? Name { get; private set; }
-        public long CompressedSize { get; private set; }
-        public DateTime DateTime { get; private set; }
-        public int Crc16 { get; private set; }
-        public long OriginalSize { get; private set; }
-        public long DataStartPosition { get; private set; }
+        this.ArchiveEncoding = archiveEncoding;
+    }
 
-        public ArcEntryHeader(IArchiveEncoding archiveEncoding)
+    public ArcEntryHeader? ReadHeader(Stream stream)
+    {
+        byte[] headerBytes = new byte[29];
+        if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
         {
-            this.ArchiveEncoding = archiveEncoding;
+            return null;
         }
+        DataStartPosition = stream.Position;
+        return LoadFrom(headerBytes);
+    }
 
-        public ArcEntryHeader? ReadHeader(Stream stream)
+    public async ValueTask<ArcEntryHeader?> ReadHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        byte[] headerBytes = new byte[29];
+        if (
+            await stream.ReadAsync(headerBytes, 0, headerBytes.Length, cancellationToken)
+            != headerBytes.Length
+        )
         {
-            byte[] headerBytes = new byte[29];
-            if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
-            {
-                return null;
-            }
-            DataStartPosition = stream.Position;
-            return LoadFrom(headerBytes);
+            return null;
         }
+        DataStartPosition = stream.Position;
+        return LoadFrom(headerBytes);
+    }
 
-        public ArcEntryHeader LoadFrom(byte[] headerBytes)
+    public ArcEntryHeader LoadFrom(byte[] headerBytes)
+    {
+        CompressionMethod = GetCompressionType(headerBytes[1]);
+
+        // Read name
+        int nameEnd = Array.IndexOf(headerBytes, (byte)0, 1); // Find null terminator
+        Name = Encoding.UTF8.GetString(headerBytes, 2, nameEnd > 0 ? nameEnd - 2 : 12);
+
+        int offset = 15;
+        CompressedSize = BitConverter.ToUInt32(headerBytes, offset);
+        offset += 4;
+        uint rawDateTime = BitConverter.ToUInt32(headerBytes, offset);
+        DateTime = ConvertToDateTime(rawDateTime);
+        offset += 4;
+        Crc16 = BitConverter.ToUInt16(headerBytes, offset);
+        offset += 2;
+        OriginalSize = BitConverter.ToUInt32(headerBytes, offset);
+        return this;
+    }
+
+    private CompressionType GetCompressionType(byte value)
+    {
+        return value switch
         {
-            CompressionMethod = GetCompressionType(headerBytes[1]);
+            1 or 2 => CompressionType.None,
+            3 => CompressionType.Packed,
+            4 => CompressionType.Squeezed,
+            5 or 6 or 7 or 8 => CompressionType.Crunched,
+            9 => CompressionType.Squashed,
+            10 => CompressionType.Crushed,
+            11 => CompressionType.Distilled,
+            _ => CompressionType.Unknown,
+        };
+    }
 
-            // Read name
-            int nameEnd = Array.IndexOf(headerBytes, (byte)0, 1); // Find null terminator
-            Name = Encoding.UTF8.GetString(headerBytes, 2, nameEnd > 0 ? nameEnd - 2 : 12);
-
-            int offset = 15;
-            CompressedSize = BitConverter.ToUInt32(headerBytes, offset);
-            offset += 4;
-            uint rawDateTime = BitConverter.ToUInt32(headerBytes, offset);
-            DateTime = ConvertToDateTime(rawDateTime);
-            offset += 4;
-            Crc16 = BitConverter.ToUInt16(headerBytes, offset);
-            offset += 2;
-            OriginalSize = BitConverter.ToUInt32(headerBytes, offset);
-            return this;
-        }
-
-        private CompressionType GetCompressionType(byte value)
-        {
-            return value switch
-            {
-                1 or 2 => CompressionType.None,
-                3 => CompressionType.Packed,
-                4 => CompressionType.Squeezed,
-                5 or 6 or 7 or 8 => CompressionType.Crunched,
-                9 => CompressionType.Squashed,
-                10 => CompressionType.Crushed,
-                11 => CompressionType.Distilled,
-                _ => CompressionType.Unknown,
-            };
-        }
-
-        public static DateTime ConvertToDateTime(long rawDateTime)
-        {
-            // Convert Unix timestamp to DateTime (UTC)
-            return DateTimeOffset.FromUnixTimeSeconds(rawDateTime).UtcDateTime;
-        }
+    public static DateTime ConvertToDateTime(long rawDateTime)
+    {
+        // Convert Unix timestamp to DateTime (UTC)
+        return DateTimeOffset.FromUnixTimeSeconds(rawDateTime).UtcDateTime;
     }
 }

src/SharpCompress/Common/Arc/ArcFilePart.Async.cs

@@ -0,0 +1,58 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.Lzw;
+using SharpCompress.Compressors.RLE90;
+using SharpCompress.Compressors.Squeezed;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Arc;
+
+public partial class ArcFilePart
+{
+    internal override async ValueTask<Stream?> GetCompressedStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_stream != null)
+        {
+            Stream compressedStream;
+            switch (Header.CompressionMethod)
+            {
+                case CompressionType.None:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.CompressedSize
+                    );
+                    break;
+                case CompressionType.Packed:
+                    compressedStream = new RunLength90Stream(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Squeezed:
+                    compressedStream = await SqueezeStream.CreateAsync(
+                        _stream,
+                        (int)Header.CompressedSize,
+                        cancellationToken
+                    );
+                    break;
+                case CompressionType.Crunched:
+                    if (Header.OriginalSize > 128 * 1024)
+                    {
+                        throw new NotSupportedException(
+                            "CompressionMethod: " + Header.CompressionMethod + " with size > 128KB"
+                        );
+                    }
+                    compressedStream = new ArcLzwStream(_stream, (int)Header.CompressedSize, true);
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionMethod
+                    );
+            }
+            return compressedStream;
+        }
+        return _stream;
+    }
+}

src/SharpCompress/Common/Arc/ArcFilePart.cs

@@ -13,71 +13,61 @@ using SharpCompress.Compressors.RLE90;
 using SharpCompress.Compressors.Squeezed;
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public partial class ArcFilePart : FilePart
 {
-    public class ArcFilePart : FilePart
+    private readonly Stream? _stream;
+
+    internal ArcFilePart(ArcEntryHeader localArcHeader, Stream? seekableStream)
+        : base(localArcHeader.ArchiveEncoding)
     {
-        private readonly Stream? _stream;
-
-        internal ArcFilePart(ArcEntryHeader localArcHeader, Stream? seekableStream)
-            : base(localArcHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localArcHeader;
-        }
-
-        internal ArcEntryHeader Header { get; set; }
-
-        internal override string? FilePartName => Header.Name;
-
-        internal override Stream GetCompressedStream()
-        {
-            if (_stream != null)
-            {
-                Stream compressedStream;
-                switch (Header.CompressionMethod)
-                {
-                    case CompressionType.None:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.CompressedSize
-                        );
-                        break;
-                    case CompressionType.Packed:
-                        compressedStream = new RunLength90Stream(
-                            _stream,
-                            (int)Header.CompressedSize
-                        );
-                        break;
-                    case CompressionType.Squeezed:
-                        compressedStream = new SqueezeStream(_stream, (int)Header.CompressedSize);
-                        break;
-                    case CompressionType.Crunched:
-                        if (Header.OriginalSize > 128 * 1024)
-                        {
-                            throw new NotSupportedException(
-                                "CompressionMethod: "
-                                    + Header.CompressionMethod
-                                    + " with size > 128KB"
-                            );
-                        }
-                        compressedStream = new ArcLzwStream(
-                            _stream,
-                            (int)Header.CompressedSize,
-                            true
-                        );
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionMethod
-                        );
-                }
-                return compressedStream;
-            }
-            return _stream.NotNull();
-        }
-
-        internal override Stream? GetRawStream() => _stream;
+        _stream = seekableStream;
+        Header = localArcHeader;
     }
+
+    internal ArcEntryHeader Header { get; set; }
+
+    internal override string? FilePartName => Header.Name;
+
+    internal override Stream GetCompressedStream()
+    {
+        if (_stream != null)
+        {
+            Stream compressedStream;
+            switch (Header.CompressionMethod)
+            {
+                case CompressionType.None:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.CompressedSize
+                    );
+                    break;
+                case CompressionType.Packed:
+                    compressedStream = new RunLength90Stream(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Squeezed:
+                    compressedStream = SqueezeStream.Create(_stream, (int)Header.CompressedSize);
+                    break;
+                case CompressionType.Crunched:
+                    if (Header.OriginalSize > 128 * 1024)
+                    {
+                        throw new NotSupportedException(
+                            "CompressionMethod: " + Header.CompressionMethod + " with size > 128KB"
+                        );
+                    }
+                    compressedStream = new ArcLzwStream(_stream, (int)Header.CompressedSize, true);
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionMethod
+                    );
+            }
+            return compressedStream;
+        }
+        return _stream.NotNull();
+    }
+
+    internal override Stream? GetRawStream() => _stream;
 }

src/SharpCompress/Common/Arc/ArcVolume.cs

@@ -6,11 +6,10 @@ using System.Text;
 using System.Threading.Tasks;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common.Arc
+namespace SharpCompress.Common.Arc;
+
+public class ArcVolume : Volume
 {
-    public class ArcVolume : Volume
-    {
-        public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
-    }
+    public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+        : base(stream, readerOptions, index) { }
 }

src/SharpCompress/Common/Arj/ArjEntry.cs

@@ -6,53 +6,52 @@ using System.Threading.Tasks;
 using SharpCompress.Common.Arc;
 using SharpCompress.Common.Arj.Headers;
 
-namespace SharpCompress.Common.Arj
+namespace SharpCompress.Common.Arj;
+
+public class ArjEntry : Entry
 {
-    public class ArjEntry : Entry
+    private readonly ArjFilePart _filePart;
+
+    internal ArjEntry(ArjFilePart filePart)
     {
-        private readonly ArjFilePart _filePart;
-
-        internal ArjEntry(ArjFilePart filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override long Crc => _filePart.Header.OriginalCrc32;
-
-        public override string? Key => _filePart?.Header.Name;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
-
-        public override CompressionType CompressionType
-        {
-            get
-            {
-                if (_filePart.Header.CompressionMethod == CompressionMethod.Stored)
-                {
-                    return CompressionType.None;
-                }
-                return CompressionType.ArjLZ77;
-            }
-        }
-
-        public override long Size => _filePart?.Header.OriginalSize ?? 0;
-
-        public override DateTime? LastModifiedTime => _filePart.Header.DateTimeModified.DateTime;
-
-        public override DateTime? CreatedTime => _filePart.Header.DateTimeCreated.DateTime;
-
-        public override DateTime? LastAccessedTime => _filePart.Header.DateTimeAccessed.DateTime;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => _filePart.Header.FileType == FileType.Directory;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+        _filePart = filePart;
     }
+
+    public override long Crc => _filePart.Header.OriginalCrc32;
+
+    public override string? Key => _filePart?.Header.Name;
+
+    public override string? LinkTarget => null;
+
+    public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
+
+    public override CompressionType CompressionType
+    {
+        get
+        {
+            if (_filePart.Header.CompressionMethod == CompressionMethod.Stored)
+            {
+                return CompressionType.None;
+            }
+            return CompressionType.ArjLZ77;
+        }
+    }
+
+    public override long Size => _filePart?.Header.OriginalSize ?? 0;
+
+    public override DateTime? LastModifiedTime => _filePart.Header.DateTimeModified.DateTime;
+
+    public override DateTime? CreatedTime => _filePart.Header.DateTimeCreated.DateTime;
+
+    public override DateTime? LastAccessedTime => _filePart.Header.DateTimeAccessed.DateTime;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => _filePart.Header.FileType == FileType.Directory;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 }

src/SharpCompress/Common/Arj/ArjFilePart.cs

@@ -8,65 +8,62 @@ using SharpCompress.Common.Arj.Headers;
 using SharpCompress.Compressors.Arj;
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Arj
+namespace SharpCompress.Common.Arj;
+
+public class ArjFilePart : FilePart
 {
-    public class ArjFilePart : FilePart
+    private readonly Stream _stream;
+    internal ArjLocalHeader Header { get; set; }
+
+    internal ArjFilePart(ArjLocalHeader localArjHeader, Stream seekableStream)
+        : base(localArjHeader.ArchiveEncoding)
     {
-        private readonly Stream _stream;
-        internal ArjLocalHeader Header { get; set; }
-
-        internal ArjFilePart(ArjLocalHeader localArjHeader, Stream seekableStream)
-            : base(localArjHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localArjHeader;
-        }
-
-        internal override string? FilePartName => Header.Name;
-
-        internal override Stream GetCompressedStream()
-        {
-            if (_stream != null)
-            {
-                Stream compressedStream;
-                switch (Header.CompressionMethod)
-                {
-                    case CompressionMethod.Stored:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.CompressedSize
-                        );
-                        break;
-                    case CompressionMethod.CompressedMost:
-                    case CompressionMethod.Compressed:
-                    case CompressionMethod.CompressedFaster:
-                        if (Header.OriginalSize > 128 * 1024)
-                        {
-                            throw new NotSupportedException(
-                                "CompressionMethod: "
-                                    + Header.CompressionMethod
-                                    + " with size > 128KB"
-                            );
-                        }
-                        compressedStream = new LhaStream<Lh7DecoderCfg>(
-                            _stream,
-                            (int)Header.OriginalSize
-                        );
-                        break;
-                    case CompressionMethod.CompressedFastest:
-                        compressedStream = new LHDecoderStream(_stream, (int)Header.OriginalSize);
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionMethod
-                        );
-                }
-                return compressedStream;
-            }
-            return _stream.NotNull();
-        }
-
-        internal override Stream GetRawStream() => _stream;
+        _stream = seekableStream;
+        Header = localArjHeader;
     }
+
+    internal override string? FilePartName => Header.Name;
+
+    internal override Stream GetCompressedStream()
+    {
+        if (_stream != null)
+        {
+            Stream compressedStream;
+            switch (Header.CompressionMethod)
+            {
+                case CompressionMethod.Stored:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.CompressedSize
+                    );
+                    break;
+                case CompressionMethod.CompressedMost:
+                case CompressionMethod.Compressed:
+                case CompressionMethod.CompressedFaster:
+                    if (Header.OriginalSize > 128 * 1024)
+                    {
+                        throw new NotSupportedException(
+                            "CompressionMethod: " + Header.CompressionMethod + " with size > 128KB"
+                        );
+                    }
+                    compressedStream = new LhaStream<Lh7DecoderCfg>(
+                        _stream,
+                        (int)Header.OriginalSize
+                    );
+                    break;
+                case CompressionMethod.CompressedFastest:
+                    compressedStream = new LHDecoderStream(_stream, (int)Header.OriginalSize);
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionMethod
+                    );
+            }
+            return compressedStream;
+        }
+        return _stream.NotNull();
+    }
+
+    internal override Stream GetRawStream() => _stream;
 }

src/SharpCompress/Common/Arj/ArjVolume.cs

@@ -8,29 +8,28 @@ using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common.Arj
+namespace SharpCompress.Common.Arj;
+
+public class ArjVolume : Volume
 {
-    public class ArjVolume : Volume
+    public ArjVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+        : base(stream, readerOptions, index) { }
+
+    public override bool IsFirstVolume
     {
-        public ArjVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
+        get { return true; }
+    }
 
-        public override bool IsFirstVolume
-        {
-            get { return true; }
-        }
+    /// <summary>
+    /// ArjArchive is part of a multi-part archive.
+    /// </summary>
+    public override bool IsMultiVolume
+    {
+        get { return false; }
+    }
 
-        /// <summary>
-        /// ArjArchive is part of a multi-part archive.
-        /// </summary>
-        public override bool IsMultiVolume
-        {
-            get { return false; }
-        }
-
-        internal IEnumerable<ArjFilePart> GetVolumeFileParts()
-        {
-            return new List<ArjFilePart>();
-        }
+    internal IEnumerable<ArjFilePart> GetVolumeFileParts()
+    {
+        return new List<ArjFilePart>();
     }
 }

src/SharpCompress/Common/Arj/Headers/ArjHeader.Async.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Arj.Headers;
+
+public abstract partial class ArjHeader
+{
+    public abstract ValueTask<ArjHeader?> ReadAsync(
+        Stream reader,
+        CancellationToken cancellationToken = default
+    );
+
+    public async ValueTask<byte[]> ReadHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // check for magic bytes
+        var magic = new byte[2];
+        if (await stream.ReadAsync(magic, 0, 2, cancellationToken) != 2)
+        {
+            return Array.Empty<byte>();
+        }
+
+        if (!CheckMagicBytes(magic))
+        {
+            throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
+        }
+
+        // read header_size
+        byte[] headerBytes = new byte[2];
+        await stream.ReadAsync(headerBytes, 0, 2, cancellationToken);
+        var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
+        if (headerSize < 1)
+        {
+            return Array.Empty<byte>();
+        }
+
+        var body = new byte[headerSize];
+        var read = await stream.ReadAsync(body, 0, headerSize, cancellationToken);
+        if (read < headerSize)
+        {
+            return Array.Empty<byte>();
+        }
+
+        byte[] crc = new byte[4];
+        read = await stream.ReadAsync(crc, 0, 4, cancellationToken);
+        var checksum = Crc32Stream.Compute(body);
+        // Compute the hash value
+        if (checksum != BitConverter.ToUInt32(crc, 0))
+        {
+            throw new InvalidDataException("Header checksum is invalid");
+        }
+        return body;
+    }
+
+    protected async ValueTask<List<byte[]>> ReadExtendedHeadersAsync(
+        Stream reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        List<byte[]> extendedHeader = new List<byte[]>();
+        byte[] buffer = new byte[2];
+
+        while (true)
+        {
+            int bytesRead = await reader.ReadAsync(buffer, 0, 2, cancellationToken);
+            if (bytesRead < 2)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header size."
+                );
+            }
+
+            var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
+            if (extHeaderSize == 0)
+            {
+                return extendedHeader;
+            }
+
+            byte[] header = new byte[extHeaderSize];
+            bytesRead = await reader.ReadAsync(header, 0, extHeaderSize, cancellationToken);
+            if (bytesRead < extHeaderSize)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header data."
+                );
+            }
+
+            byte[] crcextended = new byte[4];
+            bytesRead = await reader.ReadAsync(crcextended, 0, 4, cancellationToken);
+            if (bytesRead < 4)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header CRC."
+                );
+            }
+
+            var checksum = Crc32Stream.Compute(header);
+            if (checksum != BitConverter.ToUInt32(crcextended, 0))
+            {
+                throw new InvalidDataException("Extended header checksum is invalid");
+            }
+
+            extendedHeader.Add(header);
+        }
+    }
+
+    /// <summary>
+    /// Asynchronously checks if the stream is an ARJ archive
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>True if the stream is an ARJ archive, false otherwise</returns>
+    public static async ValueTask<bool> IsArchiveAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var bytes = new byte[2];
+        if (await stream.ReadAsync(bytes, 0, 2, cancellationToken) != 2)
+        {
+            return false;
+        }
+
+        return CheckMagicBytes(bytes);
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjHeader.cs

@@ -3,156 +3,158 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Crypto;
 
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public enum ArjHeaderType
 {
-    public enum ArjHeaderType
+    MainHeader,
+    LocalHeader,
+}
+
+public abstract partial class ArjHeader
+{
+    private const int FIRST_HDR_SIZE = 34;
+    private const ushort ARJ_MAGIC = 0xEA60;
+
+    public ArjHeader(ArjHeaderType type)
     {
-        MainHeader,
-        LocalHeader,
+        ArjHeaderType = type;
     }
 
-    public abstract class ArjHeader
-    {
-        private const int FIRST_HDR_SIZE = 34;
-        private const ushort ARJ_MAGIC = 0xEA60;
+    public ArjHeaderType ArjHeaderType { get; }
+    public byte Flags { get; set; }
+    public FileType FileType { get; set; }
 
-        public ArjHeader(ArjHeaderType type)
+    public abstract ArjHeader? Read(Stream reader);
+
+    // Async methods moved to ArjHeader.Async.cs
+
+    public byte[] ReadHeader(Stream stream)
+    {
+        // check for magic bytes
+        var magic = new byte[2];
+        if (stream.Read(magic) != 2)
         {
-            ArjHeaderType = type;
+            return Array.Empty<byte>();
         }
 
-        public ArjHeaderType ArjHeaderType { get; }
-        public byte Flags { get; set; }
-        public FileType FileType { get; set; }
-
-        public abstract ArjHeader? Read(Stream reader);
-
-        public byte[] ReadHeader(Stream stream)
+        if (!CheckMagicBytes(magic))
         {
-            // check for magic bytes
-            var magic = new byte[2];
-            if (stream.Read(magic) != 2)
+            throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
+        }
+
+        // read header_size
+        byte[] headerBytes = new byte[2];
+        stream.Read(headerBytes, 0, 2);
+        var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
+        if (headerSize < 1)
+        {
+            return Array.Empty<byte>();
+        }
+
+        var body = new byte[headerSize];
+        var read = stream.Read(body, 0, headerSize);
+        if (read < headerSize)
+        {
+            return Array.Empty<byte>();
+        }
+
+        byte[] crc = new byte[4];
+        read = stream.Read(crc, 0, 4);
+        var checksum = Crc32Stream.Compute(body);
+        // Compute the hash value
+        if (checksum != BitConverter.ToUInt32(crc, 0))
+        {
+            throw new InvalidDataException("Header checksum is invalid");
+        }
+        return body;
+    }
+
+    // ReadHeaderAsync moved to ArjHeader.Async.cs
+
+    protected List<byte[]> ReadExtendedHeaders(Stream reader)
+    {
+        List<byte[]> extendedHeader = new List<byte[]>();
+        byte[] buffer = new byte[2];
+
+        while (true)
+        {
+            int bytesRead = reader.Read(buffer, 0, 2);
+            if (bytesRead < 2)
             {
-                return Array.Empty<byte>();
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header size."
+                );
             }
 
-            if (!CheckMagicBytes(magic))
+            var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
+            if (extHeaderSize == 0)
             {
-                throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
+                return extendedHeader;
             }
 
-            // read header_size
-            byte[] headerBytes = new byte[2];
-            stream.Read(headerBytes, 0, 2);
-            var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
-            if (headerSize < 1)
+            byte[] header = new byte[extHeaderSize];
+            bytesRead = reader.Read(header, 0, extHeaderSize);
+            if (bytesRead < extHeaderSize)
             {
-                return Array.Empty<byte>();
-            }
-
-            var body = new byte[headerSize];
-            var read = stream.Read(body, 0, headerSize);
-            if (read < headerSize)
-            {
-                return Array.Empty<byte>();
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header data."
+                );
             }
 
             byte[] crc = new byte[4];
-            read = stream.Read(crc, 0, 4);
-            var checksum = Crc32Stream.Compute(body);
-            // Compute the hash value
+            bytesRead = reader.Read(crc, 0, 4);
+            if (bytesRead < 4)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header CRC."
+                );
+            }
+
+            var checksum = Crc32Stream.Compute(header);
             if (checksum != BitConverter.ToUInt32(crc, 0))
             {
-                throw new InvalidDataException("Header checksum is invalid");
-            }
-            return body;
-        }
-
-        protected List<byte[]> ReadExtendedHeaders(Stream reader)
-        {
-            List<byte[]> extendedHeader = new List<byte[]>();
-            byte[] buffer = new byte[2];
-
-            while (true)
-            {
-                int bytesRead = reader.Read(buffer, 0, 2);
-                if (bytesRead < 2)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header size."
-                    );
-                }
-
-                var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
-                if (extHeaderSize == 0)
-                {
-                    return extendedHeader;
-                }
-
-                byte[] header = new byte[extHeaderSize];
-                bytesRead = reader.Read(header, 0, extHeaderSize);
-                if (bytesRead < extHeaderSize)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header data."
-                    );
-                }
-
-                byte[] crc = new byte[4];
-                bytesRead = reader.Read(crc, 0, 4);
-                if (bytesRead < 4)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header CRC."
-                    );
-                }
-
-                var checksum = Crc32Stream.Compute(header);
-                if (checksum != BitConverter.ToUInt32(crc, 0))
-                {
-                    throw new InvalidDataException("Extended header checksum is invalid");
-                }
-
-                extendedHeader.Add(header);
-            }
-        }
-
-        // Flag helpers
-        public bool IsGabled => (Flags & 0x01) != 0;
-        public bool IsAnsiPage => (Flags & 0x02) != 0;
-        public bool IsVolume => (Flags & 0x04) != 0;
-        public bool IsArjProtected => (Flags & 0x08) != 0;
-        public bool IsPathSym => (Flags & 0x10) != 0;
-        public bool IsBackup => (Flags & 0x20) != 0;
-        public bool IsSecured => (Flags & 0x40) != 0;
-        public bool IsAltName => (Flags & 0x80) != 0;
-
-        public static FileType FileTypeFromByte(byte value)
-        {
-            return Enum.IsDefined(typeof(FileType), value)
-                ? (FileType)value
-                : Headers.FileType.Unknown;
-        }
-
-        public static bool IsArchive(Stream stream)
-        {
-            var bytes = new byte[2];
-            if (stream.Read(bytes, 0, 2) != 2)
-            {
-                return false;
+                throw new InvalidDataException("Extended header checksum is invalid");
             }
 
-            return CheckMagicBytes(bytes);
-        }
-
-        protected static bool CheckMagicBytes(byte[] headerBytes)
-        {
-            var magicValue = (ushort)(headerBytes[0] | headerBytes[1] << 8);
-            return magicValue == ARJ_MAGIC;
+            extendedHeader.Add(header);
         }
     }
+
+    // Flag helpers
+    public bool IsGabled => (Flags & 0x01) != 0;
+    public bool IsAnsiPage => (Flags & 0x02) != 0;
+    public bool IsVolume => (Flags & 0x04) != 0;
+    public bool IsArjProtected => (Flags & 0x08) != 0;
+    public bool IsPathSym => (Flags & 0x10) != 0;
+    public bool IsBackup => (Flags & 0x20) != 0;
+    public bool IsSecured => (Flags & 0x40) != 0;
+    public bool IsAltName => (Flags & 0x80) != 0;
+
+    public static FileType FileTypeFromByte(byte value)
+    {
+        return Enum.IsDefined(typeof(FileType), value) ? (FileType)value : Headers.FileType.Unknown;
+    }
+
+    public static bool IsArchive(Stream stream)
+    {
+        var bytes = new byte[2];
+        if (stream.Read(bytes, 0, 2) != 2)
+        {
+            return false;
+        }
+
+        return CheckMagicBytes(bytes);
+    }
+
+    protected static bool CheckMagicBytes(byte[] headerBytes)
+    {
+        var magicValue = (ushort)(headerBytes[0] | headerBytes[1] << 8);
+        return magicValue == ARJ_MAGIC;
+    }
 }

src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.Async.cs

@@ -0,0 +1,24 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Arj.Headers;
+
+public partial class ArjLocalHeader
+{
+    public override async ValueTask<ArjHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var body = await ReadHeaderAsync(stream, cancellationToken);
+        if (body.Length > 0)
+        {
+            await ReadExtendedHeadersAsync(stream, cancellationToken);
+            var header = LoadFrom(body);
+            header.DataStartPosition = stream.Position;
+            return header;
+        }
+        return null;
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.cs

@@ -4,158 +4,159 @@ using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public partial class ArjLocalHeader : ArjHeader
 {
-    public class ArjLocalHeader : ArjHeader
+    public ArchiveEncoding ArchiveEncoding { get; }
+    public long DataStartPosition { get; protected set; }
+
+    public byte ArchiverVersionNumber { get; set; }
+    public byte MinVersionToExtract { get; set; }
+    public HostOS HostOS { get; set; }
+    public CompressionMethod CompressionMethod { get; set; }
+    public DosDateTime DateTimeModified { get; set; } = new DosDateTime(0);
+    public long CompressedSize { get; set; }
+    public long OriginalSize { get; set; }
+    public long OriginalCrc32 { get; set; }
+    public int FileSpecPosition { get; set; }
+    public int FileAccessMode { get; set; }
+    public byte FirstChapter { get; set; }
+    public byte LastChapter { get; set; }
+    public long ExtendedFilePosition { get; set; }
+    public DosDateTime DateTimeAccessed { get; set; } = new DosDateTime(0);
+    public DosDateTime DateTimeCreated { get; set; } = new DosDateTime(0);
+    public long OriginalSizeEvenForVolumes { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public string Comment { get; set; } = string.Empty;
+
+    private const byte StdHdrSize = 30;
+    private const byte R9HdrSize = 46;
+
+    public ArjLocalHeader(ArchiveEncoding archiveEncoding)
+        : base(ArjHeaderType.LocalHeader)
     {
-        public ArchiveEncoding ArchiveEncoding { get; }
-        public long DataStartPosition { get; protected set; }
+        ArchiveEncoding =
+            archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
+    }
 
-        public byte ArchiverVersionNumber { get; set; }
-        public byte MinVersionToExtract { get; set; }
-        public HostOS HostOS { get; set; }
-        public CompressionMethod CompressionMethod { get; set; }
-        public DosDateTime DateTimeModified { get; set; } = new DosDateTime(0);
-        public long CompressedSize { get; set; }
-        public long OriginalSize { get; set; }
-        public long OriginalCrc32 { get; set; }
-        public int FileSpecPosition { get; set; }
-        public int FileAccessMode { get; set; }
-        public byte FirstChapter { get; set; }
-        public byte LastChapter { get; set; }
-        public long ExtendedFilePosition { get; set; }
-        public DosDateTime DateTimeAccessed { get; set; } = new DosDateTime(0);
-        public DosDateTime DateTimeCreated { get; set; } = new DosDateTime(0);
-        public long OriginalSizeEvenForVolumes { get; set; }
-        public string Name { get; set; } = string.Empty;
-        public string Comment { get; set; } = string.Empty;
-
-        private const byte StdHdrSize = 30;
-        private const byte R9HdrSize = 46;
-
-        public ArjLocalHeader(ArchiveEncoding archiveEncoding)
-            : base(ArjHeaderType.LocalHeader)
+    public override ArjHeader? Read(Stream stream)
+    {
+        var body = ReadHeader(stream);
+        if (body.Length > 0)
         {
-            ArchiveEncoding =
-                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
+            ReadExtendedHeaders(stream);
+            var header = LoadFrom(body);
+            header.DataStartPosition = stream.Position;
+            return header;
+        }
+        return null;
+    }
+
+    // ReadAsync moved to ArjLocalHeader.Async.cs
+
+    public ArjLocalHeader LoadFrom(byte[] headerBytes)
+    {
+        int offset = 0;
+
+        int ReadInt16()
+        {
+            if (offset + 1 >= headerBytes.Length)
+            {
+                throw new EndOfStreamException();
+            }
+            var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
+            offset += 2;
+            return v;
+        }
+        long ReadInt32()
+        {
+            if (offset + 3 >= headerBytes.Length)
+            {
+                throw new EndOfStreamException();
+            }
+            long v =
+                headerBytes[offset] & 0xFF
+                | (headerBytes[offset + 1] & 0xFF) << 8
+                | (headerBytes[offset + 2] & 0xFF) << 16
+                | (headerBytes[offset + 3] & 0xFF) << 24;
+            offset += 4;
+            return v;
         }
 
-        public override ArjHeader? Read(Stream stream)
+        byte headerSize = headerBytes[offset++];
+        ArchiverVersionNumber = headerBytes[offset++];
+        MinVersionToExtract = headerBytes[offset++];
+        HostOS hostOS = (HostOS)headerBytes[offset++];
+        Flags = headerBytes[offset++];
+        CompressionMethod = CompressionMethodFromByte(headerBytes[offset++]);
+        FileType = FileTypeFromByte(headerBytes[offset++]);
+
+        offset++; // Skip 1 byte
+
+        var rawTimestamp = ReadInt32();
+        DateTimeModified = rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
+
+        CompressedSize = ReadInt32();
+        OriginalSize = ReadInt32();
+        OriginalCrc32 = ReadInt32();
+        FileSpecPosition = ReadInt16();
+        FileAccessMode = ReadInt16();
+
+        FirstChapter = headerBytes[offset++];
+        LastChapter = headerBytes[offset++];
+
+        ExtendedFilePosition = 0;
+        OriginalSizeEvenForVolumes = 0;
+
+        if (headerSize > StdHdrSize)
         {
-            var body = ReadHeader(stream);
-            if (body.Length > 0)
+            ExtendedFilePosition = ReadInt32();
+
+            if (headerSize >= R9HdrSize)
             {
-                ReadExtendedHeaders(stream);
-                var header = LoadFrom(body);
-                header.DataStartPosition = stream.Position;
-                return header;
+                rawTimestamp = ReadInt32();
+                DateTimeAccessed =
+                    rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
+                rawTimestamp = ReadInt32();
+                DateTimeCreated =
+                    rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
+                OriginalSizeEvenForVolumes = ReadInt32();
             }
-            return null;
         }
 
-        public ArjLocalHeader LoadFrom(byte[] headerBytes)
+        Name = Encoding.ASCII.GetString(
+            headerBytes,
+            offset,
+            Array.IndexOf(headerBytes, (byte)0, offset) - offset
+        );
+        offset += Name.Length + 1;
+
+        Comment = Encoding.ASCII.GetString(
+            headerBytes,
+            offset,
+            Array.IndexOf(headerBytes, (byte)0, offset) - offset
+        );
+        offset += Comment.Length + 1;
+
+        return this;
+    }
+
+    public static CompressionMethod CompressionMethodFromByte(byte value)
+    {
+        return value switch
         {
-            int offset = 0;
-
-            int ReadInt16()
-            {
-                if (offset + 1 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
-                offset += 2;
-                return v;
-            }
-            long ReadInt32()
-            {
-                if (offset + 3 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                long v =
-                    headerBytes[offset] & 0xFF
-                    | (headerBytes[offset + 1] & 0xFF) << 8
-                    | (headerBytes[offset + 2] & 0xFF) << 16
-                    | (headerBytes[offset + 3] & 0xFF) << 24;
-                offset += 4;
-                return v;
-            }
-
-            byte headerSize = headerBytes[offset++];
-            ArchiverVersionNumber = headerBytes[offset++];
-            MinVersionToExtract = headerBytes[offset++];
-            HostOS hostOS = (HostOS)headerBytes[offset++];
-            Flags = headerBytes[offset++];
-            CompressionMethod = CompressionMethodFromByte(headerBytes[offset++]);
-            FileType = FileTypeFromByte(headerBytes[offset++]);
-
-            offset++; // Skip 1 byte
-
-            var rawTimestamp = ReadInt32();
-            DateTimeModified =
-                rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
-
-            CompressedSize = ReadInt32();
-            OriginalSize = ReadInt32();
-            OriginalCrc32 = ReadInt32();
-            FileSpecPosition = ReadInt16();
-            FileAccessMode = ReadInt16();
-
-            FirstChapter = headerBytes[offset++];
-            LastChapter = headerBytes[offset++];
-
-            ExtendedFilePosition = 0;
-            OriginalSizeEvenForVolumes = 0;
-
-            if (headerSize > StdHdrSize)
-            {
-                ExtendedFilePosition = ReadInt32();
-
-                if (headerSize >= R9HdrSize)
-                {
-                    rawTimestamp = ReadInt32();
-                    DateTimeAccessed =
-                        rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
-                    rawTimestamp = ReadInt32();
-                    DateTimeCreated =
-                        rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
-                    OriginalSizeEvenForVolumes = ReadInt32();
-                }
-            }
-
-            Name = Encoding.ASCII.GetString(
-                headerBytes,
-                offset,
-                Array.IndexOf(headerBytes, (byte)0, offset) - offset
-            );
-            offset += Name.Length + 1;
-
-            Comment = Encoding.ASCII.GetString(
-                headerBytes,
-                offset,
-                Array.IndexOf(headerBytes, (byte)0, offset) - offset
-            );
-            offset += Comment.Length + 1;
-
-            return this;
-        }
-
-        public static CompressionMethod CompressionMethodFromByte(byte value)
-        {
-            return value switch
-            {
-                0 => CompressionMethod.Stored,
-                1 => CompressionMethod.CompressedMost,
-                2 => CompressionMethod.Compressed,
-                3 => CompressionMethod.CompressedFaster,
-                4 => CompressionMethod.CompressedFastest,
-                8 => CompressionMethod.NoDataNoCrc,
-                9 => CompressionMethod.NoData,
-                _ => CompressionMethod.Unknown,
-            };
-        }
+            0 => CompressionMethod.Stored,
+            1 => CompressionMethod.CompressedMost,
+            2 => CompressionMethod.Compressed,
+            3 => CompressionMethod.CompressedFaster,
+            4 => CompressionMethod.CompressedFastest,
+            8 => CompressionMethod.NoDataNoCrc,
+            9 => CompressionMethod.NoData,
+            _ => CompressionMethod.Unknown,
+        };
     }
 }