Fix DataDescriptorStream to handle legitimate cross-boundary signatures

Previous fix prevented infinite loops but broke detection of legitimate
data descriptor signatures split across buffer boundaries.

New approach:
- Track previous rewind count in _previousSearchPosition
- Detect infinite loop when read size equals previous rewind count
  AND all bytes match the signature pattern
- In that case, treat bytes as data (not signature) to break loop
- Otherwise, allow normal rewind/match to continue for legitimate
  cross-boundary signatures

This fixes both cases:
1. Infinite loop on data containing signature-like bytes (0x50...)
2. Correct detection of actual signatures split at buffer edge

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

.editorconfig

@@ -307,6 +307,7 @@ 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
@@ -367,9 +368,6 @@ dotnet_diagnostic.NX0001.severity = error
 dotnet_diagnostic.NX0002.severity = silent
 dotnet_diagnostic.NX0003.severity = silent
 
-dotnet_diagnostic.VSTHRD110.severity = error
-dotnet_diagnostic.VSTHRD107.severity = error
-
 ##########################################
 # Styles
 ##########################################

.gitignore

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

AGENTS.md

@@ -14,7 +14,6 @@ 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.
@@ -111,7 +110,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 [docs/FORMATS.md](docs/FORMATS.md) for complete format support matrix
+- See FORMATS.md for complete format support matrix
 
 ### Stream Handling Rules
 - **Disposal**: As of version 0.21, SharpCompress closes wrapped streams by default
@@ -178,4 +177,5 @@ 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

Directory.Build.props

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

Directory.Packages.props

@@ -5,20 +5,16 @@
     <PackageVersion Include="Glob" Version="1.1.9" />
     <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.15" />
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.NET.ILLink.Task" Version="10.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
     <PackageVersion Include="SimpleExec" Version="13.0.0" />
     <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.v3" Version="3.2.1" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
-    <GlobalPackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
-    <GlobalPackageReference
-      Include="Microsoft.VisualStudio.Threading.Analyzers"
-      Version="17.14.15"
-    />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
   </ItemGroup>
 </Project>

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

SharpCompress.sln

@@ -18,11 +18,12 @@ 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

USAGE.md

@@ -1,6 +1,6 @@
 # SharpCompress Usage
 
-## Async/Await Support (Beta)
+## Async/Await Support
 
 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
+## Stream Rules (changed with 0.21)
 
 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.CreateArchive())
+using(var archive = ZipArchive.Create())
 {
     archive.AddEntry("file01.txt", "C:\\file01.txt");
     archive.AddEntry("file02.txt", "C:\\file02.txt");
@@ -61,7 +61,7 @@ using(var archive = ZipArchive.CreateArchive())
 ### Create Zip Archive from all files in a directory to a file
 
 ```C#
-using (var archive = ZipArchive.CreateArchive())
+using (var archive = ZipArchive.Create())
 {
     archive.AddAllFromDirectory("D:\\temp");
     archive.SaveTo("C:\\temp.zip", CompressionType.Deflate);
@@ -72,7 +72,7 @@ using (var archive = ZipArchive.CreateArchive())
 
 ```C#
 var memoryStream = new MemoryStream();
-using (var archive = ZipArchive.CreateArchive())
+using (var archive = ZipArchive.Create())
 {
     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.OpenArchive("Test.rar"))
+using (var archive = RarArchive.Open("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.OpenArchive("Test.rar"))
 ### Iterate over all files from a Rar file using RarArchive
 
 ```C#
-using (var archive = RarArchive.OpenArchive("Test.rar"))
+using (var archive = RarArchive.Open("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.OpenArchive("archive.rar", new ReaderOptions { Progress = progress })) // Must be solid Rar or 7Zip
+using (var archive = RarArchive.Open("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.OpenArchive("archive.rar", new ReaderOptions { P
 
 ```C#
 using (Stream stream = File.OpenRead("Tar.tar.bz2"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -161,7 +161,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 
 ```C#
 using (Stream stream = File.OpenRead("Tar.tar.bz2"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -180,7 +180,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 
 ```C#
 using (Stream stream = File.OpenWrite("C:\\temp.tgz"))
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
+using (var writer = WriterFactory.Open(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.OpenArchive("test.zip", opts);
+var tr = SharpCompress.Archives.Zip.ZipArchive.Open("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.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     while (reader.MoveToNextEntry())
     {
@@ -234,7 +234,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 **Extract all entries asynchronously:**
 ```C#
 using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.OpenReader(stream))
+using (var reader = ReaderFactory.Open(stream))
 {
     await reader.WriteAllToDirectoryAsync(
         @"D:\temp",
@@ -250,7 +250,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
 
 **Open and process entry stream asynchronously:**
 ```C#
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
+using (var archive = ZipArchive.Open("archive.zip"))
 {
     foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
     {
@@ -268,7 +268,7 @@ using (var archive = ZipArchive.OpenArchive("archive.zip"))
 **Write single file asynchronously:**
 ```C#
 using (Stream archiveStream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.OpenWriter(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
+using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
 {
     using (Stream fileStream = File.OpenRead("input.txt"))
     {
@@ -280,7 +280,7 @@ using (var writer = WriterFactory.OpenWriter(archiveStream, ArchiveType.Zip, Com
 **Write entire directory asynchronously:**
 ```C#
 using (Stream stream = File.OpenWrite("backup.tar.gz"))
-using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+using (var writer = WriterFactory.Open(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.OpenWriter(stream, ArchiveType.Zip, CompressionType.Deflate))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
 {
     try
     {
@@ -316,7 +316,7 @@ using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, Compressio
 
 **Extract from archive asynchronously:**
 ```C#
-using (var archive = ZipArchive.OpenArchive("archive.zip"))
+using (var archive = ZipArchive.Open("archive.zip"))
 {
     // Simple async extraction - works for all archive types
     await archive.WriteToDirectoryAsync(

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

@@ -14,51 +14,11 @@
         "resolved": "1.1.9",
         "contentHash": "AfK5+ECWYTP7G3AAdnU8IfVj+QpGjrh9GC2mpdcJzCvtQ4pnerAGwHsxJ9D4/RnhDUz2DSzd951O/lQjQby2Sw=="
       },
-      "Microsoft.NETFramework.ReferenceAssemblies": {
-        "type": "Direct",
-        "requested": "[1.0.3, )",
-        "resolved": "1.0.3",
-        "contentHash": "vUc9Npcs14QsyOD01tnv/m8sQUnGTGOw1BCmKcv77LBJY7OxhJ+zJF7UD/sCL3lYNFuqmQEVlkfS4Quif6FyYg==",
-        "dependencies": {
-          "Microsoft.NETFramework.ReferenceAssemblies.net461": "1.0.3"
-        }
-      },
-      "Microsoft.SourceLink.GitHub": {
-        "type": "Direct",
-        "requested": "[8.0.0, )",
-        "resolved": "8.0.0",
-        "contentHash": "G5q7OqtwIyGTkeIOAc3u2ZuV/kicQaec5EaRnc0pIeSnh9LUjj+PYQrJYBURvDt7twGl2PKA7nSN0kz1Zw5bnQ==",
-        "dependencies": {
-          "Microsoft.Build.Tasks.Git": "8.0.0",
-          "Microsoft.SourceLink.Common": "8.0.0"
-        }
-      },
-      "Microsoft.VisualStudio.Threading.Analyzers": {
-        "type": "Direct",
-        "requested": "[17.14.15, )",
-        "resolved": "17.14.15",
-        "contentHash": "mXQPJsbuUD2ydq4/ffd8h8tSOFCXec+2xJOVNCvXjuMOq/+5EKHq3D2m2MC2+nUaXeFMSt66VS/J4HdKBixgcw=="
-      },
       "SimpleExec": {
         "type": "Direct",
         "requested": "[13.0.0, )",
         "resolved": "13.0.0",
         "contentHash": "zcCR1pupa1wI1VqBULRiQKeHKKZOuJhi/K+4V5oO+rHJZlaOD53ViFo1c3PavDoMAfSn/FAXGAWpPoF57rwhYg=="
-      },
-      "Microsoft.Build.Tasks.Git": {
-        "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "bZKfSIKJRXLTuSzLudMFte/8CempWjVamNUR5eHJizsy+iuOuO/k2gnh7W0dHJmYY0tBf+gUErfluCv5mySAOQ=="
-      },
-      "Microsoft.NETFramework.ReferenceAssemblies.net461": {
-        "type": "Transitive",
-        "resolved": "1.0.3",
-        "contentHash": "AmOJZwCqnOCNp6PPcf9joyogScWLtwy0M1WkqfEQ0M9nYwyDD7EX9ZjscKS5iYnyvteX7kzSKFCKt9I9dXA6mA=="
-      },
-      "Microsoft.SourceLink.Common": {
-        "type": "Transitive",
-        "resolved": "8.0.0",
-        "contentHash": "dk9JPxTCIevS75HyEQ0E4OVAFhB2N+V9ShCXf8Q6FkUQZDkgLI12y679Nym1YqsiSysuQskT7Z+6nUf3yab6Vw=="
       }
     }
   }

docs/API.md

@@ -1,512 +0,0 @@
-# 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

@@ -1,659 +0,0 @@
-# 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

@@ -1,610 +0,0 @@
-# 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

@@ -1,474 +0,0 @@
-# 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

src/SharpCompress/Archives/AbstractArchive.cs

@@ -1,13 +1,14 @@
+using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
+public abstract class AbstractArchive<TEntry, TVolume> : IArchive
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -25,12 +26,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
         _sourceStream = sourceStream;
         _lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(_sourceStream));
         _lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
-        _lazyVolumesAsync = new LazyAsyncReadOnlyCollection<TVolume>(
-            LoadVolumesAsync(_sourceStream)
-        );
-        _lazyEntriesAsync = new LazyAsyncReadOnlyCollection<TEntry>(
-            LoadEntriesAsync(_lazyVolumesAsync)
-        );
     }
 
     internal AbstractArchive(ArchiveType type)
@@ -39,16 +34,19 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
         ReaderOptions = new();
         _lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
         _lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
-        _lazyVolumesAsync = new LazyAsyncReadOnlyCollection<TVolume>(
-            AsyncEnumerableEx.Empty<TVolume>()
-        );
-        _lazyEntriesAsync = new LazyAsyncReadOnlyCollection<TEntry>(
-            AsyncEnumerableEx.Empty<TEntry>()
-        );
     }
 
     public ArchiveType Type { get; }
 
+    private static Stream CheckStreams(Stream stream)
+    {
+        if (!stream.CanSeek || !stream.CanRead)
+        {
+            throw new ArchiveException("Archive streams must be Readable and Seekable");
+        }
+        return stream;
+    }
+
     /// <summary>
     /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
     /// </summary>
@@ -68,25 +66,12 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     /// <summary>
     /// The total size of the files as uncompressed in the archive.
     /// </summary>
-    public virtual long TotalUncompressedSize =>
+    public virtual long TotalUncompressSize =>
         Entries.Aggregate(0L, (total, cf) => total + cf.Size);
 
     protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
     protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
 
-    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>();
@@ -133,7 +118,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     }
 
     protected abstract IReader CreateReaderForSolidExtraction();
-    protected abstract ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync();
 
     /// <summary>
     /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
@@ -156,87 +140,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;
-
-    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 IAsyncEnumerable<TVolume> VolumesAsync => _lazyVolumesAsync;
-
-    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/AbstractWritableArchive.cs

@@ -12,8 +12,7 @@ namespace SharpCompress.Archives;
 
 public abstract class AbstractWritableArchive<TEntry, TVolume>
     : AbstractArchive<TEntry, TVolume>,
-        IWritableArchive,
-        IWritableAsyncArchive
+        IWritableArchive
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -73,25 +72,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         modifiedEntries.AddRange(OldEntries.Concat(newEntries));
     }
 
-    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);
-    }
-
     private IEnumerable<TEntry> OldEntries => base.Entries.Where(x => !removedEntries.Contains(x));
-    private IAsyncEnumerable<TEntry> OldEntriesAsync =>
-        base.EntriesAsync.Where(x => !removedEntries.Contains(x));
 
     public void RemoveEntry(TEntry entry)
     {
@@ -102,20 +83,8 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         }
     }
 
-    public async ValueTask RemoveEntryAsync(TEntry entry)
-    {
-        if (!removedEntries.Contains(entry))
-        {
-            removedEntries.Add(entry);
-            await RebuildModifiedCollectionAsync();
-        }
-    }
-
     void IWritableArchive.RemoveEntry(IArchiveEntry entry) => RemoveEntry((TEntry)entry);
 
-    ValueTask IWritableAsyncArchive.RemoveEntryAsync(IArchiveEntry entry) =>
-        RemoveEntryAsync((TEntry)entry);
-
     public TEntry AddEntry(string key, Stream source, long size = 0, DateTime? modified = null) =>
         AddEntry(key, source, false, size, modified);
 
@@ -170,68 +139,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return false;
     }
 
-    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;
-    }
-
-    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 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 TEntry AddDirectoryEntry(string key, DateTime? modified = null)
     {
         if (key.Length > 0 && key[0] is '/' or '\\')
@@ -248,26 +155,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         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 void SaveTo(Stream stream, WriterOptions options)
     {
         //reset streams of new entries
@@ -275,7 +162,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         SaveTo(stream, options, OldEntries, newEntries);
     }
 
-    public async ValueTask SaveToAsync(
+    public async Task SaveToAsync(
         Stream stream,
         WriterOptions options,
         CancellationToken cancellationToken = default
@@ -283,7 +170,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
     {
         //reset streams of new entries
         newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        await SaveToAsync(stream, options, OldEntriesAsync, newEntries, cancellationToken)
+        await SaveToAsync(stream, options, OldEntries, newEntries, cancellationToken)
             .ConfigureAwait(false);
     }
 
@@ -321,10 +208,10 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         IEnumerable<TEntry> newEntries
     );
 
-    protected abstract ValueTask SaveToAsync(
+    protected abstract Task SaveToAsync(
         Stream stream,
         WriterOptions options,
-        IAsyncEnumerable<TEntry> oldEntries,
+        IEnumerable<TEntry> oldEntries,
         IEnumerable<TEntry> newEntries,
         CancellationToken cancellationToken = default
     );

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -2,8 +2,6 @@ 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;
@@ -13,26 +11,20 @@ namespace SharpCompress.Archives;
 
 public static class ArchiveFactory
 {
-    public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    /// <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)
     {
         readerOptions ??= new ReaderOptions();
         stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
-        return FindFactory<IArchiveFactory>(stream).OpenArchive(stream, readerOptions);
+        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        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);
-        return factory.OpenAsyncArchive(stream, readerOptions);
-    }
-
-    public static IWritableArchive CreateArchive(ArchiveType type)
+    public static IWritableArchive Create(ArchiveType type)
     {
         var factory = Factory
             .Factories.OfType<IWriteableArchiveFactory>()
@@ -40,51 +32,41 @@ public static class ArchiveFactory
 
         if (factory != null)
         {
-            return factory.CreateArchive();
+            return factory.CreateWriteableArchive();
         }
 
         throw new NotSupportedException("Cannot create Archives of type: " + type);
     }
 
-    public static IArchive OpenArchive(string filePath, ReaderOptions? options = null)
+    /// <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)
     {
         filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), options);
+        return Open(new FileInfo(filePath), options);
     }
 
-    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 IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
+    /// <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)
     {
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-        return FindFactory<IArchiveFactory>(fileInfo).OpenArchive(fileInfo, options);
+        return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
     }
 
-    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 IArchive OpenArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? options = null
-    )
+    /// <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();
@@ -96,42 +78,21 @@ public static class ArchiveFactory
         var fileInfo = filesArray[0];
         if (filesArray.Length == 1)
         {
-            return OpenArchive(fileInfo, options);
+            return Open(fileInfo, options);
         }
 
         fileInfo.NotNull(nameof(fileInfo));
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-        return FindFactory<IMultiArchiveFactory>(fileInfo).OpenArchive(filesArray, options);
+        return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, 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 IArchive OpenArchive(IEnumerable<Stream> streams, ReaderOptions? options = null)
+    /// <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)
     {
         streams.NotNull(nameof(streams));
         var streamsArray = streams.ToArray();
@@ -143,71 +104,29 @@ public static class ArchiveFactory
         var firstStream = streamsArray[0];
         if (streamsArray.Length == 1)
         {
-            return OpenArchive(firstStream, options);
+            return Open(firstStream, options);
         }
 
         firstStream.NotNull(nameof(firstStream));
         options ??= new ReaderOptions();
 
-        return FindFactory<IMultiArchiveFactory>(firstStream).OpenArchive(streamsArray, options);
-    }
-
-    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);
+        return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
     }
 
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
     public static void WriteToDirectory(
         string sourceArchive,
         string destinationDirectory,
         ExtractionOptions? options = null
     )
     {
-        using var archive = OpenArchive(sourceArchive);
+        using var archive = Open(sourceArchive);
         archive.WriteToDirectory(destinationDirectory, options);
     }
 
-    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 ValueTask<T> FindFactoryAsync<T>(
-        string path,
-        CancellationToken cancellationToken = default
-    )
-        where T : IFactory
-    {
-        path.NotNullOrEmpty(nameof(path));
-        return FindFactoryAsync<T>(new FileInfo(path), cancellationToken);
-    }
-
-    public static T FindFactory<T>(FileInfo finfo)
+    private static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
         finfo.NotNull(nameof(finfo));
@@ -215,7 +134,7 @@ public static class ArchiveFactory
         return FindFactory<T>(stream);
     }
 
-    public static T FindFactory<T>(Stream stream)
+    private static T FindFactory<T>(Stream stream)
         where T : IFactory
     {
         stream.NotNull(nameof(stream));
@@ -247,68 +166,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));
@@ -335,12 +200,22 @@ 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));
@@ -354,7 +229,7 @@ public static class ArchiveFactory
             if (part != null)
             {
                 yield return part;
-                while ((part = factory.GetFilePart(i++, part1)) != null)
+                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
                 {
                     yield return part;
                 }
@@ -363,4 +238,6 @@ public static class ArchiveFactory
             }
         }
     }
+
+    public static IArchiveFactory AutoFactory { get; } = new AutoArchiveFactory();
 }

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+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) =>
+        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 IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
+        ArchiveFactory.Open(fileInfo, readerOptions);
+}

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

@@ -1,197 +0,0 @@
-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.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
-    )
-    {
-        byte[] header = new byte[10];
-
-        if (!await stream.ReadFullyAsync(header, cancellationToken).ConfigureAwait(false))
-        {
-            return false;
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            return false;
-        }
-
-        return true;
-    }
-}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -14,20 +14,122 @@ using SharpCompress.Writers.GZip;
 
 namespace SharpCompress.Archives.GZip;
 
-public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+public 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())
+        );
+    }
+
+    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)
@@ -36,19 +138,38 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         SaveTo(stream, new WriterOptions(CompressionType.GZip));
     }
 
-    public ValueTask SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
+    public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
         SaveToAsync(new FileInfo(filePath), cancellationToken);
 
-    public async ValueTask SaveToAsync(
-        FileInfo fileInfo,
-        CancellationToken cancellationToken = default
-    )
+    public async Task 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;
+    }
+
+    internal GZipArchive()
+        : base(ArchiveType.GZip) { }
+
     protected override GZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -92,10 +213,10 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         }
     }
 
-    protected override async ValueTask SaveToAsync(
+    protected override async Task SaveToAsync(
         Stream stream,
         WriterOptions options,
-        IAsyncEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> oldEntries,
         IEnumerable<GZipArchiveEntry> newEntries,
         CancellationToken cancellationToken = default
     )
@@ -105,23 +226,7 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
             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))
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
             using var entryStream = entry.OpenEntryStream();
             await writer
@@ -135,18 +240,7 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         var stream = volumes.Single().Stream;
         yield return new GZipArchiveEntry(
             this,
-            GZipFilePart.Create(stream, ReaderOptions.ArchiveEncoding)
-        );
-    }
-
-    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)
+            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
         );
     }
 
@@ -154,13 +248,6 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return GZipReader.OpenReader(stream);
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)GZipReader.OpenReader(stream));
+        return GZipReader.Open(stream);
     }
 }

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

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

src/SharpCompress/Archives/IArchive.cs

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

src/SharpCompress/Archives/IArchiveEntry.cs

@@ -17,7 +17,7 @@ public interface IArchiveEntry : IEntry
     /// Opens the current entry as a stream that will decompress as it is read asynchronously.
     /// Read the entire stream or use SkipEntry on EntryStream.
     /// </summary>
-    ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
+    Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
 
     /// <summary>
     /// The archive can find all the parts of the archive needed to extract this entry.

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>
@@ -37,7 +35,7 @@ public static class IArchiveEntryExtensions
         /// <param name="streamToWriteTo">The stream to write the entry content to.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
-        public async ValueTask WriteToAsync(
+        public async Task WriteToAsync(
             Stream streamToWriteTo,
             IProgress<ProgressReport>? progress = null,
             CancellationToken cancellationToken = default
@@ -51,7 +49,7 @@ public static class IArchiveEntryExtensions
             using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
             var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
             await sourceStream
-                .CopyToAsync(streamToWriteTo, BufferSize, cancellationToken)
+                .CopyToAsync(streamToWriteTo, Constants.BufferSize, cancellationToken)
                 .ConfigureAwait(false);
         }
     }
@@ -110,20 +108,18 @@ public static class IArchiveEntryExtensions
         /// <summary>
         /// Extract to specific directory asynchronously, retaining filename
         /// </summary>
-        public async ValueTask WriteToDirectoryAsync(
+        public Task WriteToDirectoryAsync(
             string destinationDirectory,
             ExtractionOptions? options = null,
             CancellationToken cancellationToken = default
         ) =>
-            await ExtractionMethods
-                .WriteEntryToDirectoryAsync(
-                    entry,
-                    destinationDirectory,
-                    options,
-                    entry.WriteToFileAsync,
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
+            ExtractionMethods.WriteEntryToDirectoryAsync(
+                entry,
+                destinationDirectory,
+                options,
+                entry.WriteToFileAsync,
+                cancellationToken
+            );
 
         /// <summary>
         /// Extract to specific file
@@ -143,23 +139,21 @@ public static class IArchiveEntryExtensions
         /// <summary>
         /// Extract to specific file asynchronously
         /// </summary>
-        public async ValueTask WriteToFileAsync(
+        public Task WriteToFileAsync(
             string destinationFileName,
             ExtractionOptions? options = null,
             CancellationToken cancellationToken = default
         ) =>
-            await ExtractionMethods
-                .WriteEntryToFileAsync(
-                    entry,
-                    destinationFileName,
-                    options,
-                    async (x, fm, ct) =>
-                    {
-                        using var fs = File.Open(destinationFileName, fm);
-                        await entry.WriteToAsync(fs, null, ct).ConfigureAwait(false);
-                    },
-                    cancellationToken
-                )
-                .ConfigureAwait(false);
+            ExtractionMethods.WriteEntryToFileAsync(
+                entry,
+                destinationFileName,
+                options,
+                async (x, fm, ct) =>
+                {
+                    using var fs = File.Open(destinationFileName, fm);
+                    await entry.WriteToAsync(fs, null, ct).ConfigureAwait(false);
+                },
+                cancellationToken
+            );
     }
 }

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
@@ -8,6 +10,7 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveExtensions
 {
+    /// <param name="archive">The archive to extract.</param>
     extension(IArchive archive)
     {
         /// <summary>
@@ -22,6 +25,7 @@ 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();
@@ -29,6 +33,7 @@ public static class IArchiveExtensions
             }
             else
             {
+                // For non-solid archives, extract entries directly
                 archive.WriteToDirectoryInternal(destinationDirectory, options, progress);
             }
         }
@@ -39,10 +44,14 @@ public static class IArchiveExtensions
             IProgress<ProgressReport>? progress
         )
         {
-            var totalBytes = archive.TotalUncompressedSize;
+            // Prepare for progress reporting
+            var totalBytes = archive.TotalUncompressSize;
             var bytesRead = 0L;
+
+            // Tracking for created directories.
             var seenDirectories = new HashSet<string>();
 
+            // Extract
             foreach (var entry in archive.Entries)
             {
                 if (entry.IsDirectory)
@@ -61,8 +70,94 @@ 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)
+                );
+            }
+        }
+
+        /// <summary>
+        /// Extract to specific directory asynchronously with progress reporting and cancellation support
+        /// </summary>
+        /// <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 Task WriteToDirectoryAsync(
+            string destinationDirectory,
+            ExtractionOptions? options = null,
+            IProgress<ProgressReport>? progress = null,
+            CancellationToken cancellationToken = default
+        )
+        {
+            // For solid archives (Rar, 7Zip), use the optimized reader-based approach
+            if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
+            {
+                using var reader = archive.ExtractAllEntries();
+                await reader.WriteAllToDirectoryAsync(
+                    destinationDirectory,
+                    options,
+                    cancellationToken
+                );
+            }
+            else
+            {
+                // For non-solid archives, extract entries directly
+                await archive.WriteToDirectoryAsyncInternal(
+                    destinationDirectory,
+                    options,
+                    progress,
+                    cancellationToken
+                );
+            }
+        }
+
+        private async Task WriteToDirectoryAsyncInternal(
+            string destinationDirectory,
+            ExtractionOptions? options,
+            IProgress<ProgressReport>? progress,
+            CancellationToken cancellationToken
+        )
+        {
+            // Prepare for progress reporting
+            var totalBytes = archive.TotalUncompressSize;
+            var bytesRead = 0L;
+
+            // Tracking for created directories.
+            var seenDirectories = new HashSet<string>();
+
+            // Extract
+            foreach (var entry in archive.Entries)
+            {
+                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;
+                }
+
+                // Use the entry's WriteToDirectoryAsync method which respects ExtractionOptions
+                await entry
+                    .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken)
+                    .ConfigureAwait(false);
+
+                // Update progress
                 bytesRead += entry.Size;
                 progress?.Report(
                     new ProgressReport(entry.Key ?? string.Empty, bytesRead, totalBytes)

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -25,27 +24,12 @@ public interface IArchiveFactory : IFactory
     /// </summary>
     /// <param name="stream">An open, readable and seekable stream.</param>
     /// <param name="readerOptions">reading options.</param>
-    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>
-    IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null);
+    IArchive Open(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 OpenArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Opens an Archive from a FileInfo object asynchronously.
-    /// </summary>
-    /// <param name="fileInfo">the file to open.</param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    IAsyncArchive OpenAsyncArchive(FileInfo fileInfo, ReaderOptions? readerOptions = null);
+    IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
 }

src/SharpCompress/Archives/IArchiveOpenable.cs

@@ -1,40 +0,0 @@
-#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

@@ -1,48 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-public interface IAsyncArchive : IAsyncDisposable
-{
-    IAsyncEnumerable<IArchiveEntry> EntriesAsync { get; }
-    IAsyncEnumerable<IVolume> VolumesAsync { get; }
-
-    ArchiveType Type { get; }
-
-    /// <summary>
-    /// Use this method to extract all entries in an archive in order.
-    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
-    /// extracted sequentially for the best performance.
-    /// </summary>
-    ValueTask<IAsyncReader> ExtractAllEntriesAsync();
-
-    /// <summary>
-    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-    /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
-    /// </summary>
-    ValueTask<bool> IsSolidAsync();
-
-    /// <summary>
-    /// This checks to see if all the known entries have IsComplete = true
-    /// </summary>
-    ValueTask<bool> IsCompleteAsync();
-
-    /// <summary>
-    /// The total size of the files compressed in the archive.
-    /// </summary>
-    ValueTask<long> TotalSizeAsync();
-
-    /// <summary>
-    /// The total size of the files as uncompressed in the archive.
-    /// </summary>
-    ValueTask<long> TotalUncompressedSizeAsync();
-
-    /// <summary>
-    /// Returns whether the archive is encrypted.
-    /// </summary>
-    ValueTask<bool> IsEncryptedAsync();
-}

src/SharpCompress/Archives/IAsyncArchiveExtensions.cs

@@ -1,92 +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;
-
-public static class IAsyncArchiveExtensions
-{
-    extension(IAsyncArchive archive)
-    {
-        /// <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 Task WriteToDirectoryAsync(
-            string destinationDirectory,
-            ExtractionOptions? options = null,
-            IProgress<ProgressReport>? progress = null,
-            CancellationToken cancellationToken = default
-        )
-        {
-            if (await archive.IsSolidAsync() || archive.Type == ArchiveType.SevenZip)
-            {
-                await using var reader = await archive.ExtractAllEntriesAsync();
-                await reader.WriteAllToDirectoryAsync(
-                    destinationDirectory,
-                    options,
-                    cancellationToken
-                );
-            }
-            else
-            {
-                await archive.WriteToDirectoryAsyncInternal(
-                    destinationDirectory,
-                    options,
-                    progress,
-                    cancellationToken
-                );
-            }
-        }
-
-        private async Task WriteToDirectoryAsyncInternal(
-            string destinationDirectory,
-            ExtractionOptions? options,
-            IProgress<ProgressReport>? progress,
-            CancellationToken cancellationToken
-        )
-        {
-            var totalBytes = await archive.TotalUncompressedSizeAsync();
-            var bytesRead = 0L;
-            var seenDirectories = new HashSet<string>();
-
-            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,6 +1,5 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -26,34 +25,12 @@ public interface IMultiArchiveFactory : IFactory
     /// </summary>
     /// <param name="streams"></param>
     /// <param name="readerOptions">reading options.</param>
-    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>
-    IAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null
-    );
+    IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
 
     /// <summary>
     /// Constructor with IEnumerable Stream objects, multi and split support.
     /// </summary>
     /// <param name="fileInfos"></param>
     /// <param name="readerOptions">reading options.</param>
-    IArchive OpenArchive(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Opens a multi-part archive from files asynchronously.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions">reading options.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    IAsyncArchive OpenAsyncArchive(
-        IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    );
+    IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
 }

src/SharpCompress/Archives/IMultiArchiveOpenable.cs

@@ -1,35 +0,0 @@
-#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,17 +6,10 @@ using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public interface IWritableArchiveCommon
+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.
-    /// </summary>
-    /// <returns>IDisposeable to resume entry rebuilding</returns>
-    IDisposable PauseEntryRebuilding();
-}
+    void RemoveEntry(IArchiveEntry entry);
 
-public interface IWritableArchive : IArchive, IWritableArchiveCommon
-{
     IArchiveEntry AddEntry(
         string key,
         Stream source,
@@ -27,51 +20,17 @@ public interface IWritableArchive : IArchive, IWritableArchiveCommon
 
     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(
+    Task SaveToAsync(
         Stream stream,
         WriterOptions options,
         CancellationToken cancellationToken = default
     );
 
     /// <summary>
-    /// Asynchronously adds an entry to the archive with the specified key, source stream, and options.
+    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
     /// </summary>
-    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);
+    /// <returns>IDisposeable to resume entry rebuilding</returns>
+    IDisposable PauseEntryRebuilding();
 }

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

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

src/SharpCompress/Archives/IWritableArchiveOpenable.cs

@@ -1,10 +0,0 @@
-#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

@@ -1,86 +0,0 @@
-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 CreateArchive();
+    IWritableArchive CreateWriteableArchive();
 }

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -36,7 +36,4 @@ 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.Extensions.cs

@@ -1,36 +1,18 @@
-using System.Linq;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
+using System.Linq;
 
 namespace SharpCompress.Archives.Rar;
 
 public static class RarArchiveExtensions
 {
-    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 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;
 
-        /// <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;
-    }
+    /// <summary>
+    /// RarArchive is part of a multi-part archive.
+    /// </summary>
+    public static bool IsMultipartVolume(this RarArchive archive) =>
+        archive.Volumes.First().IsMultiVolume;
 }

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

@@ -1,187 +0,0 @@
-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

@@ -2,8 +2,6 @@ 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;
@@ -14,23 +12,17 @@ using SharpCompress.Readers.Rar;
 
 namespace SharpCompress.Archives.Rar;
 
-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
+public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 {
     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) { }
 
@@ -48,31 +40,15 @@ public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, I
         }
     }
 
-    public override async ValueTask DisposeAsync()
-    {
-        if (!_disposed)
-        {
-            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
-            {
-                unpackV1.Dispose();
-            }
-
-            _disposed = true;
-            await base.DisposeAsync();
-        }
-    }
-
     protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
         RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
-    protected override IAsyncEnumerable<RarArchiveEntry> LoadEntriesAsync(IAsyncEnumerable<RarVolume> volumes) =>
-        RarArchiveEntryFactory.GetEntriesAsync(this, volumes, ReaderOptions);
 
     protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
     {
-        sourceStream.LoadAllParts();
+        sourceStream.LoadAllParts(); //request all streams
         var streams = sourceStream.Streams.ToArray();
         var i = 0;
-        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions))
+        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
         {
             sourceStream.IsVolumes = true;
             streams[1].Position = 0;
@@ -85,27 +61,10 @@ public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, I
             ));
         }
 
+        //split mode or single file
         return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
     }
 
-
-    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);
-    }
-
     protected override IReader CreateReaderForSolidExtraction()
     {
         if (this.IsMultipartVolume())
@@ -115,22 +74,137 @@ public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, I
                 volume.Stream.Position = 0;
                 return volume.Stream;
             });
-            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
+            return RarReader.Open(streams, ReaderOptions);
         }
 
         var stream = Volumes.First().Stream;
         stream.Position = 0;
-        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
+        return RarReader.Open(stream, ReaderOptions);
     }
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
 
-    public override async ValueTask<bool> IsSolidAsync() =>
-        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsSolidArchiveAsync();
-
     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()
+            )
+        );
+    }
+
+    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.cs

@@ -92,9 +92,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
         return stream;
     }
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
+    public async Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
     {
         RarStream stream;
         if (IsRarV3)
@@ -102,9 +100,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
             );
         }
         else
@@ -112,9 +108,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
             stream = new RarStream(
                 archive.UnpackV2017.Value,
                 FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>())
             );
         }
 

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

@@ -17,17 +17,6 @@ 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
     )
@@ -49,27 +38,6 @@ 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,
@@ -81,16 +49,4 @@ 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/StreamRarArchiveVolume.cs

@@ -14,9 +14,6 @@ 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.Factory.cs

@@ -1,210 +0,0 @@
-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,76 +12,136 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.SevenZip;
 
-public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
+public 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>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
     private SevenZipArchive(SourceStream sourceStream)
         : base(ArchiveType.SevenZip, sourceStream) { }
 
-    internal SevenZipArchive()
-        : base(ArchiveType.SevenZip) { }
-
     protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream sourceStream)
     {
-        sourceStream.NotNull("SourceStream is null").LoadAllParts();
-        return new SevenZipVolume(sourceStream, ReaderOptions, 0).AsEnumerable();
+        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
+        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) { }
+
     protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(
         IEnumerable<SevenZipVolume> volumes
     )
     {
-        foreach (var volume in volumes)
-        {
-            LoadFactory(volume.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(
-                        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;
-            }
-        }
-    }
-
-    protected override async IAsyncEnumerable<SevenZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<SevenZipVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        await LoadFactoryAsync(stream);
+        var stream = volumes.Single().Stream;
+        LoadFactory(stream);
         if (_database is null)
         {
-            yield break;
+            return Enumerable.Empty<SevenZipArchiveEntry>();
         }
         var entries = new SevenZipArchiveEntry[_database._files.Count];
         for (var i = 0; i < _database._files.Count; i++)
@@ -98,14 +158,11 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
             foreach (var entry in group)
             {
                 entry.IsSolid = isSolid;
-                isSolid = true;
+                isSolid = true; //mark others in this group as solid - same as rar behaviour.
             }
         }
 
-        foreach (var entry in entries)
-        {
-            yield return entry;
-        }
+        return entries;
     }
 
     private void LoadFactory(Stream stream)
@@ -119,33 +176,31 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         }
     }
 
-    private async Task LoadFactoryAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
+    public static bool IsSevenZipFile(Stream stream)
     {
-        if (_database is null)
+        try
         {
-            stream.Position = 0;
-            var reader = new ArchiveReader();
-            await reader.OpenAsync(
-                stream,
-                lookForHeader: ReaderOptions.LookForHeader,
-                cancellationToken
-            );
-            _database = await reader.ReadDatabaseAsync(
-                new PasswordProvider(ReaderOptions.Password),
-                cancellationToken
-            );
+            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)
@@ -157,10 +212,31 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
     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;
@@ -176,6 +252,10 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
                 _currentEntry = dir;
                 yield return dir;
             }
+            // 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;
@@ -190,10 +270,60 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
             {
                 return CreateEntryStream(Stream.Null);
             }
-            return CreateEntryStream(new SyncOnlyStream(entry.FilePart.GetCompressedStream()));
+
+            var filePart = (SevenZipFilePart)entry.FilePart;
+            if (!filePart.Header.HasStream)
+            {
+                // Entries with no underlying stream (e.g., empty files or anti-items)
+                // should return an empty stream, matching previous behavior.
+                return CreateEntryStream(Stream.Null);
+            }
+
+            var folder = 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();
         }
     }
 
+    /// <summary>
+    /// WORKAROUND: Forces async operations to use synchronous equivalents.
+    /// This is necessary because the LZMA decoder has bugs in its async implementation
+    /// that cause state corruption (IndexOutOfRangeException, DataErrorException).
+    ///
+    /// The proper fix would be to repair the LZMA decoder's async methods
+    /// (LzmaStream.ReadAsync, Decoder.CodeAsync, OutWindow async operations),
+    /// but that requires deep changes to the decoder state machine.
+    /// </summary>
     private sealed class SyncOnlyStream : Stream
     {
         private readonly Stream _baseStream;
@@ -223,6 +353,7 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         public override void Write(byte[] buffer, int offset, int count) =>
             _baseStream.Write(buffer, offset, count);
 
+        // Force async operations to use sync equivalents to avoid LZMA decoder bugs
         public override Task<int> ReadAsync(
             byte[] buffer,
             int offset,

src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs

@@ -12,8 +12,8 @@ public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 
     public Stream OpenEntryStream() => FilePart.GetCompressedStream();
 
-    public ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        new(OpenEntryStream());
+    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
+        Task.FromResult(OpenEntryStream());
 
     public IArchive Archive { get; }
 

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

@@ -1,198 +0,0 @@
-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 ?? new 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()
-            )
-        );
-    }
-
-    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()
-            )
-        );
-    }
-
-    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());
-            var reader = new AsyncBinaryReader(stream, false);
-            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,14 +15,132 @@ using SharpCompress.Writers.Tar;
 
 namespace SharpCompress.Archives.Tar;
 
-public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
 {
-    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
+    /// <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)
     {
-        sourceStream.NotNull("SourceStream is null").LoadAllParts();
-        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable();
+        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())
+        );
+    }
+
+    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
+    }
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
     private TarArchive(SourceStream sourceStream)
         : base(ArchiveType.Tar, sourceStream) { }
 
@@ -32,10 +150,6 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
     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(
@@ -66,7 +180,7 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
                         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();
 
@@ -91,76 +205,7 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
         }
     }
 
-    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");
-                }
-            }
-        }
-    }
+    public static TarArchive Create() => new();
 
     protected override TarArchiveEntry CreateEntryInternal(
         string filePath,
@@ -214,44 +259,16 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
         }
     }
 
-    protected override async ValueTask SaveToAsync(
+    protected override async Task SaveToAsync(
         Stream stream,
         WriterOptions options,
-        IAsyncEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<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)
+        foreach (var entry in oldEntries.Concat(newEntries))
         {
             if (entry.IsDirectory)
             {
@@ -283,13 +300,6 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
-        return TarReader.OpenReader(stream);
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)TarReader.OpenReader(stream));
+        return TarReader.Open(stream);
     }
 }

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

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

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

@@ -1,324 +0,0 @@
-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 ?? new 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()
-            )
-        );
-    }
-
-    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()
-            )
-        );
-    }
-
-    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,
-        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)
-                {
-                    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(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,
-        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)
-                {
-                    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,12 +16,21 @@ using SharpCompress.Writers.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+public 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(
@@ -29,42 +38,208 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
             sourceStream.ReaderOptions.ArchiveEncoding
         );
 
-    internal ZipArchive()
-        : base(ArchiveType.Zip) { }
+    /// <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())
+        );
+    }
+
+    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
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: Constants.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)
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: Constants.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).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
 
     protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
     {
-        stream.LoadAllParts();
+        stream.LoadAllParts(); //request all streams
         stream.Position = 0;
 
         var streams = stream.Streams.ToList();
         var idx = 0;
-        if (streams.Count() > 1)
+        if (streams.Count() > 1) //test part 2 - true = multipart not split
         {
-            streams[1].Position += 4;
-            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
+            streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password);
             streams[1].Position -= 4;
             if (isZip)
             {
                 stream.IsVolumes = true;
 
-                var tmp = streams[0];
+                var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
                 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)
             {
@@ -108,59 +283,6 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         }
     }
 
-    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(
@@ -192,42 +314,16 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         }
     }
 
-    protected override async ValueTask SaveToAsync(
+    protected override async Task SaveToAsync(
         Stream stream,
         WriterOptions options,
-        IAsyncEnumerable<ZipArchiveEntry> oldEntries,
+        IEnumerable<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)
+        foreach (var entry in oldEntries.Concat(newEntries))
         {
             if (entry.IsDirectory)
             {
@@ -266,17 +362,12 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         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.OpenReader(stream, ReaderOptions, Entries);
-    }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)ZipReader.OpenReader(stream));
+        return ZipReader.Open(stream, ReaderOptions, Entries);
     }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -13,17 +13,9 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
+    public virtual Task<Stream> OpenEntryStreamAsync(
         CancellationToken cancellationToken = default
-    )
-    {
-        var part = Parts.Single();
-        if (part is SeekableZipFilePart seekablePart)
-        {
-            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
-        }
-        return OpenEntryStream();
-    }
+    ) => Task.FromResult(OpenEntryStream());
 
     #region IArchiveEntry Members
 

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

@@ -2,8 +2,6 @@ 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;
 
@@ -48,7 +46,7 @@ namespace SharpCompress.Common.Ace.Headers
             }
         }
 
-        public AceFileHeader(IArchiveEncoding archiveEncoding)
+        public AceFileHeader(ArchiveEncoding archiveEncoding)
             : base(archiveEncoding, AceHeaderType.FILE) { }
 
         /// <summary>
@@ -149,107 +147,6 @@ namespace SharpCompress.Common.Ace.Headers
             return this;
         }
 
-        /// <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;
-        }
-
         public CompressionType GetCompressionType(byte value) =>
             value switch
             {

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

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Arj.Headers;
 using SharpCompress.Crypto;
 
@@ -33,13 +31,13 @@ namespace SharpCompress.Common.Ace.Headers
             (byte)'*',
         ];
 
-        public AceHeader(IArchiveEncoding archiveEncoding, AceHeaderType type)
+        public AceHeader(ArchiveEncoding archiveEncoding, AceHeaderType type)
         {
             AceHeaderType = type;
             ArchiveEncoding = archiveEncoding;
         }
 
-        public IArchiveEncoding ArchiveEncoding { get; }
+        public ArchiveEncoding ArchiveEncoding { get; }
         public AceHeaderType AceHeaderType { get; }
 
         public ushort HeaderFlags { get; set; }
@@ -60,11 +58,6 @@ namespace SharpCompress.Common.Ace.Headers
 
         public abstract AceHeader? Read(Stream reader);
 
-        public abstract ValueTask<AceHeader?> ReadAsync(
-            Stream reader,
-            CancellationToken cancellationToken = default
-        );
-
         public byte[] ReadHeader(Stream stream)
         {
             // Read header CRC (2 bytes) and header size (2 bytes)
@@ -97,41 +90,6 @@ namespace SharpCompress.Common.Ace.Headers
             return body;
         }
 
-        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.ReadAsync(headerBytes, 0, 4, cancellationToken) != 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 (await stream.ReadAsync(body, 0, HeaderSize, cancellationToken) != HeaderSize)
-            {
-                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
@@ -147,26 +105,6 @@ namespace SharpCompress.Common.Ace.Headers
             return CheckMagicBytes(bytes, 7);
         }
 
-        /// <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.ReadAsync(bytes, 0, 14, cancellationToken) != 14)
-            {
-                return false;
-            }
-
-            return CheckMagicBytes(bytes, 7);
-        }
-
         protected static bool CheckMagicBytes(byte[] headerBytes, int offset)
         {
             // Check for "**ACE**" at specified offset

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

@@ -2,8 +2,6 @@ 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;
@@ -24,7 +22,7 @@ namespace SharpCompress.Common.Ace.Headers
         public List<byte> Comment { get; set; } = new();
         public byte AceVersion { get; private set; }
 
-        public AceMainHeader(IArchiveEncoding archiveEncoding)
+        public AceMainHeader(ArchiveEncoding archiveEncoding)
             : base(archiveEncoding, AceHeaderType.MAIN) { }
 
         /// <summary>
@@ -95,77 +93,5 @@ namespace SharpCompress.Common.Ace.Headers
 
             return this;
         }
-
-        /// <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/Arc/ArcEntryHeader.cs

@@ -7,7 +7,7 @@ namespace SharpCompress.Common.Arc
 {
     public class ArcEntryHeader
     {
-        public IArchiveEncoding ArchiveEncoding { get; }
+        public ArchiveEncoding ArchiveEncoding { get; }
         public CompressionType CompressionMethod { get; private set; }
         public string? Name { get; private set; }
         public long CompressedSize { get; private set; }
@@ -16,7 +16,7 @@ namespace SharpCompress.Common.Arc
         public long OriginalSize { get; private set; }
         public long DataStartPosition { get; private set; }
 
-        public ArcEntryHeader(IArchiveEncoding archiveEncoding)
+        public ArcEntryHeader(ArchiveEncoding archiveEncoding)
         {
             this.ArchiveEncoding = archiveEncoding;
         }

src/SharpCompress/Common/ArchiveEncoding.cs

@@ -3,11 +3,55 @@ using System.Text;
 
 namespace SharpCompress.Common;
 
-public class ArchiveEncoding : IArchiveEncoding
+public class ArchiveEncoding
 {
-    public Encoding Default { get; set; } = Encoding.Default;
-    public Encoding Password { get; set; } = Encoding.Default;
-    public Encoding UTF8 { get; set; } = Encoding.UTF8;
+    /// <summary>
+    /// Default encoding to use when archive format doesn't specify one.
+    /// </summary>
+    public Encoding? Default { get; set; }
+
+    /// <summary>
+    /// ArchiveEncoding used by encryption schemes which don't comply with RFC 2898.
+    /// </summary>
+    public Encoding? Password { get; set; }
+
+    /// <summary>
+    /// Set this encoding when you want to force it for all encoding operations.
+    /// </summary>
     public Encoding? Forced { get; set; }
-    public Func<byte[], int, int, EncodingType, string>? CustomDecoder { get; set; }
+
+    /// <summary>
+    /// Set this when you want to use a custom method for all decoding operations.
+    /// </summary>
+    /// <returns>string Func(bytes, index, length)</returns>
+    public Func<byte[], int, int, string>? CustomDecoder { get; set; }
+
+    public ArchiveEncoding()
+        : this(Encoding.Default, Encoding.Default) { }
+
+    public ArchiveEncoding(Encoding def, Encoding password)
+    {
+        Default = def;
+        Password = password;
+    }
+
+#if !NETFRAMEWORK
+    static ArchiveEncoding() => Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+#endif
+
+    public string Decode(byte[] bytes) => Decode(bytes, 0, bytes.Length);
+
+    public string Decode(byte[] bytes, int start, int length) =>
+        GetDecoder().Invoke(bytes, start, length);
+
+    public string DecodeUTF8(byte[] bytes) => Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+
+    public byte[] Encode(string str) => GetEncoding().GetBytes(str);
+
+    public Encoding GetEncoding() => Forced ?? Default ?? Encoding.UTF8;
+
+    public Encoding GetPasswordEncoding() => Password ?? Encoding.UTF8;
+
+    public Func<byte[], int, int, string> GetDecoder() =>
+        CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
 }

src/SharpCompress/Common/ArchiveEncodingExtensions.cs

@@ -1,87 +0,0 @@
-using System;
-using System.Text;
-
-namespace SharpCompress.Common;
-
-/// <summary>
-/// Specifies the type of encoding to use.
-/// </summary>
-public enum EncodingType
-{
-    /// <summary>
-    /// Uses the default encoding.
-    /// </summary>
-    Default,
-
-    /// <summary>
-    /// Uses UTF-8 encoding.
-    /// </summary>
-    UTF8,
-}
-
-/// <summary>
-/// Provides extension methods for archive encoding.
-/// </summary>
-public static class ArchiveEncodingExtensions
-{
-#if !NETFRAMEWORK
-    /// <summary>
-    /// Registers the code pages encoding provider.
-    /// </summary>
-    static ArchiveEncodingExtensions() =>
-        Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-#endif
-
-    extension(IArchiveEncoding encoding)
-    {
-        /// <summary>
-        /// Gets the encoding based on the archive encoding settings.
-        /// </summary>
-        /// <param name="useUtf8">Whether to use UTF-8.</param>
-        /// <returns>The encoding.</returns>
-        public Encoding GetEncoding(bool useUtf8 = false) =>
-            encoding.Forced ?? (useUtf8 ? encoding.UTF8 : encoding.Default);
-
-        /// <summary>
-        /// Gets the decoder function for the archive encoding.
-        /// </summary>
-        /// <returns>The decoder function.</returns>
-        public Func<byte[], int, int, EncodingType, string> GetDecoder() =>
-            encoding.CustomDecoder
-            ?? (
-                (bytes, index, count, type) =>
-                    encoding.GetEncoding(type == EncodingType.UTF8).GetString(bytes, index, count)
-            );
-
-        /// <summary>
-        /// Encodes a string using the default encoding.
-        /// </summary>
-        /// <param name="str">The string to encode.</param>
-        /// <returns>The encoded bytes.</returns>
-        public byte[] Encode(string str) => encoding.Default.GetBytes(str);
-
-        /// <summary>
-        /// Decodes bytes using the specified encoding type.
-        /// </summary>
-        /// <param name="bytes">The bytes to decode.</param>
-        /// <param name="type">The encoding type.</param>
-        /// <returns>The decoded string.</returns>
-        public string Decode(byte[] bytes, EncodingType type = EncodingType.Default) =>
-            encoding.Decode(bytes, 0, bytes.Length, type);
-
-        /// <summary>
-        /// Decodes a portion of bytes using the specified encoding type.
-        /// </summary>
-        /// <param name="bytes">The bytes to decode.</param>
-        /// <param name="start">The start index.</param>
-        /// <param name="length">The length.</param>
-        /// <param name="type">The encoding type.</param>
-        /// <returns>The decoded string.</returns>
-        public string Decode(
-            byte[] bytes,
-            int start,
-            int length,
-            EncodingType type = EncodingType.Default
-        ) => encoding.GetDecoder()(bytes, start, length, type);
-    }
-}

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

@@ -3,7 +3,6 @@ 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;
@@ -32,11 +31,6 @@ namespace SharpCompress.Common.Arj.Headers
 
         public abstract ArjHeader? Read(Stream reader);
 
-        public abstract ValueTask<ArjHeader?> ReadAsync(
-            Stream reader,
-            CancellationToken cancellationToken = default
-        );
-
         public byte[] ReadHeader(Stream stream)
         {
             // check for magic bytes
@@ -78,102 +72,6 @@ namespace SharpCompress.Common.Arj.Headers
             return body;
         }
 
-        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[] crc = new byte[4];
-                bytesRead = await reader.ReadAsync(crc, 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(crc, 0))
-                {
-                    throw new InvalidDataException("Extended header checksum is invalid");
-                }
-
-                extendedHeader.Add(header);
-            }
-        }
-
         protected List<byte[]> ReadExtendedHeaders(Stream reader)
         {
             List<byte[]> extendedHeader = new List<byte[]>();
@@ -251,26 +149,6 @@ namespace SharpCompress.Common.Arj.Headers
             return CheckMagicBytes(bytes);
         }
 
-        /// <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);
-        }
-
         protected static bool CheckMagicBytes(byte[] headerBytes)
         {
             var magicValue = (ushort)(headerBytes[0] | headerBytes[1] << 8);

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

@@ -4,7 +4,6 @@ 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
@@ -56,22 +55,6 @@ namespace SharpCompress.Common.Arj.Headers
             return null;
         }
 
-        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;
-        }
-
         public ArjLocalHeader LoadFrom(byte[] headerBytes)
         {
             int offset = 0;

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

@@ -1,8 +1,6 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Crypto;
 
@@ -47,16 +45,6 @@ namespace SharpCompress.Common.Arj.Headers
             return LoadFrom(body);
         }
 
-        public override async ValueTask<ArjHeader?> ReadAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var body = await ReadHeaderAsync(stream, cancellationToken);
-            await ReadExtendedHeadersAsync(stream, cancellationToken);
-            return LoadFrom(body);
-        }
-
         public ArjMainHeader LoadFrom(byte[] headerBytes)
         {
             var offset = 1;

src/SharpCompress/Common/AsyncBinaryReader.cs

@@ -1,103 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common
-{
-    public sealed class AsyncBinaryReader : IDisposable
-    {
-        private readonly Stream _stream;
-        private readonly Stream _originalStream;
-        private readonly bool _leaveOpen;
-        private readonly byte[] _buffer = new byte[8];
-        private bool _disposed;
-
-        public AsyncBinaryReader(Stream stream, bool leaveOpen = false, int bufferSize = 4096)
-        {
-            _originalStream = stream ?? throw new ArgumentNullException(nameof(stream));
-            _leaveOpen = leaveOpen;
-
-            // Use the stream directly without wrapping in BufferedStream
-            // BufferedStream uses synchronous Read internally which doesn't work with async-only streams
-            // SharpCompress uses SharpCompressStream for buffering which supports true async reads
-            _stream = stream;
-        }
-
-        public Stream BaseStream => _stream;
-
-        public async ValueTask<byte> ReadByteAsync(CancellationToken ct = default)
-        {
-            await _stream.ReadExactAsync(_buffer, 0, 1, ct).ConfigureAwait(false);
-            return _buffer[0];
-        }
-
-        public async ValueTask<ushort> ReadUInt16Async(CancellationToken ct = default)
-        {
-            await _stream.ReadExactAsync(_buffer, 0, 2, ct).ConfigureAwait(false);
-            return BinaryPrimitives.ReadUInt16LittleEndian(_buffer);
-        }
-
-        public async ValueTask<uint> ReadUInt32Async(CancellationToken ct = default)
-        {
-            await _stream.ReadExactAsync(_buffer, 0, 4, ct).ConfigureAwait(false);
-            return BinaryPrimitives.ReadUInt32LittleEndian(_buffer);
-        }
-
-        public async ValueTask<ulong> ReadUInt64Async(CancellationToken ct = default)
-        {
-            await _stream.ReadExactAsync(_buffer, 0, 8, ct).ConfigureAwait(false);
-            return BinaryPrimitives.ReadUInt64LittleEndian(_buffer);
-        }
-
-        public async ValueTask ReadBytesAsync(
-            byte[] bytes,
-            int offset,
-            int count,
-            CancellationToken ct = default
-        )
-        {
-            await _stream.ReadExactAsync(bytes, offset, count, ct).ConfigureAwait(false);
-        }
-
-        public async ValueTask SkipAsync(int count, CancellationToken ct = default)
-        {
-            await _stream.SkipAsync(count, ct).ConfigureAwait(false);
-        }
-
-        public void Dispose()
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            _disposed = true;
-
-            // Dispose the original stream if we own it
-            if (!_leaveOpen)
-            {
-                _originalStream.Dispose();
-            }
-        }
-
-#if NET6_0_OR_GREATER
-        public async ValueTask DisposeAsync()
-        {
-            if (_disposed)
-            {
-                return;
-            }
-
-            _disposed = true;
-
-            // Dispose the original stream if we own it
-            if (!_leaveOpen)
-            {
-                await _originalStream.DisposeAsync().ConfigureAwait(false);
-            }
-        }
-#endif
-    }
-}

src/SharpCompress/Common/Constants.cs

@@ -0,0 +1,10 @@
+namespace SharpCompress.Common;
+
+public static class Constants
+{
+    /// <summary>
+    /// The default buffer size for stream operations, matching .NET's Stream.CopyTo default of 81920 bytes.
+    /// This can be modified globally at runtime.
+    /// </summary>
+    public static int BufferSize { get; set; } = 81920;
+}

src/SharpCompress/Common/EntryStream.cs

@@ -56,7 +56,7 @@ public class EntryStream : Stream, IStreamStack
     /// <summary>
     /// Asynchronously skip the rest of the entry stream.
     /// </summary>
-    public async ValueTask SkipEntryAsync(CancellationToken cancellationToken = default)
+    public async Task SkipEntryAsync(CancellationToken cancellationToken = default)
     {
         await this.SkipAsync(cancellationToken).ConfigureAwait(false);
         _completed = true;

src/SharpCompress/Common/ExtractionMethods.cs

@@ -124,11 +124,11 @@ internal static class ExtractionMethods
         }
     }
 
-    public static async ValueTask WriteEntryToDirectoryAsync(
+    public static async Task WriteEntryToDirectoryAsync(
         IEntry entry,
         string destinationDirectory,
         ExtractionOptions? options,
-        Func<string, ExtractionOptions?, CancellationToken, ValueTask> writeAsync,
+        Func<string, ExtractionOptions?, CancellationToken, Task> writeAsync,
         CancellationToken cancellationToken = default
     )
     {
@@ -197,11 +197,11 @@ internal static class ExtractionMethods
         }
     }
 
-    public static async ValueTask WriteEntryToFileAsync(
+    public static async Task WriteEntryToFileAsync(
         IEntry entry,
         string destinationFileName,
         ExtractionOptions? options,
-        Func<string, FileMode, CancellationToken, ValueTask> openAndWriteAsync,
+        Func<string, FileMode, CancellationToken, Task> openAndWriteAsync,
         CancellationToken cancellationToken = default
     )
     {

src/SharpCompress/Common/FilePart.cs

@@ -1,14 +1,12 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common;
 
 public abstract class FilePart
 {
-    protected FilePart(IArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding;
+    protected FilePart(ArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding;
 
-    internal IArchiveEncoding ArchiveEncoding { get; }
+    internal ArchiveEncoding ArchiveEncoding { get; }
 
     internal abstract string? FilePartName { get; }
     public int Index { get; set; }
@@ -16,8 +14,4 @@ public abstract class FilePart
     internal abstract Stream? GetCompressedStream();
     internal abstract Stream? GetRawStream();
     internal bool Skipped { get; set; }
-
-    internal virtual ValueTask<Stream?> GetCompressedStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => new(GetCompressedStream());
 }

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -40,6 +40,6 @@ public class GZipEntry : Entry
 
     internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
     {
-        yield return new GZipEntry(GZipFilePart.Create(stream, options.ArchiveEncoding));
+        yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
     }
 }

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -2,8 +2,6 @@ using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
@@ -15,58 +13,28 @@ internal sealed class GZipFilePart : FilePart
     private string? _name;
     private readonly Stream _stream;
 
-    internal static GZipFilePart Create(Stream stream, IArchiveEncoding archiveEncoding)
+    internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
+        : base(archiveEncoding)
     {
-        var part = new GZipFilePart(stream, archiveEncoding);
-
-        part.ReadAndValidateGzipHeader();
+        _stream = stream;
+        ReadAndValidateGzipHeader();
         if (stream.CanSeek)
         {
             var position = stream.Position;
             stream.Position = stream.Length - 8;
-            part.ReadTrailer();
+            ReadTrailer();
             stream.Position = position;
-            part.EntryStartPosition = position;
+            EntryStartPosition = position;
         }
         else
         {
             // For non-seekable streams, we can't read the trailer or track position.
             // Set to 0 since the stream will be read sequentially from its current position.
-            part.EntryStartPosition = 0;
+            EntryStartPosition = 0;
         }
-        return part;
     }
 
-    internal static async ValueTask<GZipFilePart> CreateAsync(
-        Stream stream,
-        IArchiveEncoding archiveEncoding,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var part = new GZipFilePart(stream, archiveEncoding);
-
-        await part.ReadAndValidateGzipHeaderAsync(cancellationToken);
-        if (stream.CanSeek)
-        {
-            var position = stream.Position;
-            stream.Position = stream.Length - 8;
-            await part.ReadTrailerAsync(cancellationToken);
-            stream.Position = position;
-            part.EntryStartPosition = position;
-        }
-        else
-        {
-            // For non-seekable streams, we can't read the trailer or track position.
-            // Set to 0 since the stream will be read sequentially from its current position.
-            part.EntryStartPosition = 0;
-        }
-        return part;
-    }
-
-    private GZipFilePart(Stream stream, IArchiveEncoding archiveEncoding)
-        : base(archiveEncoding) => _stream = stream;
-
-    internal long EntryStartPosition { get; private set; }
+    internal long EntryStartPosition { get; }
 
     internal DateTime? DateModified { get; private set; }
     internal uint? Crc { get; private set; }
@@ -83,22 +51,12 @@ internal sealed class GZipFilePart : FilePart
     {
         // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
         Span<byte> trailer = stackalloc byte[8];
-        _stream.ReadFully(trailer);
+        var n = _stream.Read(trailer);
 
         Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
         UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.Slice(4));
     }
 
-    private async ValueTask ReadTrailerAsync(CancellationToken cancellationToken = default)
-    {
-        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-        var trailer = new byte[8];
-        _ = await _stream.ReadFullyAsync(trailer, 0, 8, cancellationToken);
-
-        Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
-        UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.AsSpan().Slice(4));
-    }
-
     private void ReadAndValidateGzipHeader()
     {
         // read the header on the first read
@@ -151,61 +109,6 @@ internal sealed class GZipFilePart : FilePart
         }
     }
 
-    private async ValueTask ReadAndValidateGzipHeaderAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        // read the header on the first read
-        var header = new byte[10];
-        var n = await _stream.ReadAsync(header, 0, 10, cancellationToken);
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (n == 0)
-        {
-            return;
-        }
-
-        if (n != 10)
-        {
-            throw new ZlibException("Not a valid GZIP stream.");
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            throw new ZlibException("Bad GZIP header.");
-        }
-
-        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan().Slice(4));
-        DateModified = TarHeader.EPOCH.AddSeconds(timet);
-        if ((header[3] & 0x04) == 0x04)
-        {
-            // read and discard extra field
-            var lengthField = new byte[2];
-            _ = await _stream.ReadAsync(lengthField, 0, 2, cancellationToken);
-
-            var extraLength = (short)(lengthField[0] + (lengthField[1] * 256));
-            var extra = new byte[extraLength];
-
-            if (!await _stream.ReadFullyAsync(extra, cancellationToken))
-            {
-                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
-            }
-        }
-        if ((header[3] & 0x08) == 0x08)
-        {
-            _name = await ReadZeroTerminatedStringAsync(_stream, cancellationToken);
-        }
-        if ((header[3] & 0x10) == 0x010)
-        {
-            await ReadZeroTerminatedStringAsync(_stream, cancellationToken);
-        }
-        if ((header[3] & 0x02) == 0x02)
-        {
-            var buf = new byte[1];
-            _ = await _stream.ReadAsync(buf, 0, 1, cancellationToken); // CRC16, ignore
-        }
-    }
-
     private string ReadZeroTerminatedString(Stream stream)
     {
         Span<byte> buf1 = stackalloc byte[1];
@@ -231,33 +134,4 @@ internal sealed class GZipFilePart : FilePart
         var buffer = list.ToArray();
         return ArchiveEncoding.Decode(buffer);
     }
-
-    private async ValueTask<string> ReadZeroTerminatedStringAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var buf1 = new byte[1];
-        var list = new List<byte>();
-        var done = false;
-        do
-        {
-            // workitem 7740
-            var n = await stream.ReadAsync(buf1, 0, 1, cancellationToken);
-            if (n != 1)
-            {
-                throw new ZlibException("Unexpected EOF reading GZIP header.");
-            }
-            if (buf1[0] == 0)
-            {
-                done = true;
-            }
-            else
-            {
-                list.Add(buf1[0]);
-            }
-        } while (!done);
-        var buffer = list.ToArray();
-        return ArchiveEncoding.Decode(buffer);
-    }
 }

src/SharpCompress/Common/IArchiveEncoding.cs

@@ -1,36 +0,0 @@
-using System;
-using System.Text;
-
-namespace SharpCompress.Common;
-
-/// <summary>
-/// Defines the encoding settings for archives.
-/// </summary>
-public interface IArchiveEncoding
-{
-    /// <summary>
-    /// Default encoding to use when archive format doesn't specify one.  Required and defaults to Encoding.Default.
-    /// </summary>
-    public Encoding Default { get; set; }
-
-    /// <summary>
-    /// ArchiveEncoding used by encryption schemes which don't comply with RFC 2898. Required and defaults to Encoding.Default.
-    /// </summary>
-    public Encoding Password { get; set; }
-
-    /// <summary>
-    /// Default encoding to use when archive format specifies UTF-8 encoding. Required and defaults to Encoding.UTF8.
-    /// </summary>
-    public Encoding UTF8 { get; set; }
-
-    /// <summary>
-    /// Set this encoding when you want to force it for all encoding operations.
-    /// </summary>
-    public Encoding? Forced { get; set; }
-
-    /// <summary>
-    /// Set this when you want to use a custom method for all decoding operations.
-    /// </summary>
-    /// <returns>string Func(bytes, index, length, EncodingType)</returns>
-    public Func<byte[], int, int, EncodingType, string>? CustomDecoder { get; set; }
-}

src/SharpCompress/Common/OptionsBase.cs

@@ -7,5 +7,5 @@ public class OptionsBase
     /// </summary>
     public bool LeaveStreamOpen { get; set; } = true;
 
-    public IArchiveEncoding ArchiveEncoding { get; set; } = new ArchiveEncoding();
+    public ArchiveEncoding ArchiveEncoding { get; set; } = new();
 }

src/SharpCompress/Common/Rar/AsyncMarkingBinaryReader.cs

@@ -1,177 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common;
-
-namespace SharpCompress.Common.Rar;
-
-internal class AsyncMarkingBinaryReader
-{
-    private readonly AsyncBinaryReader _reader;
-
-    public AsyncMarkingBinaryReader(Stream stream)
-    {
-        _reader = new AsyncBinaryReader(stream, leaveOpen: true);
-    }
-
-    public Stream BaseStream => _reader.BaseStream;
-
-    public virtual long CurrentReadByteCount { get; protected set; }
-
-    public virtual void Mark() => CurrentReadByteCount = 0;
-
-    public virtual async ValueTask<bool> ReadBooleanAsync(
-        CancellationToken cancellationToken = default
-    ) => await ReadByteAsync(cancellationToken).ConfigureAwait(false) != 0;
-
-    public virtual async ValueTask<byte> ReadByteAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount++;
-        return await _reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-    }
-
-    public virtual async ValueTask<byte[]> ReadBytesAsync(
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += count;
-        var bytes = new byte[count];
-        await _reader.ReadBytesAsync(bytes, 0, count,  cancellationToken).ConfigureAwait(false);
-        return bytes;
-    }
-
-    public async ValueTask<ushort> ReadUInt16Async(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += 2;
-        var bytes = await ReadBytesAsync( 2, cancellationToken).ConfigureAwait(false);
-        return BinaryPrimitives.ReadUInt16LittleEndian(bytes);
-    }
-
-    public async ValueTask<uint> ReadUInt32Async(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += 4;
-        var bytes =  await ReadBytesAsync( 4, cancellationToken).ConfigureAwait(false);
-        return BinaryPrimitives.ReadUInt32LittleEndian(bytes);
-    }
-
-    public virtual async ValueTask<ulong> ReadUInt64Async(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += 8;
-        var bytes = await ReadBytesAsync( 8, cancellationToken).ConfigureAwait(false);
-        return BinaryPrimitives.ReadUInt64LittleEndian(bytes);
-    }
-
-    public virtual async ValueTask<short> ReadInt16Async(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += 2;
-        var bytes = await ReadBytesAsync(2, cancellationToken).ConfigureAwait(false);
-        return BinaryPrimitives.ReadInt16LittleEndian(bytes);
-    }
-
-    public virtual async ValueTask<int> ReadInt32Async(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += 4;
-        var bytes =  await ReadBytesAsync( 4, cancellationToken).ConfigureAwait(false);
-        return BinaryPrimitives.ReadInt32LittleEndian(bytes);
-    }
-
-    public virtual async ValueTask<long> ReadInt64Async(
-        CancellationToken cancellationToken = default
-    )
-    {
-        CurrentReadByteCount += 8;
-        var bytes =  await ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
-        return BinaryPrimitives.ReadInt64LittleEndian(bytes);
-    }
-
-    public async ValueTask<ulong> ReadRarVIntAsync(
-        CancellationToken cancellationToken = default,
-        int maxBytes = 10
-    ) => await DoReadRarVIntAsync((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false);
-
-    private async ValueTask<ulong> DoReadRarVIntAsync(
-        int maxShift,
-        CancellationToken cancellationToken
-    )
-    {
-        var shift = 0;
-        ulong result = 0;
-        do
-        {
-            var b0 = await ReadByteAsync(cancellationToken).ConfigureAwait(false);
-            var b1 = ((uint)b0) & 0x7f;
-            ulong n = b1;
-            var shifted = n << shift;
-            if (n != shifted >> shift)
-            {
-                // overflow
-                break;
-            }
-            result |= shifted;
-            if (b0 == b1)
-            {
-                return result;
-            }
-            shift += 7;
-        } while (shift <= maxShift);
-
-        throw new FormatException("malformed vint");
-    }
-    public async ValueTask<uint> ReadRarVIntUInt32Async(int maxBytes = 5, CancellationToken cancellationToken = default) =>
-        // hopefully this gets inlined
-        await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false);
-
-    public async ValueTask<ushort> ReadRarVIntUInt16Async(int maxBytes = 3, CancellationToken cancellationToken = default) =>
-        // hopefully this gets inlined
-        checked((ushort)await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false));
-    public async ValueTask<byte> ReadRarVIntByteAsync(int maxBytes = 2, CancellationToken cancellationToken = default) =>
-        // hopefully this gets inlined
-        checked((byte)await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false));
-
-    public async ValueTask SkipAsync(int count, CancellationToken cancellationToken = default)
-    {
-        CurrentReadByteCount += count;
-        await _reader.SkipAsync(count, cancellationToken).ConfigureAwait(false);
-    }
-
-    private async ValueTask<uint> DoReadRarVIntUInt32Async(int maxShift, CancellationToken cancellationToken = default)
-    {
-        var shift = 0;
-        uint result = 0;
-        do
-        {
-            var b0 = await ReadByteAsync(cancellationToken).ConfigureAwait(false);
-            var b1 = ((uint)b0) & 0x7f;
-            var n = b1;
-            var shifted = n << shift;
-            if (n != shifted >> shift)
-            {
-                // overflow
-                break;
-            }
-            result |= shifted;
-            if (b0 == b1)
-            {
-                return result;
-            }
-            shift += 7;
-        } while (shift <= maxShift);
-
-        throw new FormatException("malformed vint");
-    }
-}

src/SharpCompress/Common/Rar/AsyncRarCrcBinaryReader.cs

@@ -1,45 +0,0 @@
-using System;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Compressors.Rar;
-
-namespace SharpCompress.Common.Rar;
-
-internal class AsyncRarCrcBinaryReader(Stream stream) : AsyncMarkingBinaryReader(stream)
-{
-    private uint _currentCrc;
-
-    public uint GetCrc32() => ~_currentCrc;
-
-    public void ResetCrc() => _currentCrc = 0xffffffff;
-
-    protected void UpdateCrc(byte b) => _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
-
-    protected async ValueTask<byte[]> ReadBytesNoCrcAsync(
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        return await base.ReadBytesAsync(count, cancellationToken).ConfigureAwait(false);
-    }
-
-    public override async ValueTask<byte> ReadByteAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        var b = await base.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-        _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
-        return b;
-    }
-
-    public override async ValueTask<byte[]> ReadBytesAsync(
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var result = await base.ReadBytesAsync(count, cancellationToken).ConfigureAwait(false);
-        _currentCrc = RarCRC.CheckCrc(_currentCrc, result, 0, result.Length);
-        return result;
-    }
-}

src/SharpCompress/Common/Rar/AsyncRarCryptoBinaryReader.cs

@@ -1,108 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Rar;
-
-internal sealed class AsyncRarCryptoBinaryReader : AsyncRarCrcBinaryReader
-{
-    private BlockTransformer _rijndael = default!;
-    private readonly Queue<byte> _data = new();
-    private long _readCount;
-
-    private AsyncRarCryptoBinaryReader(Stream stream)
-        : base(stream)
-    {
-    }
-
-    public static async ValueTask<AsyncRarCryptoBinaryReader> Create(Stream stream, ICryptKey cryptKey, byte[]? salt = null)
-    {
-        var binary = new AsyncRarCryptoBinaryReader(stream);
-        if (salt == null)
-        {
-            salt = await binary.ReadBytesAsyncBase(EncryptionConstV5.SIZE_SALT30);
-            binary._readCount += EncryptionConstV5.SIZE_SALT30;
-        }
-        binary._rijndael = new BlockTransformer(cryptKey.Transformer(salt));
-        return binary;
-    }
-
-
-    public override long CurrentReadByteCount
-    {
-        get => _readCount;
-        protected set
-        {
-            // ignore
-        }
-    }
-
-    public override void Mark() => _readCount = 0;
-
-    public override async ValueTask<byte> ReadByteAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        var bytes = await ReadAndDecryptBytesAsync(1, cancellationToken).ConfigureAwait(false);
-        return bytes[0];
-    }
-
-    private ValueTask<byte[]> ReadBytesAsyncBase(int count) => base.ReadBytesAsync(count);
-
-    public override async ValueTask<byte[]> ReadBytesAsync(
-        int count,
-        CancellationToken cancellationToken = default
-    )
-    {
-        return await ReadAndDecryptBytesAsync(count, cancellationToken).ConfigureAwait(false);
-    }
-
-    private async ValueTask<byte[]> ReadAndDecryptBytesAsync(
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        var queueSize = _data.Count;
-        var sizeToRead = count - queueSize;
-
-        if (sizeToRead > 0)
-        {
-            var alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
-            for (var i = 0; i < alignedSize / 16; i++)
-            {
-                var cipherText = await ReadBytesNoCrcAsync(16, cancellationToken)
-                    .ConfigureAwait(false);
-                var readBytes = _rijndael.ProcessBlock(cipherText);
-                foreach (var readByte in readBytes)
-                {
-                    _data.Enqueue(readByte);
-                }
-            }
-        }
-
-        var decryptedBytes = new byte[count];
-
-        for (var i = 0; i < count; i++)
-        {
-            var b = _data.Dequeue();
-            decryptedBytes[i] = b;
-            UpdateCrc(b);
-        }
-
-        _readCount += count;
-        return decryptedBytes;
-    }
-
-    public void ClearQueue() => _data.Clear();
-
-    public void SkipQueue()
-    {
-        var position = BaseStream.Position;
-        BaseStream.Position = position + _data.Count;
-        ClearQueue();
-    }
-}

src/SharpCompress/Common/Rar/Headers/AVHeader.cs

@@ -4,14 +4,13 @@ namespace SharpCompress.Common.Rar.Headers;
 
 internal class AvHeader : RarHeader
 {
-    public static AvHeader Create(RarHeader header, RarCrcBinaryReader reader)
+    public AvHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Av)
     {
-        var c = CreateChild<AvHeader>(header, reader, HeaderType.Av);
-        if (c.IsRar5)
+        if (IsRar5)
         {
             throw new InvalidFormatException("unexpected rar5 record");
         }
-        return c;
     }
 
     protected override void ReadFinish(MarkingBinaryReader reader)

src/SharpCompress/Common/Rar/Headers/ArchiveCryptHeader.cs

@@ -1,40 +1,16 @@
 #nullable disable
 
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
 internal class ArchiveCryptHeader : RarHeader
 {
-    public static ArchiveCryptHeader Create(RarHeader header, RarCrcBinaryReader reader) =>
-        CreateChild<ArchiveCryptHeader>(header, reader, HeaderType.Crypt);
+    public ArchiveCryptHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Crypt) { }
 
-    public static async ValueTask<ArchiveCryptHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<ArchiveCryptHeader>(
-                header,
-                reader,
-                HeaderType.Crypt,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-
-    public Rar5CryptoInfo CryptInfo = default!;
+    public Rar5CryptoInfo CryptInfo = new();
 
     protected override void ReadFinish(MarkingBinaryReader reader) =>
-        CryptInfo = Rar5CryptoInfo.Create(reader, false);
-
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        CryptInfo = await Rar5CryptoInfo.CreateAsync(reader, false);
-    }
+        CryptInfo = new Rar5CryptoInfo(reader, false);
 }

src/SharpCompress/Common/Rar/Headers/ArchiveHeader.cs

@@ -1,22 +1,11 @@
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
 internal sealed class ArchiveHeader : RarHeader
 {
-    public static ArchiveHeader Create(RarHeader header, RarCrcBinaryReader reader) =>
-        CreateChild<ArchiveHeader>(header, reader, HeaderType.Archive);
-
-    public static async ValueTask<ArchiveHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<ArchiveHeader>(header, reader, HeaderType.Archive, cancellationToken)
-            .ConfigureAwait(false);
+    public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Archive) { }
 
     protected override void ReadFinish(MarkingBinaryReader reader)
     {
@@ -44,38 +33,6 @@ internal sealed class ArchiveHeader : RarHeader
         }
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        if (IsRar5)
-        {
-            Flags = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
-            {
-                VolumeNumber = (int)
-                    await reader.ReadRarVIntUInt32Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            }
-            // later: we may have a locator record if we need it
-            //if (ExtraSize != 0) {
-            //    ReadLocator(reader);
-            //}
-        }
-        else
-        {
-            Flags = HeaderFlags;
-            HighPosAv = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-            PosAv = await reader.ReadInt32Async(cancellationToken).ConfigureAwait(false);
-            if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
-            {
-                EncryptionVersion = await reader
-                    .ReadByteAsync(cancellationToken)
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     private ushort Flags { get; set; }
 
     private bool HasFlag(ushort flag) => (Flags & flag) == flag;

src/SharpCompress/Common/Rar/Headers/CommentHeader.cs

@@ -4,14 +4,13 @@ namespace SharpCompress.Common.Rar.Headers;
 
 internal class CommentHeader : RarHeader
 {
-    public static CommentHeader Create(RarHeader header, RarCrcBinaryReader reader)
+    protected CommentHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Comment)
     {
-        var c = CreateChild<CommentHeader>(header, reader, HeaderType.Comment);
-        if (c.IsRar5)
+        if (IsRar5)
         {
             throw new InvalidFormatException("unexpected rar5 record");
         }
-        return c;
     }
 
     protected override void ReadFinish(MarkingBinaryReader reader)

src/SharpCompress/Common/Rar/Headers/EndArchiveHeader.cs

@@ -1,27 +1,11 @@
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
-using SharpCompress.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
 internal class EndArchiveHeader : RarHeader
 {
-    public static EndArchiveHeader Create(RarHeader header, RarCrcBinaryReader reader) =>
-        CreateChild<EndArchiveHeader>(header, reader, HeaderType.EndArchive);
-
-    public static async ValueTask<EndArchiveHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<EndArchiveHeader>(
-                header,
-                reader,
-                HeaderType.EndArchive,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
+    public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.EndArchive) { }
 
     protected override void ReadFinish(MarkingBinaryReader reader)
     {
@@ -43,29 +27,6 @@ internal class EndArchiveHeader : RarHeader
         }
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        if (IsRar5)
-        {
-            Flags = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            Flags = HeaderFlags;
-            if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
-            {
-                ArchiveCrc = await reader.ReadInt32Async(cancellationToken).ConfigureAwait(false);
-            }
-            if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
-            {
-                VolumeNumber = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-            }
-        }
-    }
-
     private ushort Flags { get; set; }
 
     private bool HasFlag(ushort flag) => (Flags & flag) == flag;

src/SharpCompress/Common/Rar/Headers/FileHeader.cs

@@ -2,9 +2,6 @@ using System;
 using System.IO;
 using System.Linq;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 #if !Rar2017_64bit
 using size_t = System.UInt32;
@@ -20,20 +17,8 @@ internal class FileHeader : RarHeader
 {
     private byte[]? _hash;
 
-    public static FileHeader Create(
-        RarHeader header,
-        RarCrcBinaryReader reader,
-        HeaderType headerType
-    ) => CreateChild<FileHeader>(header, reader, headerType);
-
-    public static async ValueTask<FileHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        HeaderType headerType,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<FileHeader>(header, reader, headerType, cancellationToken)
-            .ConfigureAwait(false);
+    public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
+        : base(header, reader, headerType) { }
 
     protected override void ReadFinish(MarkingBinaryReader reader)
     {
@@ -47,21 +32,6 @@ internal class FileHeader : RarHeader
         }
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        if (IsRar5)
-        {
-            await ReadFromReaderV5Async(reader, cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            await ReadFromReaderV4Async(reader, cancellationToken).ConfigureAwait(false);
-        }
-    }
-
     private void ReadFromReaderV5(MarkingBinaryReader reader)
     {
         Flags = reader.ReadRarVIntUInt16();
@@ -149,7 +119,7 @@ internal class FileHeader : RarHeader
             {
                 case FHEXTRA_CRYPT: // file encryption
                     {
-                        Rar5CryptoInfo =  Rar5CryptoInfo.Create(reader, true);
+                        Rar5CryptoInfo = new Rar5CryptoInfo(reader, true);
 
                         if (Rar5CryptoInfo.PswCheck.All(singleByte => singleByte == 0))
                         {
@@ -445,391 +415,6 @@ internal class FileHeader : RarHeader
         return path;
     }
 
-    private async ValueTask ReadFromReaderV5Async(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        Flags = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-
-        var lvalue = checked(
-            (long)await reader.ReadRarVIntAsync(cancellationToken: cancellationToken).ConfigureAwait(false)
-        );
-
-        UncompressedSize = HasFlag(FileFlagsV5.UNPACKED_SIZE_UNKNOWN) ? long.MaxValue : lvalue;
-
-        FileAttributes = await reader
-            .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
-            .ConfigureAwait(false);
-
-        if (HasFlag(FileFlagsV5.HAS_MOD_TIME))
-        {
-            FileLastModifiedTime = Utility.UnixTimeToDateTime(
-                await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
-            );
-        }
-
-        if (HasFlag(FileFlagsV5.HAS_CRC32))
-        {
-            FileCrc = await reader.ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
-        }
-
-        var compressionInfo = await reader
-            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
-            .ConfigureAwait(false);
-
-        CompressionAlgorithm = (byte)((compressionInfo & 0x3f) + 50);
-        IsSolid = (compressionInfo & 0x40) == 0x40;
-        CompressionMethod = (byte)((compressionInfo >> 7) & 0x7);
-        WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo >> 10) & 0xf);
-
-        HostOs = await reader.ReadRarVIntByteAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-
-        var nameSize = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-
-        var b = await reader.ReadBytesAsync(nameSize, cancellationToken).ConfigureAwait(false);
-        FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
-
-        if (ExtraSize != (uint)RemainingHeaderBytesAsync(reader))
-        {
-            throw new InvalidFormatException("rar5 header size / extra size inconsistency");
-        }
-
-        const ushort FHEXTRA_CRYPT = 0x01;
-        const ushort FHEXTRA_HASH = 0x02;
-        const ushort FHEXTRA_HTIME = 0x03;
-        const ushort FHEXTRA_REDIR = 0x05;
-
-        while (reader.CurrentReadByteCount < HeaderSize)
-        {
-            var size = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            var n = HeaderSize - reader.CurrentReadByteCount;
-            var type = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            switch (type)
-            {
-                case FHEXTRA_CRYPT:
-                    {
-                        Rar5CryptoInfo = await Rar5CryptoInfo.CreateAsync(reader, true);
-                        if (Rar5CryptoInfo.PswCheck.All(singleByte => singleByte == 0))
-                        {
-                            Rar5CryptoInfo = null;
-                        }
-                    }
-                    break;
-                case FHEXTRA_HASH:
-                    {
-                        const uint FHEXTRA_HASH_BLAKE2 = 0x0;
-                        const int BLAKE2_DIGEST_SIZE = 0x20;
-                        if (
-
-                                await reader
-                                    .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
-                                    .ConfigureAwait(false) == FHEXTRA_HASH_BLAKE2
-                        )
-                        {
-                            _hash = await reader
-                                .ReadBytesAsync(BLAKE2_DIGEST_SIZE, cancellationToken)
-                                .ConfigureAwait(false);
-                        }
-                    }
-                    break;
-                case FHEXTRA_HTIME:
-                    {
-                        var flags = await reader
-                            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        var isWindowsTime = (flags & 1) == 0;
-                        if ((flags & 0x2) == 0x2)
-                        {
-                            FileLastModifiedTime = await ReadExtendedTimeV5Async(
-                                    reader,
-                                    isWindowsTime,
-                                    cancellationToken
-                                )
-                                .ConfigureAwait(false);
-                        }
-                        if ((flags & 0x4) == 0x4)
-                        {
-                            FileCreatedTime = await ReadExtendedTimeV5Async(
-                                    reader,
-                                    isWindowsTime,
-                                    cancellationToken
-                                )
-                                .ConfigureAwait(false);
-                        }
-                        if ((flags & 0x8) == 0x8)
-                        {
-                            FileLastAccessedTime = await ReadExtendedTimeV5Async(
-                                    reader,
-                                    isWindowsTime,
-                                    cancellationToken
-                                )
-                                .ConfigureAwait(false);
-                        }
-                    }
-                    break;
-                case FHEXTRA_REDIR:
-                    {
-                        RedirType = await reader
-                            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        RedirFlags = await reader
-                            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        var nn = await reader
-                            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        var bb = await reader
-                            .ReadBytesAsync(nn, cancellationToken)
-                            .ConfigureAwait(false);
-                        RedirTargetName = ConvertPathV5(Encoding.UTF8.GetString(bb, 0, bb.Length));
-                    }
-                    break;
-                default:
-                    break;
-            }
-            var did = (int)(n - (HeaderSize - reader.CurrentReadByteCount));
-            var drain = size - did;
-            if (drain > 0)
-            {
-                await reader.ReadBytesAsync(drain, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        if (AdditionalDataSize != 0)
-        {
-            CompressedSize = AdditionalDataSize;
-        }
-    }
-
-    private async ValueTask ReadFromReaderV4Async(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        Flags = HeaderFlags;
-        IsSolid = HasFlag(FileFlagsV4.SOLID);
-        WindowSize = IsDirectory
-            ? 0U
-            : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);
-
-        var lowUncompressedSize = await reader
-            .ReadUInt32Async(cancellationToken)
-            .ConfigureAwait(false);
-
-        HostOs = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-
-        FileCrc = await reader.ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
-
-        FileLastModifiedTime = Utility.DosDateToDateTime(
-            await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
-        );
-
-        CompressionAlgorithm = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-        CompressionMethod = (byte)(
-            (await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false)) - 0x30
-        );
-
-        var nameSize = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-
-        FileAttributes = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-
-        uint highCompressedSize = 0;
-        uint highUncompressedkSize = 0;
-        if (HasFlag(FileFlagsV4.LARGE))
-        {
-            highCompressedSize = await reader
-                .ReadUInt32Async(cancellationToken)
-                .ConfigureAwait(false);
-            highUncompressedkSize = await reader
-                .ReadUInt32Async(cancellationToken)
-                .ConfigureAwait(false);
-        }
-        else
-        {
-            if (lowUncompressedSize == 0xffffffff)
-            {
-                lowUncompressedSize = 0xffffffff;
-                highUncompressedkSize = int.MaxValue;
-            }
-        }
-        CompressedSize = UInt32To64(highCompressedSize, checked((uint)AdditionalDataSize));
-        UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
-
-        nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
-
-        var fileNameBytes = await reader
-            .ReadBytesAsync(nameSize, cancellationToken)
-            .ConfigureAwait(false);
-
-        const int newLhdSize = 32;
-
-        switch (HeaderCode)
-        {
-            case HeaderCodeV.RAR4_FILE_HEADER:
-                {
-                    if (HasFlag(FileFlagsV4.UNICODE))
-                    {
-                        var length = 0;
-                        while (length < fileNameBytes.Length && fileNameBytes[length] != 0)
-                        {
-                            length++;
-                        }
-                        if (length != nameSize)
-                        {
-                            length++;
-                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
-                        }
-                        else
-                        {
-                            FileName = ArchiveEncoding.Decode(fileNameBytes);
-                        }
-                    }
-                    else
-                    {
-                        FileName = ArchiveEncoding.Decode(fileNameBytes);
-                    }
-                    FileName = ConvertPathV4(FileName);
-                }
-                break;
-            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
-                {
-                    var datasize = HeaderSize - newLhdSize - nameSize;
-                    if (HasFlag(FileFlagsV4.SALT))
-                    {
-                        datasize -= EncryptionConstV5.SIZE_SALT30;
-                    }
-                    if (datasize > 0)
-                    {
-                        SubData = await reader
-                            .ReadBytesAsync(datasize, cancellationToken)
-                            .ConfigureAwait(false);
-                    }
-
-                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes.Take(4).ToArray()))
-                    {
-                        if (SubData is null)
-                        {
-                            throw new InvalidFormatException();
-                        }
-                        RecoverySectors =
-                            SubData[8]
-                            + (SubData[9] << 8)
-                            + (SubData[10] << 16)
-                            + (SubData[11] << 24);
-                    }
-                }
-                break;
-        }
-
-        if (HasFlag(FileFlagsV4.SALT))
-        {
-            R4Salt = await reader.ReadBytesAsync(EncryptionConstV5.SIZE_SALT30, cancellationToken);
-        }
-        if (HasFlag(FileFlagsV4.EXT_TIME))
-        {
-            if (reader.CurrentReadByteCount >= 2)
-            {
-                var extendedFlags = await reader
-                    .ReadUInt16Async(cancellationToken)
-                    .ConfigureAwait(false);
-                if (FileLastModifiedTime is not null)
-                {
-                    FileLastModifiedTime = await ProcessExtendedTimeV4Async(
-                            extendedFlags,
-                            FileLastModifiedTime,
-                            reader,
-                            0,
-                            cancellationToken
-                        )
-                        .ConfigureAwait(false);
-                }
-
-                FileCreatedTime = await ProcessExtendedTimeV4Async(
-                        extendedFlags,
-                        null,
-                        reader,
-                        1,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-                FileLastAccessedTime = await ProcessExtendedTimeV4Async(
-                        extendedFlags,
-                        null,
-                        reader,
-                        2,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-                FileArchivedTime = await ProcessExtendedTimeV4Async(
-                        extendedFlags,
-                        null,
-                        reader,
-                        3,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
-    private static async ValueTask<DateTime> ReadExtendedTimeV5Async(
-        AsyncMarkingBinaryReader reader,
-        bool isWindowsTime,
-        CancellationToken cancellationToken
-    )
-    {
-        if (isWindowsTime)
-        {
-            return DateTime.FromFileTime(
-                await reader.ReadInt64Async(cancellationToken).ConfigureAwait(false)
-            );
-        }
-        else
-        {
-            return Utility.UnixTimeToDateTime(
-                await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
-            );
-        }
-    }
-
-    private static async ValueTask<DateTime?> ProcessExtendedTimeV4Async(
-        ushort extendedFlags,
-        DateTime? time,
-        AsyncMarkingBinaryReader reader,
-        int i,
-        CancellationToken cancellationToken
-    )
-    {
-        var rmode = (uint)extendedFlags >> ((3 - i) * 4);
-        if ((rmode & 8) == 0)
-        {
-            return null;
-        }
-        if (i != 0)
-        {
-            var dosTime = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-            time = Utility.DosDateToDateTime(dosTime);
-        }
-        if ((rmode & 4) == 0 && time is not null)
-        {
-            time = time.Value.AddSeconds(1);
-        }
-        uint nanosecondHundreds = 0;
-        var count = (int)rmode & 3;
-        for (var j = 0; j < count; j++)
-        {
-            var b = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-            nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
-        }
-
-        if (time is not null)
-        {
-            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
-        }
-        return null;
-    }
-
     public override string ToString() => FileName ?? "FileHeader";
 
     private ushort Flags { get; set; }

src/SharpCompress/Common/Rar/Headers/MarkHeader.cs

@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Rar.Headers;
 
@@ -27,19 +25,6 @@ internal class MarkHeader : IRarHeader
         throw new EndOfStreamException();
     }
 
-    private static async Task<byte> GetByteAsync(Stream stream, CancellationToken cancellationToken)
-    {
-        var buffer = new byte[1];
-        var bytesRead = await stream
-            .ReadAsync(buffer, 0, 1, cancellationToken)
-            .ConfigureAwait(false);
-        if (bytesRead == 1)
-        {
-            return buffer[0];
-        }
-        throw new EndOfStreamException();
-    }
-
     public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
     {
         var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
@@ -144,111 +129,4 @@ internal class MarkHeader : IRarHeader
 
         throw new InvalidFormatException("Rar signature not found");
     }
-
-    public static async ValueTask<MarkHeader> ReadAsync(
-        Stream stream,
-        bool leaveStreamOpen,
-        bool lookForHeader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
-        try
-        {
-            var start = -1;
-            var b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-            start++;
-            while (start <= maxScanIndex)
-            {
-                if (b == 0x52)
-                {
-                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                    start++;
-                    if (b == 0x61)
-                    {
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x72)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x21)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x1a)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x07)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b == 1)
-                        {
-                            b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                            start++;
-                            if (b != 0)
-                            {
-                                continue;
-                            }
-
-                            return new MarkHeader(true); // Rar5
-                        }
-                        else if (b == 0)
-                        {
-                            return new MarkHeader(false); // Rar4
-                        }
-                    }
-                    else if (b == 0x45)
-                    {
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x7e)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x5e)
-                        {
-                            continue;
-                        }
-
-                        throw new InvalidFormatException(
-                            "Rar format version pre-4 is unsupported."
-                        );
-                    }
-                }
-                else
-                {
-                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                    start++;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            if (!leaveStreamOpen)
-            {
-                stream.Dispose();
-            }
-            throw new InvalidFormatException("Error trying to read rar signature.", e);
-        }
-
-        throw new InvalidFormatException("Rar signature not found");
-    }
 }

src/SharpCompress/Common/Rar/Headers/ProtectHeader.cs

@@ -1,40 +1,17 @@
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
+// ProtectHeader is part of the Recovery Record feature
 internal sealed class ProtectHeader : RarHeader
 {
-    public static ProtectHeader Create(RarHeader header, RarCrcBinaryReader reader)
+    public ProtectHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Protect)
     {
-        var c = CreateChild<ProtectHeader>(header, reader, HeaderType.Protect);
-        if (c.IsRar5)
+        if (IsRar5)
         {
             throw new InvalidFormatException("unexpected rar5 record");
         }
-        return c;
-    }
-
-    public static async ValueTask<ProtectHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var c = await CreateChildAsync<ProtectHeader>(
-                header,
-                reader,
-                HeaderType.Protect,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-        if (c.IsRar5)
-        {
-            throw new InvalidFormatException("unexpected rar5 record");
-        }
-        return c;
     }
 
     protected override void ReadFinish(MarkingBinaryReader reader)
@@ -45,17 +22,6 @@ internal sealed class ProtectHeader : RarHeader
         Mark = reader.ReadBytes(8);
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        Version = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-        RecSectors = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
-        TotalBlocks = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-        Mark = await reader.ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
-    }
-
     internal uint DataSize => checked((uint)AdditionalDataSize);
     internal byte Version { get; private set; }
     internal ushort RecSectors { get; private set; }

src/SharpCompress/Common/Rar/Headers/RarHeader.cs

@@ -1,7 +1,4 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
@@ -10,25 +7,18 @@ namespace SharpCompress.Common.Rar.Headers;
 // https://www.rarlab.com/technote.htm
 internal class RarHeader : IRarHeader
 {
-    private HeaderType _headerType;
-    private bool _isRar5;
-
-    protected RarHeader()
-    {
-        ArchiveEncoding = new ArchiveEncoding();
-    }
+    private readonly HeaderType _headerType;
+    private readonly bool _isRar5;
 
     internal static RarHeader? TryReadBase(
         RarCrcBinaryReader reader,
         bool isRar5,
-        IArchiveEncoding archiveEncoding
+        ArchiveEncoding archiveEncoding
     )
     {
         try
         {
-            var header = new RarHeader();
-            header.Initialize(reader, isRar5, archiveEncoding);
-            return header;
+            return new RarHeader(reader, isRar5, archiveEncoding);
         }
         catch (InvalidFormatException)
         {
@@ -36,32 +26,7 @@ internal class RarHeader : IRarHeader
         }
     }
 
-    internal static async ValueTask<RarHeader?> TryReadBaseAsync(
-        AsyncRarCrcBinaryReader reader,
-        bool isRar5,
-        IArchiveEncoding archiveEncoding,
-        CancellationToken cancellationToken = default
-    )
-    {
-        try
-        {
-            var header = new RarHeader();
-            await header
-                .InitializeAsync(reader, isRar5, archiveEncoding, cancellationToken)
-                .ConfigureAwait(false);
-            return header;
-        }
-        catch (InvalidFormatException)
-        {
-            return null;
-        }
-    }
-
-    private void Initialize(
-        RarCrcBinaryReader reader,
-        bool isRar5,
-        IArchiveEncoding archiveEncoding
-    )
+    private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
     {
         _headerType = HeaderType.Null;
         _isRar5 = isRar5;
@@ -99,128 +64,34 @@ internal class RarHeader : IRarHeader
         }
     }
 
-    private async ValueTask InitializeAsync(
-        AsyncRarCrcBinaryReader reader,
-        bool isRar5,
-        IArchiveEncoding archiveEncoding,
-        CancellationToken cancellationToken
-    )
+    protected RarHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
     {
-        _headerType = HeaderType.Null;
-        _isRar5 = isRar5;
-        ArchiveEncoding = archiveEncoding;
-        if (IsRar5)
-        {
-            HeaderCrc = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-            reader.ResetCrc();
-            HeaderSize = (int)
-                await reader.ReadRarVIntUInt32Async( 3, cancellationToken).ConfigureAwait(false);
-            reader.Mark();
-            HeaderCode = await reader.ReadRarVIntByteAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-            HeaderFlags = await reader
-                .ReadRarVIntUInt16Async(2,cancellationToken)
-                .ConfigureAwait(false);
+        _headerType = headerType;
+        _isRar5 = header.IsRar5;
+        HeaderCrc = header.HeaderCrc;
+        HeaderCode = header.HeaderCode;
+        HeaderFlags = header.HeaderFlags;
+        HeaderSize = header.HeaderSize;
+        ExtraSize = header.ExtraSize;
+        AdditionalDataSize = header.AdditionalDataSize;
+        ArchiveEncoding = header.ArchiveEncoding;
+        ReadFinish(reader);
 
-            if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
-            {
-                ExtraSize = await reader
-                    .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
-                    .ConfigureAwait(false);
-            }
-            if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
-            {
-                AdditionalDataSize = (long)
-                    await reader.ReadRarVIntAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-            }
-        }
-        else
-        {
-            reader.Mark();
-            HeaderCrc = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
-            reader.ResetCrc();
-            HeaderCode = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-            HeaderFlags = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
-            HeaderSize = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-            if (HasHeaderFlag(HeaderFlagsV4.HAS_DATA))
-            {
-                AdditionalDataSize = await reader
-                    .ReadUInt32Async(cancellationToken)
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
-    internal static T CreateChild<T>(
-        RarHeader header,
-        RarCrcBinaryReader reader,
-        HeaderType headerType
-    )
-        where T : RarHeader, new()
-    {
-        var child = new T() { ArchiveEncoding = header.ArchiveEncoding };
-        child._headerType = headerType;
-        child._isRar5 = header.IsRar5;
-        child.HeaderCrc = header.HeaderCrc;
-        child.HeaderCode = header.HeaderCode;
-        child.HeaderFlags = header.HeaderFlags;
-        child.HeaderSize = header.HeaderSize;
-        child.ExtraSize = header.ExtraSize;
-        child.AdditionalDataSize = header.AdditionalDataSize;
-        child.ReadFinish(reader);
-
-        var n = child.RemainingHeaderBytes(reader);
+        var n = RemainingHeaderBytes(reader);
         if (n > 0)
         {
             reader.ReadBytes(n);
         }
 
-        child.VerifyHeaderCrc(reader.GetCrc32());
-        return child;
-    }
-
-    internal static async ValueTask<T> CreateChildAsync<T>(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        HeaderType headerType,
-        CancellationToken cancellationToken = default
-    )
-        where T : RarHeader, new()
-    {
-        var child = new T() { ArchiveEncoding = header.ArchiveEncoding };
-        child._headerType = headerType;
-        child._isRar5 = header.IsRar5;
-        child.HeaderCrc = header.HeaderCrc;
-        child.HeaderCode = header.HeaderCode;
-        child.HeaderFlags = header.HeaderFlags;
-        child.HeaderSize = header.HeaderSize;
-        child.ExtraSize = header.ExtraSize;
-        child.AdditionalDataSize = header.AdditionalDataSize;
-        await child.ReadFinishAsync(reader, cancellationToken).ConfigureAwait(false);
-
-        var n = child.RemainingHeaderBytesAsync(reader);
-        if (n > 0)
-        {
-            await reader.ReadBytesAsync(n, cancellationToken).ConfigureAwait(false);
-        }
-
-        child.VerifyHeaderCrc(reader.GetCrc32());
-        return child;
+        VerifyHeaderCrc(reader.GetCrc32());
     }
 
     protected int RemainingHeaderBytes(MarkingBinaryReader reader) =>
         checked(HeaderSize - (int)reader.CurrentReadByteCount);
 
-    protected int RemainingHeaderBytesAsync(AsyncMarkingBinaryReader reader) =>
-        checked(HeaderSize - (int)reader.CurrentReadByteCount);
-
     protected virtual void ReadFinish(MarkingBinaryReader reader) =>
         throw new NotImplementedException();
 
-    protected virtual ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) => throw new NotImplementedException();
-
     private void VerifyHeaderCrc(uint crc32)
     {
         var b = (IsRar5 ? crc32 : (ushort)crc32) == HeaderCrc;
@@ -232,27 +103,27 @@ internal class RarHeader : IRarHeader
 
     public HeaderType HeaderType => _headerType;
 
-    internal bool IsRar5 => _isRar5;
+    protected bool IsRar5 => _isRar5;
 
-    protected uint HeaderCrc { get; private set; }
+    protected uint HeaderCrc { get; }
 
-    internal byte HeaderCode { get; private set; }
+    internal byte HeaderCode { get; }
 
-    protected ushort HeaderFlags { get; private set; }
+    protected ushort HeaderFlags { get; }
 
     protected bool HasHeaderFlag(ushort flag) => (HeaderFlags & flag) == flag;
 
-    protected int HeaderSize { get; private set; }
+    protected int HeaderSize { get; }
 
-    internal IArchiveEncoding ArchiveEncoding { get; private set; }
+    internal ArchiveEncoding ArchiveEncoding { get; }
 
     /// <summary>
     /// Extra header size.
     /// </summary>
-    protected uint ExtraSize { get; private set; }
+    protected uint ExtraSize { get; }
 
     /// <summary>
     /// Size of additional data (eg file contents)
     /// </summary>
-    protected long AdditionalDataSize { get; private set; }
+    protected long AdditionalDataSize { get; }
 }

src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs

@@ -1,10 +1,5 @@
-using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -45,37 +40,6 @@ public class RarHeaderFactory
         }
     }
 
-    public async IAsyncEnumerable<IRarHeader> ReadHeadersAsync(Stream stream)
-    {
-        var markHeader = await MarkHeader
-            .ReadAsync(
-                stream,
-                Options.LeaveStreamOpen,
-                Options.LookForHeader,
-                CancellationToken.None
-            )
-            .ConfigureAwait(false);
-        _isRar5 = markHeader.IsRar5;
-        yield return markHeader;
-
-        RarHeader? header;
-        while (
-            (
-                header = await TryReadNextHeaderAsync(stream, CancellationToken.None)
-                    .ConfigureAwait(false)
-            ) != null
-        )
-        {
-            yield return header;
-            if (header.HeaderType == HeaderType.EndArchive)
-            {
-                // End of archive marker. RAR does not read anything after this header letting to use third
-                // party tools to add extra information such as a digital signature to archive.
-                yield break;
-            }
-        }
-    }
-
     private RarHeader? TryReadNextHeader(Stream stream)
     {
         RarCrcBinaryReader reader;
@@ -97,12 +61,12 @@ public class RarHeaderFactory
                 _cryptInfo.ReadInitV(new MarkingBinaryReader(stream));
                 var _headerKey = new CryptKey5(Options.Password!, _cryptInfo);
 
-                reader = RarCryptoBinaryReader.Create(stream, _headerKey, _cryptInfo.Salt);
+                reader = new RarCryptoBinaryReader(stream, _headerKey, _cryptInfo.Salt);
             }
             else
             {
                 var key = new CryptKey3(Options.Password);
-                reader =  RarCryptoBinaryReader.Create(stream, key);
+                reader = new RarCryptoBinaryReader(stream, key);
             }
         }
 
@@ -116,7 +80,7 @@ public class RarHeaderFactory
             case HeaderCodeV.RAR5_ARCHIVE_HEADER:
             case HeaderCodeV.RAR4_ARCHIVE_HEADER:
             {
-                var ah = ArchiveHeader.Create(header, reader);
+                var ah = new ArchiveHeader(header, reader);
                 if (ah.IsEncrypted == true)
                 {
                     //!!! rar5 we don't know yet
@@ -127,7 +91,7 @@ public class RarHeaderFactory
 
             case HeaderCodeV.RAR4_PROTECT_HEADER:
             {
-                var ph = ProtectHeader.Create(header, reader);
+                var ph = new ProtectHeader(header, reader);
                 // skip the recovery record data, we do not use it.
                 switch (StreamingMode)
                 {
@@ -152,7 +116,7 @@ public class RarHeaderFactory
 
             case HeaderCodeV.RAR5_SERVICE_HEADER:
             {
-                var fh = FileHeader.Create(header, reader, HeaderType.Service);
+                var fh = new FileHeader(header, reader, HeaderType.Service);
                 if (fh.FileName == "CMT")
                 {
                     fh.PackedStream = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
@@ -166,7 +130,7 @@ public class RarHeaderFactory
 
             case HeaderCodeV.RAR4_NEW_SUB_HEADER:
             {
-                var fh = FileHeader.Create(header, reader, HeaderType.NewSub);
+                var fh = new FileHeader(header, reader, HeaderType.NewSub);
                 SkipData(fh, reader);
                 return fh;
             }
@@ -174,7 +138,7 @@ public class RarHeaderFactory
             case HeaderCodeV.RAR5_FILE_HEADER:
             case HeaderCodeV.RAR4_FILE_HEADER:
             {
-                var fh = FileHeader.Create(header, reader, HeaderType.File);
+                var fh = new FileHeader(header, reader, HeaderType.File);
                 switch (StreamingMode)
                 {
                     case StreamingMode.Seekable:
@@ -217,189 +181,11 @@ public class RarHeaderFactory
             case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
             case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
             {
-                return EndArchiveHeader.Create(header, reader);
+                return new EndArchiveHeader(header, reader);
             }
             case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
             {
-                var cryptoHeader = ArchiveCryptHeader.Create(header, reader);
-                IsEncrypted = true;
-                _cryptInfo = cryptoHeader.CryptInfo;
-
-                return cryptoHeader;
-            }
-            default:
-            {
-                throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
-            }
-        }
-    }
-
-    private async ValueTask<RarHeader?> TryReadNextHeaderAsync(
-        Stream stream,
-        CancellationToken cancellationToken
-    )
-    {
-        AsyncRarCrcBinaryReader reader;
-        if (!IsEncrypted)
-        {
-            reader = new AsyncRarCrcBinaryReader(stream);
-        }
-        else
-        {
-            if (Options.Password is null)
-            {
-                throw new CryptographicException(
-                    "Encrypted Rar archive has no password specified."
-                );
-            }
-
-            if (_isRar5 && _cryptInfo != null)
-            {
-                await _cryptInfo.ReadInitVAsync(new AsyncMarkingBinaryReader(stream));
-                var _headerKey = new CryptKey5(Options.Password!, _cryptInfo);
-
-                reader = await AsyncRarCryptoBinaryReader.Create(stream, _headerKey, _cryptInfo.Salt);
-            }
-            else
-            {
-                var key = new CryptKey3(Options.Password);
-                reader = await AsyncRarCryptoBinaryReader.Create(stream, key);
-            }
-        }
-
-        var header = await RarHeader
-            .TryReadBaseAsync(reader, _isRar5, Options.ArchiveEncoding, cancellationToken)
-            .ConfigureAwait(false);
-        if (header is null)
-        {
-            return null;
-        }
-        switch (header.HeaderCode)
-        {
-            case HeaderCodeV.RAR5_ARCHIVE_HEADER:
-            case HeaderCodeV.RAR4_ARCHIVE_HEADER:
-            {
-                var ah = await ArchiveHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-                if (ah.IsEncrypted == true)
-                {
-                    //!!! rar5 we don't know yet
-                    IsEncrypted = true;
-                }
-                return ah;
-            }
-
-            case HeaderCodeV.RAR4_PROTECT_HEADER:
-            {
-                var ph = await ProtectHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-                // skip the recovery record data, we do not use it.
-                switch (StreamingMode)
-                {
-                    case StreamingMode.Seekable:
-                        {
-                            reader.BaseStream.Position += ph.DataSize;
-                        }
-                        break;
-                    case StreamingMode.Streaming:
-                        {
-                            await reader
-                                .BaseStream.SkipAsync(ph.DataSize, cancellationToken)
-                                .ConfigureAwait(false);
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-                return ph;
-            }
-
-            case HeaderCodeV.RAR5_SERVICE_HEADER:
-            {
-                var fh = await FileHeader
-                    .CreateAsync(header, reader, HeaderType.Service, cancellationToken)
-                    .ConfigureAwait(false);
-                if (fh.FileName == "CMT")
-                {
-                    fh.PackedStream = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                }
-                else
-                {
-                    await SkipDataAsync(fh, reader, cancellationToken).ConfigureAwait(false);
-                }
-                return fh;
-            }
-
-            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
-            {
-                var fh = await FileHeader
-                    .CreateAsync(header, reader, HeaderType.NewSub, cancellationToken)
-                    .ConfigureAwait(false);
-                await SkipDataAsync(fh, reader, cancellationToken).ConfigureAwait(false);
-                return fh;
-            }
-
-            case HeaderCodeV.RAR5_FILE_HEADER:
-            case HeaderCodeV.RAR4_FILE_HEADER:
-            {
-                var fh = await FileHeader
-                    .CreateAsync(header, reader, HeaderType.File, cancellationToken)
-                    .ConfigureAwait(false);
-                switch (StreamingMode)
-                {
-                    case StreamingMode.Seekable:
-                        {
-                            fh.DataStartPosition = reader.BaseStream.Position;
-                            reader.BaseStream.Position += fh.CompressedSize;
-                        }
-                        break;
-                    case StreamingMode.Streaming:
-                        {
-                            var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                            if (fh.R4Salt is null && fh.Rar5CryptoInfo is null)
-                            {
-                                fh.PackedStream = ms;
-                            }
-                            else
-                            {
-                                fh.PackedStream = new RarCryptoWrapper(
-                                    ms,
-                                    fh.R4Salt is null
-                                        ? fh.Rar5CryptoInfo.NotNull().Salt
-                                        : fh.R4Salt,
-                                    fh.R4Salt is null
-                                        ? new CryptKey5(
-                                            Options.Password,
-                                            fh.Rar5CryptoInfo.NotNull()
-                                        )
-                                        : new CryptKey3(Options.Password)
-                                );
-                            }
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-                return fh;
-            }
-            case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
-            case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
-            {
-                return await EndArchiveHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-            }
-            case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
-            {
-                var cryptoHeader = await ArchiveCryptHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
+                var cryptoHeader = new ArchiveCryptHeader(header, reader);
                 IsEncrypted = true;
                 _cryptInfo = cryptoHeader.CryptInfo;
 
@@ -434,33 +220,4 @@ public class RarHeaderFactory
             }
         }
     }
-
-    private async ValueTask SkipDataAsync(
-        FileHeader fh,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        switch (StreamingMode)
-        {
-            case StreamingMode.Seekable:
-                {
-                    fh.DataStartPosition = reader.BaseStream.Position;
-                    reader.BaseStream.Position += fh.CompressedSize;
-                }
-                break;
-            case StreamingMode.Streaming:
-                {
-                    //skip the data because it's useless?
-                    await reader
-                        .BaseStream.SkipAsync(fh.CompressedSize, cancellationToken)
-                        .ConfigureAwait(false);
-                }
-                break;
-            default:
-            {
-                throw new InvalidFormatException("Invalid StreamingMode");
-            }
-        }
-    }
 }

src/SharpCompress/Common/Rar/Headers/SignHeader.cs

@@ -4,14 +4,13 @@ namespace SharpCompress.Common.Rar.Headers;
 
 internal class SignHeader : RarHeader
 {
-    public static SignHeader Create(RarHeader header, RarCrcBinaryReader reader)
+    protected SignHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Sign)
     {
-        var c = CreateChild<SignHeader>(header, reader, HeaderType.Sign);
-        if (c.IsRar5)
+        if (IsRar5)
         {
             throw new InvalidFormatException("unexpected rar5 record");
         }
-        return c;
     }
 
     protected override void ReadFinish(MarkingBinaryReader reader)

src/SharpCompress/Common/Rar/Rar5CryptoInfo.cs

@@ -1,7 +1,5 @@
 using System;
 using System.Security.Cryptography;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 
@@ -9,90 +7,44 @@ namespace SharpCompress.Common.Rar;
 
 internal class Rar5CryptoInfo
 {
-    private Rar5CryptoInfo() { }
+    public Rar5CryptoInfo() { }
 
-    public static Rar5CryptoInfo Create(MarkingBinaryReader reader, bool readInitV)
+    public Rar5CryptoInfo(MarkingBinaryReader reader, bool readInitV)
     {
-        var cryptoInfo = new Rar5CryptoInfo();
         var cryptVersion = reader.ReadRarVIntUInt32();
         if (cryptVersion > EncryptionConstV5.VERSION)
         {
             throw new CryptographicException($"Unsupported crypto version of {cryptVersion}");
         }
         var encryptionFlags = reader.ReadRarVIntUInt32();
-        cryptoInfo.UsePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
-        cryptoInfo.LG2Count = reader.ReadRarVIntByte(1);
+        UsePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
+        LG2Count = reader.ReadRarVIntByte(1);
 
-        if (cryptoInfo.LG2Count > EncryptionConstV5.CRYPT5_KDF_LG2_COUNT_MAX)
+        if (LG2Count > EncryptionConstV5.CRYPT5_KDF_LG2_COUNT_MAX)
         {
-            throw new CryptographicException($"Unsupported LG2 count of {cryptoInfo.LG2Count}.");
+            throw new CryptographicException($"Unsupported LG2 count of {LG2Count}.");
         }
 
-        cryptoInfo.Salt = reader.ReadBytes(EncryptionConstV5.SIZE_SALT50);
+        Salt = reader.ReadBytes(EncryptionConstV5.SIZE_SALT50);
 
         if (readInitV) // File header needs to read IV here
         {
-            cryptoInfo.ReadInitV(reader);
+            ReadInitV(reader);
         }
 
-        if (cryptoInfo.UsePswCheck)
+        if (UsePswCheck)
         {
-            cryptoInfo.PswCheck = reader.ReadBytes(EncryptionConstV5.SIZE_PSWCHECK);
+            PswCheck = reader.ReadBytes(EncryptionConstV5.SIZE_PSWCHECK);
             var _pswCheckCsm = reader.ReadBytes(EncryptionConstV5.SIZE_PSWCHECK_CSUM);
 
             var sha = SHA256.Create();
-            cryptoInfo.UsePswCheck = sha.ComputeHash(cryptoInfo.PswCheck).AsSpan().StartsWith(_pswCheckCsm.AsSpan());
+            UsePswCheck = sha.ComputeHash(PswCheck).AsSpan().StartsWith(_pswCheckCsm.AsSpan());
         }
-        return cryptoInfo;
-    }
-
-    public static async ValueTask<Rar5CryptoInfo> CreateAsync(AsyncMarkingBinaryReader reader, bool readInitV)
-    {
-        var cryptoInfo = new Rar5CryptoInfo();
-        var cryptVersion =
-            await reader.ReadRarVIntUInt32Async(cancellationToken: CancellationToken.None);
-        if (cryptVersion > EncryptionConstV5.VERSION)
-        {
-            throw new CryptographicException($"Unsupported crypto version of {cryptVersion}");
-        }
-        var encryptionFlags =
-            await reader.ReadRarVIntUInt32Async(cancellationToken: CancellationToken.None);
-        cryptoInfo.UsePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
-        cryptoInfo.LG2Count = (int)
-            await reader.ReadRarVIntUInt32Async(cancellationToken: CancellationToken.None);
-        if (cryptoInfo.LG2Count > EncryptionConstV5.CRYPT5_KDF_LG2_COUNT_MAX)
-        {
-            throw new CryptographicException($"Unsupported LG2 count of {cryptoInfo.LG2Count}.");
-        }
-
-        cryptoInfo.Salt = await reader
-            .ReadBytesAsync(EncryptionConstV5.SIZE_SALT50, CancellationToken.None);
-
-        if (readInitV)
-        {
-            await cryptoInfo.ReadInitVAsync(reader);
-        }
-
-        if (cryptoInfo.UsePswCheck)
-        {
-            cryptoInfo.PswCheck = await reader
-                .ReadBytesAsync(EncryptionConstV5.SIZE_PSWCHECK, CancellationToken.None);
-            var _pswCheckCsm = await reader
-                .ReadBytesAsync(EncryptionConstV5.SIZE_PSWCHECK_CSUM, CancellationToken.None);
-
-            var sha = SHA256.Create();
-            cryptoInfo.UsePswCheck = sha.ComputeHash(cryptoInfo.PswCheck).AsSpan().StartsWith(_pswCheckCsm.AsSpan());
-        }
-        return cryptoInfo;
     }
 
     public void ReadInitV(MarkingBinaryReader reader) =>
         InitV = reader.ReadBytes(EncryptionConstV5.SIZE_INITV);
 
-    public async ValueTask ReadInitVAsync(AsyncMarkingBinaryReader reader) =>
-        InitV = await reader
-            .ReadBytesAsync(EncryptionConstV5.SIZE_INITV, CancellationToken.None);
-
     public bool UsePswCheck = false;
 
     public int LG2Count = 0;

src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs

@@ -1,4 +1,4 @@
-
+#nullable disable
 
 using System.Collections.Generic;
 using System.IO;
@@ -9,26 +9,20 @@ namespace SharpCompress.Common.Rar;
 
 internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
 {
-    private BlockTransformer _rijndael = default!;
+    private BlockTransformer _rijndael;
     private readonly Queue<byte> _data = new();
     private long _readCount;
 
-    private RarCryptoBinaryReader(Stream stream)
+    public RarCryptoBinaryReader(Stream stream, ICryptKey cryptKey)
         : base(stream)
     {
+        var salt = base.ReadBytes(EncryptionConstV5.SIZE_SALT30);
+        _readCount += EncryptionConstV5.SIZE_SALT30;
+        _rijndael = new BlockTransformer(cryptKey.Transformer(salt));
     }
 
-    public static RarCryptoBinaryReader Create(Stream stream, ICryptKey cryptKey, byte[]? salt = null)
-    {
-        var binary = new RarCryptoBinaryReader(stream);
-        if (salt == null)
-        {
-            salt = binary.ReadBytesBase(EncryptionConstV5.SIZE_SALT30);
-            binary._readCount += EncryptionConstV5.SIZE_SALT30;
-        }
-        binary._rijndael = new BlockTransformer(cryptKey.Transformer(salt));
-        return binary;
-    }
+    public RarCryptoBinaryReader(Stream stream, ICryptKey cryptKey, byte[] salt)
+        : base(stream) => _rijndael = new BlockTransformer(cryptKey.Transformer(salt));
 
     // track read count ourselves rather than using the underlying stream since we buffer
     public override long CurrentReadByteCount
@@ -46,8 +40,6 @@ internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
 
     public override byte[] ReadBytes(int count) => ReadAndDecryptBytes(count);
 
-    private byte[] ReadBytesBase(int count) => base.ReadBytes(count);
-
     private byte[] ReadAndDecryptBytes(int count)
     {
         var queueSize = _data.Count;

src/SharpCompress/Common/Rar/RarVolume.cs

@@ -2,10 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
@@ -29,8 +26,6 @@ public abstract class RarVolume : Volume
 
     internal abstract IEnumerable<RarFilePart> ReadFileParts();
 
-    internal abstract IAsyncEnumerable<RarFilePart> ReadFilePartsAsync();
-
     internal abstract RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader);
 
     internal IEnumerable<RarFilePart> GetVolumeFileParts()
@@ -76,59 +71,16 @@ public abstract class RarVolume : Volume
         }
     }
 
-    internal async IAsyncEnumerable<RarFilePart> GetVolumeFilePartsAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
-    {
-        MarkHeader? lastMarkHeader = null;
-        await foreach (var header in _headerFactory.ReadHeadersAsync(Stream).WithCancellation(cancellationToken))
-        {
-            switch (header.HeaderType)
-            {
-                case HeaderType.Mark:
-                    {
-                        lastMarkHeader = (MarkHeader)header;
-                    }
-                    break;
-                case HeaderType.Archive:
-                    {
-                        ArchiveHeader = (ArchiveHeader)header;
-                    }
-                    break;
-                case HeaderType.File:
-                    {
-                        var fh = (FileHeader)header;
-                        if (_maxCompressionAlgorithm < fh.CompressionAlgorithm)
-                        {
-                            _maxCompressionAlgorithm = fh.CompressionAlgorithm;
-                        }
-
-                        yield return CreateFilePart(lastMarkHeader!, fh);
-                    }
-                    break;
-                case HeaderType.Service:
-                    {
-                        var fh = (FileHeader)header;
-                        if (fh.FileName == "CMT")
-                        {
-                            var buffer = new byte[fh.CompressedSize];
-                            fh.PackedStream.NotNull().ReadFully(buffer);
-                            Comment = Encoding.UTF8.GetString(buffer, 0, buffer.Length - 1);
-                        }
-                    }
-                    break;
-            }
-        }
-    }
-
     private void EnsureArchiveHeaderLoaded()
     {
         if (ArchiveHeader is null)
         {
             if (Mode == StreamingMode.Streaming)
-        {
-            throw new InvalidOperationException(
+            {
+                throw new InvalidOperationException(
                     "ArchiveHeader should never been null in a streaming read."
-            );
-        }
+                );
+            }
 
             // we only want to load the archive header to avoid overhead but have to do the nasty thing and reset the stream
             GetVolumeFileParts().First();
@@ -174,12 +126,6 @@ public abstract class RarVolume : Volume
         }
     }
 
-    public async ValueTask<bool> IsSolidArchiveAsync(CancellationToken cancellationToken = default)
-    {
-        await EnsureArchiveHeaderLoadedAsync(cancellationToken);
-        return ArchiveHeader?.IsSolid ?? false;
-    }
-
     public int MinVersion
     {
         get
@@ -228,68 +174,5 @@ public abstract class RarVolume : Volume
         }
     }
 
-    private async ValueTask EnsureArchiveHeaderLoadedAsync(CancellationToken cancellationToken)
-    {
-        if (ArchiveHeader is null)
-        {
-            if (Mode == StreamingMode.Streaming)
-            {
-                throw new InvalidOperationException(
-                    "ArchiveHeader should never been null in a streaming read."
-                );
-            }
-
-            // we only want to load the archive header to avoid overhead but have to do the nasty thing and reset the stream
-            await GetVolumeFilePartsAsync(cancellationToken).FirstAsync();
-            Stream.Position = 0;
-        }
-    }
-
-    public virtual async ValueTask<int> MinVersionAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        await EnsureArchiveHeaderLoadedAsync(cancellationToken).ConfigureAwait(false);
-        if (_maxCompressionAlgorithm >= 50)
-        {
-            return 5; //5-6
-        }
-        else if (_maxCompressionAlgorithm >= 29)
-        {
-            return 3; //3-4
-        }
-        else if (_maxCompressionAlgorithm >= 20)
-        {
-            return 2; //2
-        }
-        else
-        {
-            return 1;
-        }
-    }
-
-    public virtual async ValueTask<int> MaxVersionAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        await EnsureArchiveHeaderLoadedAsync(cancellationToken).ConfigureAwait(false);
-        if (_maxCompressionAlgorithm >= 50)
-        {
-            return 6; //5-6
-        }
-        else if (_maxCompressionAlgorithm >= 29)
-        {
-            return 4; //3-4
-        }
-        else if (_maxCompressionAlgorithm >= 20)
-        {
-            return 2; //2
-        }
-        else
-        {
-            return 1;
-        }
-    }
-
     public string? Comment { get; internal set; }
 }

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -5,8 +5,6 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
@@ -1272,46 +1270,6 @@ internal class ArchiveReader
         _stream = stream;
     }
 
-    public async Task OpenAsync(
-        Stream stream,
-        bool lookForHeader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        Close();
-
-        _streamOrigin = stream.Position;
-        _streamEnding = stream.Length;
-
-        var canScan = lookForHeader ? 0x80000 - 20 : 0;
-        while (true)
-        {
-            // TODO: Check Signature!
-            _header = new byte[0x20];
-            await stream.ReadExactAsync(_header, 0, 0x20, cancellationToken);
-
-            if (
-                !lookForHeader
-                || _header
-                    .AsSpan(0, length: 6)
-                    .SequenceEqual<byte>([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])
-            )
-            {
-                break;
-            }
-
-            if (canScan == 0)
-            {
-                throw new InvalidFormatException("Unable to find 7z signature");
-            }
-
-            canScan--;
-            stream.Position = ++_streamOrigin;
-        }
-
-        _stream = stream;
-    }
-
     public void Close()
     {
         _stream?.Dispose();
@@ -1425,110 +1383,6 @@ internal class ArchiveReader
         return db;
     }
 
-    public async Task<ArchiveDatabase> ReadDatabaseAsync(
-        IPasswordProvider pass,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var db = new ArchiveDatabase(pass);
-        db.Clear();
-
-        db._majorVersion = _header[6];
-        db._minorVersion = _header[7];
-
-        if (db._majorVersion != 0)
-        {
-            throw new InvalidOperationException();
-        }
-
-        var crcFromArchive = DataReader.Get32(_header, 8);
-        var nextHeaderOffset = (long)DataReader.Get64(_header, 0xC);
-        var nextHeaderSize = (long)DataReader.Get64(_header, 0x14);
-        var nextHeaderCrc = DataReader.Get32(_header, 0x1C);
-
-        var crc = Crc.INIT_CRC;
-        crc = Crc.Update(crc, nextHeaderOffset);
-        crc = Crc.Update(crc, nextHeaderSize);
-        crc = Crc.Update(crc, nextHeaderCrc);
-        crc = Crc.Finish(crc);
-
-        if (crc != crcFromArchive)
-        {
-            throw new InvalidOperationException();
-        }
-
-        db._startPositionAfterHeader = _streamOrigin + 0x20;
-
-        // empty header is ok
-        if (nextHeaderSize == 0)
-        {
-            db.Fill();
-            return db;
-        }
-
-        if (nextHeaderOffset < 0 || nextHeaderSize < 0 || nextHeaderSize > int.MaxValue)
-        {
-            throw new InvalidOperationException();
-        }
-
-        if (nextHeaderOffset > _streamEnding - db._startPositionAfterHeader)
-        {
-            throw new InvalidOperationException("nextHeaderOffset is invalid");
-        }
-
-        _stream.Seek(nextHeaderOffset, SeekOrigin.Current);
-
-        var header = new byte[nextHeaderSize];
-        await _stream.ReadExactAsync(header, 0, header.Length, cancellationToken);
-
-        if (Crc.Finish(Crc.Update(Crc.INIT_CRC, header, 0, header.Length)) != nextHeaderCrc)
-        {
-            throw new InvalidOperationException();
-        }
-
-        using (var streamSwitch = new CStreamSwitch())
-        {
-            streamSwitch.Set(this, header);
-
-            var type = ReadId();
-            if (type != BlockType.Header)
-            {
-                if (type != BlockType.EncodedHeader)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                var dataVector = ReadAndDecodePackedStreams(
-                    db._startPositionAfterHeader,
-                    db.PasswordProvider
-                );
-
-                // compressed header without content is odd but ok
-                if (dataVector.Count == 0)
-                {
-                    db.Fill();
-                    return db;
-                }
-
-                if (dataVector.Count != 1)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                streamSwitch.Set(this, dataVector[0]);
-
-                if (ReadId() != BlockType.Header)
-                {
-                    throw new InvalidOperationException();
-                }
-            }
-
-            ReadHeader(db, db.PasswordProvider);
-        }
-        db.Fill();
-        return db;
-    }
-
     internal class CExtractFolderInfo
     {
         internal int _fileIndex;

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -15,7 +15,7 @@ internal class SevenZipFilePart : FilePart
         ArchiveDatabase database,
         int index,
         CFileItem fileEntry,
-        IArchiveEncoding archiveEncoding
+        ArchiveEncoding archiveEncoding
     )
         : base(archiveEncoding)
     {

src/SharpCompress/Common/Tar/Headers/TarHeader.cs

@@ -1,10 +1,8 @@
 using System;
-using System.Buffers;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Tar.Headers;
 
@@ -13,7 +11,7 @@ internal sealed class TarHeader
     internal static readonly DateTime EPOCH = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
     public TarHeader(
-        IArchiveEncoding archiveEncoding,
+        ArchiveEncoding archiveEncoding,
         TarHeaderWriteFormat writeFormat = TarHeaderWriteFormat.GNU_TAR_LONG_LINK
     )
     {
@@ -32,7 +30,7 @@ internal sealed class TarHeader
     internal DateTime LastModifiedTime { get; set; }
     internal EntryType EntryType { get; set; }
     internal Stream? PackedStream { get; set; }
-    internal IArchiveEncoding ArchiveEncoding { get; }
+    internal ArchiveEncoding ArchiveEncoding { get; }
 
     internal const int BLOCK_SIZE = 512;
 
@@ -497,90 +495,6 @@ internal sealed class TarHeader
         return true;
     }
 
-    internal async Task<bool> ReadAsync(AsyncBinaryReader reader)
-    {
-        string? longName = null;
-        string? longLinkName = null;
-        var hasLongValue = true;
-        byte[] buffer;
-        EntryType entryType;
-
-        do
-        {
-            buffer = await ReadBlockAsync(reader);
-
-            if (buffer.Length == 0)
-            {
-                return false;
-            }
-
-            entryType = ReadEntryType(buffer);
-
-            // LongName and LongLink headers can follow each other and need
-            // to apply to the header that follows them.
-            if (entryType == EntryType.LongName)
-            {
-                longName = await ReadLongNameAsync(reader, buffer);
-                continue;
-            }
-            else if (entryType == EntryType.LongLink)
-            {
-                longLinkName = await ReadLongNameAsync(reader, buffer);
-                continue;
-            }
-
-            hasLongValue = false;
-        } while (hasLongValue);
-
-        // Check header checksum
-        if (!checkChecksum(buffer))
-        {
-            return false;
-        }
-
-        Name = longName ?? ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
-        EntryType = entryType;
-        Size = ReadSize(buffer);
-
-        // for symlinks, additionally read the linkname
-        if (entryType == EntryType.SymLink || entryType == EntryType.HardLink)
-        {
-            LinkName = longLinkName ?? ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
-        }
-
-        Mode = ReadAsciiInt64Base8(buffer, 100, 7);
-
-        if (entryType == EntryType.Directory)
-        {
-            Mode |= 0b1_000_000_000;
-        }
-
-        UserId = ReadAsciiInt64Base8oldGnu(buffer, 108, 7);
-        GroupId = ReadAsciiInt64Base8oldGnu(buffer, 116, 7);
-
-        var unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
-
-        LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();
-        Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();
-
-        if (!string.IsNullOrEmpty(Magic) && "ustar".Equals(Magic))
-        {
-            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157).TrimNulls();
-
-            if (!string.IsNullOrEmpty(namePrefix))
-            {
-                Name = namePrefix + "/" + Name;
-            }
-        }
-
-        if (entryType != EntryType.LongName && Name.Length == 0)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
     internal static int RecalculateChecksum(byte[] buf)
     {
         // Set default value for checksum. That is 8 spaces.
@@ -616,65 +530,4 @@ internal sealed class TarHeader
     public long? DataStartPosition { get; set; }
 
     public string? Magic { get; set; }
-
-    private static async ValueTask<byte[]> ReadBlockAsync(AsyncBinaryReader reader)
-    {
-        var buffer = ArrayPool<byte>.Shared.Rent(BLOCK_SIZE);
-        try
-        {
-            await reader.ReadBytesAsync(buffer, 0, BLOCK_SIZE);
-
-            if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
-            {
-                throw new InvalidFormatException("Buffer is invalid size");
-            }
-
-            return buffer;
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(buffer);
-        }
-    }
-
-    private async Task<string> ReadLongNameAsync(AsyncBinaryReader reader, byte[] buffer)
-    {
-        var size = ReadSize(buffer);
-
-        // Validate size to prevent memory exhaustion from malformed headers
-        if (size < 0 || size > MAX_LONG_NAME_SIZE)
-        {
-            throw new InvalidFormatException(
-                $"Long name size {size} is invalid or exceeds maximum allowed size of {MAX_LONG_NAME_SIZE} bytes"
-            );
-        }
-
-        var nameLength = (int)size;
-        var nameBytes = ArrayPool<byte>.Shared.Rent(nameLength);
-        try
-        {
-            await reader.ReadBytesAsync(buffer, 0, nameLength);
-            var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);
-
-            // Read the rest of the block and discard the data
-            if (remainingBytesToRead < BLOCK_SIZE)
-            {
-                var remainingBytes = ArrayPool<byte>.Shared.Rent(remainingBytesToRead);
-                try
-                {
-                    await reader.ReadBytesAsync(remainingBytes, 0, remainingBytesToRead);
-                }
-                finally
-                {
-                    ArrayPool<byte>.Shared.Return(nameBytes);
-                }
-            }
-
-            return ArchiveEncoding.Decode(nameBytes, 0, nameLength).TrimNulls();
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(nameBytes);
-        }
-    }
 }

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -54,7 +54,7 @@ public class TarEntry : Entry
         StreamingMode mode,
         Stream stream,
         CompressionType compressionType,
-        IArchiveEncoding archiveEncoding
+        ArchiveEncoding archiveEncoding
     )
     {
         foreach (var header in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -10,7 +10,7 @@ internal static class TarHeaderFactory
     internal static IEnumerable<TarHeader?> ReadHeader(
         StreamingMode mode,
         Stream stream,
-        IArchiveEncoding archiveEncoding
+        ArchiveEncoding archiveEncoding
     )
     {
         while (true)
@@ -18,7 +18,7 @@ internal static class TarHeaderFactory
             TarHeader? header = null;
             try
             {
-                var reader = new BinaryReader(stream, archiveEncoding.Default, leaveOpen: false);
+                var reader = new BinaryReader(stream);
                 header = new TarHeader(archiveEncoding);
 
                 if (!header.Read(reader))
@@ -54,52 +54,6 @@ internal static class TarHeaderFactory
         }
     }
 
-    internal static async IAsyncEnumerable<TarHeader?> ReadHeaderAsync(
-        StreamingMode mode,
-        Stream stream,
-        IArchiveEncoding archiveEncoding
-    )
-    {
-        while (true)
-        {
-            TarHeader? header = null;
-            try
-            {
-                var reader = new AsyncBinaryReader(stream, false);
-                header = new TarHeader(archiveEncoding);
-                if (!await header.ReadAsync(reader))
-                {
-                    yield break;
-                }
-                switch (mode)
-                {
-                    case StreamingMode.Seekable:
-                        {
-                            header.DataStartPosition = stream.Position;
-
-                            //skip to nearest 512
-                            stream.Position += PadTo512(header.Size);
-                        }
-                        break;
-                    case StreamingMode.Streaming:
-                        {
-                            header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-            }
-            catch
-            {
-                header = null;
-            }
-            yield return header;
-        }
-    }
-
     private static long PadTo512(long size)
     {
         var zeros = (int)(size % 512);

src/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -20,19 +19,6 @@ internal class DirectoryEndHeader : ZipHeader
         Comment = reader.ReadBytes(CommentLength);
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        VolumeNumber = await reader.ReadUInt16Async();
-        FirstVolumeWithDirectory = await reader.ReadUInt16Async();
-        TotalNumberOfEntriesInDisk = await reader.ReadUInt16Async();
-        TotalNumberOfEntries = await reader.ReadUInt16Async();
-        DirectorySize = await reader.ReadUInt32Async();
-        DirectoryStartOffsetRelativeToDisk = await reader.ReadUInt32Async();
-        CommentLength = await reader.ReadUInt16Async();
-        Comment = new byte[CommentLength];
-        await reader.ReadBytesAsync(Comment, 0, CommentLength);
-    }
-
     public ushort VolumeNumber { get; private set; }
 
     public ushort FirstVolumeWithDirectory { get; private set; }

src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs

@@ -1,12 +1,11 @@
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
 internal class DirectoryEntryHeader : ZipFileEntry
 {
-    public DirectoryEntryHeader(IArchiveEncoding archiveEncoding)
+    public DirectoryEntryHeader(ArchiveEncoding archiveEncoding)
         : base(ZipHeaderType.DirectoryEntry, archiveEncoding) { }
 
     internal override void Read(BinaryReader reader)
@@ -32,39 +31,7 @@ internal class DirectoryEntryHeader : ZipFileEntry
         var extra = reader.ReadBytes(extraLength);
         var comment = reader.ReadBytes(commentLength);
 
-        ProcessReadData(name, extra, comment);
-    }
-
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        Version = await reader.ReadUInt16Async();
-        VersionNeededToExtract = await reader.ReadUInt16Async();
-        Flags = (HeaderFlags)await reader.ReadUInt16Async();
-        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
-        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
-        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
-        Crc = await reader.ReadUInt32Async();
-        CompressedSize = await reader.ReadUInt32Async();
-        UncompressedSize = await reader.ReadUInt32Async();
-        var nameLength = await reader.ReadUInt16Async();
-        var extraLength = await reader.ReadUInt16Async();
-        var commentLength = await reader.ReadUInt16Async();
-        DiskNumberStart = await reader.ReadUInt16Async();
-        InternalFileAttributes = await reader.ReadUInt16Async();
-        ExternalFileAttributes = await reader.ReadUInt32Async();
-        RelativeOffsetOfEntryHeader = await reader.ReadUInt32Async();
-        var name = new byte[nameLength];
-        var extra = new byte[extraLength];
-        var comment = new byte[commentLength];
-        await reader.ReadBytesAsync(name, 0, nameLength);
-        await reader.ReadBytesAsync(extra, 0, extraLength);
-        await reader.ReadBytesAsync(comment, 0, commentLength);
-
-        ProcessReadData(name, extra, comment);
-    }
-
-    private void ProcessReadData(byte[] name, byte[] extra, byte[] comment)
-    {
+        // According to .ZIP File Format Specification
         //
         // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         //
@@ -74,8 +41,8 @@ internal class DirectoryEntryHeader : ZipFileEntry
 
         if (Flags.HasFlag(HeaderFlags.Efs))
         {
-            Name = ArchiveEncoding.Decode(name, EncodingType.UTF8);
-            Comment = ArchiveEncoding.Decode(comment, EncodingType.UTF8);
+            Name = ArchiveEncoding.DecodeUTF8(name);
+            Comment = ArchiveEncoding.DecodeUTF8(comment);
         }
         else
         {

src/SharpCompress/Common/Zip/Headers/IgnoreHeader.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -9,6 +8,4 @@ internal class IgnoreHeader : ZipHeader
         : base(type) { }
 
     internal override void Read(BinaryReader reader) { }
-
-    internal override ValueTask Read(AsyncBinaryReader reader) => default;
 }

src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs

@@ -1,12 +1,13 @@
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class LocalEntryHeader(IArchiveEncoding archiveEncoding)
-    : ZipFileEntry(ZipHeaderType.LocalEntry, archiveEncoding)
+internal class LocalEntryHeader : ZipFileEntry
 {
+    public LocalEntryHeader(ArchiveEncoding archiveEncoding)
+        : base(ZipHeaderType.LocalEntry, archiveEncoding) { }
+
     internal override void Read(BinaryReader reader)
     {
         Version = reader.ReadUInt16();
@@ -22,31 +23,7 @@ internal class LocalEntryHeader(IArchiveEncoding archiveEncoding)
         var name = reader.ReadBytes(nameLength);
         var extra = reader.ReadBytes(extraLength);
 
-        ProcessReadData(name, extra);
-    }
-
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        Version = await reader.ReadUInt16Async();
-        Flags = (HeaderFlags)await reader.ReadUInt16Async();
-        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
-        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
-        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
-        Crc = await reader.ReadUInt32Async();
-        CompressedSize = await reader.ReadUInt32Async();
-        UncompressedSize = await reader.ReadUInt32Async();
-        var nameLength = await reader.ReadUInt16Async();
-        var extraLength = await reader.ReadUInt16Async();
-        var name = new byte[nameLength];
-        var extra = new byte[extraLength];
-        await reader.ReadBytesAsync(name, 0, nameLength);
-        await reader.ReadBytesAsync(extra, 0, extraLength);
-
-        ProcessReadData(name, extra);
-    }
-
-    private void ProcessReadData(byte[] name, byte[] extra)
-    {
+        // According to .ZIP File Format Specification
         //
         // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         //
@@ -56,7 +33,7 @@ internal class LocalEntryHeader(IArchiveEncoding archiveEncoding)
 
         if (Flags.HasFlag(HeaderFlags.Efs))
         {
-            Name = ArchiveEncoding.Decode(name, EncodingType.UTF8);
+            Name = ArchiveEncoding.DecodeUTF8(name);
         }
         else
         {

src/SharpCompress/Common/Zip/Headers/SplitHeader.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -10,7 +9,4 @@ internal class SplitHeader : ZipHeader
         : base(ZipHeaderType.Split) { }
 
     internal override void Read(BinaryReader reader) => throw new NotImplementedException();
-
-    internal override ValueTask Read(AsyncBinaryReader reader) =>
-        throw new NotImplementedException();
 }

src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -27,24 +26,6 @@ internal class Zip64DirectoryEndHeader : ZipHeader
         );
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        SizeOfDirectoryEndRecord = (long)await reader.ReadUInt64Async();
-        VersionMadeBy = await reader.ReadUInt16Async();
-        VersionNeededToExtract = await reader.ReadUInt16Async();
-        VolumeNumber = await reader.ReadUInt32Async();
-        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
-        TotalNumberOfEntriesInDisk = (long)await reader.ReadUInt64Async();
-        TotalNumberOfEntries = (long)await reader.ReadUInt64Async();
-        DirectorySize = (long)await reader.ReadUInt64Async();
-        DirectoryStartOffsetRelativeToDisk = (long)await reader.ReadUInt64Async();
-        var size = (int)(
-            SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
-        );
-        DataSector = new byte[size];
-        await reader.ReadBytesAsync(DataSector, 0, size);
-    }
-
     private const int SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS = 44;
 
     public long SizeOfDirectoryEndRecord { get; private set; }