Merge pull request #1195 from adamhathcock/adam/add-configure-await

add configure await

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "csharpier": {
-      "version": "1.2.5",
+      "version": "1.2.6",
       "commands": [
         "csharpier"
       ],

.copilot-agent.yml

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

.github/agents/copilot-agent.yml

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

.github/prompts/plan-async.prompt.md

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

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

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

.github/workflows/performance-benchmarks.yml

@@ -0,0 +1,50 @@
+name: Performance Benchmarks
+
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release'
+  pull_request:
+    branches:
+      - 'master'
+      - 'release'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v6
+      with:
+        fetch-depth: 0
+    
+    - uses: actions/setup-dotnet@v5
+      with:
+        dotnet-version: 10.0.x
+    
+    - name: Build Performance Project
+      run: dotnet build tests/SharpCompress.Performance/SharpCompress.Performance.csproj --configuration Release
+    
+    - name: Run Benchmarks
+      run: dotnet run --project tests/SharpCompress.Performance/SharpCompress.Performance.csproj --configuration Release --no-build -- --filter "*" --exporters json markdown --artifacts benchmark-results
+      continue-on-error: true
+    
+    - name: Display Benchmark Results
+      if: always()
+      run: dotnet run --project build/build.csproj -- display-benchmark-results
+    
+    - name: Compare with Baseline
+      if: always()
+      run: dotnet run --project build/build.csproj -- compare-benchmark-results
+    
+    - name: Upload Benchmark Results
+      if: always()
+      uses: actions/upload-artifact@v6
+      with:
+        name: benchmark-results
+        path: benchmark-results/

.gitignore

@@ -17,6 +17,10 @@ tests/TestArchives/*/Scratch2
 tools
 .idea/
 artifacts/
+BenchmarkDotNet.Artifacts/
+baseline-artifacts/
+profiler-snapshots/
 
 .DS_Store
 *.snupkg
+benchmark-results/

Directory.Packages.props

@@ -1,20 +1,20 @@
 <Project>
   <ItemGroup>
+    <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
     <PackageVersion Include="Bullseye" Version="6.1.0" />
     <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
     <PackageVersion Include="Glob" Version="1.1.9" />
-    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.15" />
+    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.16" />
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.0" />
-    <PackageVersion Include="Microsoft.NET.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.v3" Version="3.2.2" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <GlobalPackageReference Include="Microsoft.SourceLink.GitHub" Version="10.0.102" />
     <GlobalPackageReference Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
     <GlobalPackageReference
       Include="Microsoft.VisualStudio.Threading.Analyzers"

build/Program.cs

@@ -19,6 +19,9 @@ const string Publish = "publish";
 const string DetermineVersion = "determine-version";
 const string UpdateVersion = "update-version";
 const string PushToNuGet = "push-to-nuget";
+const string DisplayBenchmarkResults = "display-benchmark-results";
+const string CompareBenchmarkResults = "compare-benchmark-results";
+const string GenerateBaseline = "generate-baseline";
 
 Target(
     Clean,
@@ -210,6 +213,249 @@ Target(
     }
 );
 
+Target(
+    DisplayBenchmarkResults,
+    () =>
+    {
+        var githubStepSummary = Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY");
+        var resultsDir = "benchmark-results/results";
+
+        if (!Directory.Exists(resultsDir))
+        {
+            Console.WriteLine("No benchmark results found.");
+            return;
+        }
+
+        var markdownFiles = Directory
+            .GetFiles(resultsDir, "*-report-github.md")
+            .OrderBy(f => f)
+            .ToList();
+
+        if (markdownFiles.Count == 0)
+        {
+            Console.WriteLine("No benchmark markdown reports found.");
+            return;
+        }
+
+        var output = new List<string> { "## Benchmark Results", "" };
+
+        foreach (var file in markdownFiles)
+        {
+            Console.WriteLine($"Processing {Path.GetFileName(file)}");
+            var content = File.ReadAllText(file);
+            output.Add(content);
+            output.Add("");
+        }
+
+        // Write to GitHub Step Summary if available
+        if (!string.IsNullOrEmpty(githubStepSummary))
+        {
+            File.AppendAllLines(githubStepSummary, output);
+            Console.WriteLine($"Benchmark results written to GitHub Step Summary");
+        }
+        else
+        {
+            // Write to console if not in GitHub Actions
+            foreach (var line in output)
+            {
+                Console.WriteLine(line);
+            }
+        }
+    }
+);
+
+Target(
+    CompareBenchmarkResults,
+    () =>
+    {
+        var githubStepSummary = Environment.GetEnvironmentVariable("GITHUB_STEP_SUMMARY");
+        var baselinePath = "tests/SharpCompress.Performance/baseline-results.md";
+        var resultsDir = "benchmark-results/results";
+
+        var output = new List<string> { "## Comparison with Baseline", "" };
+
+        if (!File.Exists(baselinePath))
+        {
+            Console.WriteLine("Baseline file not found");
+            output.Add("⚠️ Baseline file not found. Run `generate-baseline` to create it.");
+            WriteOutput(output, githubStepSummary);
+            return;
+        }
+
+        if (!Directory.Exists(resultsDir))
+        {
+            Console.WriteLine("No current benchmark results found.");
+            output.Add("⚠️ No current benchmark results found. Showing baseline only.");
+            output.Add("");
+            output.Add("### Baseline Results");
+            output.AddRange(File.ReadAllLines(baselinePath));
+            WriteOutput(output, githubStepSummary);
+            return;
+        }
+
+        var markdownFiles = Directory
+            .GetFiles(resultsDir, "*-report-github.md")
+            .OrderBy(f => f)
+            .ToList();
+
+        if (markdownFiles.Count == 0)
+        {
+            Console.WriteLine("No current benchmark markdown reports found.");
+            output.Add("⚠️ No current benchmark results found. Showing baseline only.");
+            output.Add("");
+            output.Add("### Baseline Results");
+            output.AddRange(File.ReadAllLines(baselinePath));
+            WriteOutput(output, githubStepSummary);
+            return;
+        }
+
+        Console.WriteLine("Parsing baseline results...");
+        var baselineMetrics = ParseBenchmarkResults(File.ReadAllText(baselinePath));
+
+        Console.WriteLine("Parsing current results...");
+        var currentText = string.Join("\n", markdownFiles.Select(f => File.ReadAllText(f)));
+        var currentMetrics = ParseBenchmarkResults(currentText);
+
+        Console.WriteLine("Comparing results...");
+        output.Add("### Performance Comparison");
+        output.Add("");
+        output.Add(
+            "| Benchmark | Baseline Mean | Current Mean | Change | Baseline Memory | Current Memory | Change |"
+        );
+        output.Add(
+            "|-----------|---------------|--------------|--------|-----------------|----------------|--------|"
+        );
+
+        var hasRegressions = false;
+        var hasImprovements = false;
+
+        foreach (var method in currentMetrics.Keys.Union(baselineMetrics.Keys).OrderBy(k => k))
+        {
+            var hasCurrent = currentMetrics.TryGetValue(method, out var current);
+            var hasBaseline = baselineMetrics.TryGetValue(method, out var baseline);
+
+            if (!hasCurrent)
+            {
+                output.Add(
+                    $"| {method} | {baseline!.Mean} | ❌ Missing | N/A | {baseline.Memory} | N/A | N/A |"
+                );
+                continue;
+            }
+
+            if (!hasBaseline)
+            {
+                output.Add(
+                    $"| {method} | ❌ New | {current!.Mean} | N/A | N/A | {current.Memory} | N/A |"
+                );
+                continue;
+            }
+
+            var timeChange = CalculateChange(baseline!.MeanValue, current!.MeanValue);
+            var memChange = CalculateChange(baseline.MemoryValue, current.MemoryValue);
+
+            var timeIcon =
+                timeChange > 25 ? "🔴"
+                : timeChange < -25 ? "🟢"
+                : "⚪";
+            var memIcon =
+                memChange > 25 ? "🔴"
+                : memChange < -25 ? "🟢"
+                : "⚪";
+
+            if (timeChange > 25 || memChange > 25)
+                hasRegressions = true;
+            if (timeChange < -25 || memChange < -25)
+                hasImprovements = true;
+
+            output.Add(
+                $"| {method} | {baseline.Mean} | {current.Mean} | {timeIcon} {timeChange:+0.0;-0.0;0}% | {baseline.Memory} | {current.Memory} | {memIcon} {memChange:+0.0;-0.0;0}% |"
+            );
+        }
+
+        output.Add("");
+        output.Add("**Legend:**");
+        output.Add("- 🔴 Regression (>25% slower/more memory)");
+        output.Add("- 🟢 Improvement (>25% faster/less memory)");
+        output.Add("- ⚪ No significant change");
+
+        if (hasRegressions)
+        {
+            output.Add("");
+            output.Add(
+                "⚠️ **Warning**: Performance regressions detected. Review the changes carefully."
+            );
+        }
+        else if (hasImprovements)
+        {
+            output.Add("");
+            output.Add("✅ Performance improvements detected!");
+        }
+        else
+        {
+            output.Add("");
+            output.Add("✅ Performance is stable compared to baseline.");
+        }
+
+        WriteOutput(output, githubStepSummary);
+    }
+);
+
+Target(
+    GenerateBaseline,
+    () =>
+    {
+        var perfProject = "tests/SharpCompress.Performance/SharpCompress.Performance.csproj";
+        var baselinePath = "tests/SharpCompress.Performance/baseline-results.md";
+        var artifactsDir = "baseline-artifacts";
+
+        Console.WriteLine("Building performance project...");
+        Run("dotnet", $"build {perfProject} --configuration Release");
+
+        Console.WriteLine("Running benchmarks to generate baseline...");
+        Run(
+            "dotnet",
+            $"run --project {perfProject} --configuration Release --no-build -- --filter \"*\" --exporters markdown --artifacts {artifactsDir}"
+        );
+
+        var resultsDir = Path.Combine(artifactsDir, "results");
+        if (!Directory.Exists(resultsDir))
+        {
+            Console.WriteLine("ERROR: No benchmark results generated.");
+            return;
+        }
+
+        var markdownFiles = Directory
+            .GetFiles(resultsDir, "*-report-github.md")
+            .OrderBy(f => f)
+            .ToList();
+
+        if (markdownFiles.Count == 0)
+        {
+            Console.WriteLine("ERROR: No markdown reports found.");
+            return;
+        }
+
+        Console.WriteLine($"Combining {markdownFiles.Count} benchmark reports...");
+        var baselineContent = new List<string>();
+
+        foreach (var file in markdownFiles)
+        {
+            var lines = File.ReadAllLines(file);
+            baselineContent.AddRange(lines.Select(l => l.Trim()).Where(l => l.StartsWith('|')));
+        }
+
+        File.WriteAllText(baselinePath, string.Join(Environment.NewLine, baselineContent));
+        Console.WriteLine($"Baseline written to {baselinePath}");
+
+        // Clean up artifacts directory
+        if (Directory.Exists(artifactsDir))
+        {
+            Directory.Delete(artifactsDir, true);
+            Console.WriteLine("Cleaned up artifacts directory.");
+        }
+    }
+);
+
 Target("default", [Publish], () => Console.WriteLine("Done!"));
 
 await RunTargetsAndExitAsync(args);
@@ -230,7 +476,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 +486,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 +513,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
@@ -266,3 +548,142 @@ static async Task<string> GetGitOutput(string command, string args)
         throw new Exception($"Git command failed: git {command} {args}\n{ex.Message}", ex);
     }
 }
+
+static void WriteOutput(List<string> output, string? githubStepSummary)
+{
+    if (!string.IsNullOrEmpty(githubStepSummary))
+    {
+        File.AppendAllLines(githubStepSummary, output);
+        Console.WriteLine("Comparison written to GitHub Step Summary");
+    }
+    else
+    {
+        foreach (var line in output)
+        {
+            Console.WriteLine(line);
+        }
+    }
+}
+
+static Dictionary<string, BenchmarkMetric> ParseBenchmarkResults(string markdown)
+{
+    var metrics = new Dictionary<string, BenchmarkMetric>();
+    var lines = markdown.Split('\n');
+
+    for (int i = 0; i < lines.Length; i++)
+    {
+        var line = lines[i].Trim();
+
+        // Look for table rows with benchmark data
+        if (line.StartsWith("|") && line.Contains("&#39;") && i > 0)
+        {
+            var parts = line.Split('|', StringSplitOptions.TrimEntries);
+            if (parts.Length >= 5)
+            {
+                var method = parts[1].Replace("&#39;", "'");
+                var meanStr = parts[2];
+
+                // Find Allocated column - it's usually the last column or labeled "Allocated"
+                string memoryStr = "N/A";
+                for (int j = parts.Length - 2; j >= 2; j--)
+                {
+                    if (
+                        parts[j].Contains("KB")
+                        || parts[j].Contains("MB")
+                        || parts[j].Contains("GB")
+                        || parts[j].Contains("B")
+                    )
+                    {
+                        memoryStr = parts[j];
+                        break;
+                    }
+                }
+
+                if (
+                    !method.Equals("Method", StringComparison.OrdinalIgnoreCase)
+                    && !string.IsNullOrWhiteSpace(method)
+                )
+                {
+                    var metric = new BenchmarkMetric
+                    {
+                        Method = method,
+                        Mean = meanStr,
+                        MeanValue = ParseTimeValue(meanStr),
+                        Memory = memoryStr,
+                        MemoryValue = ParseMemoryValue(memoryStr),
+                    };
+                    metrics[method] = metric;
+                }
+            }
+        }
+    }
+
+    return metrics;
+}
+
+static double ParseTimeValue(string timeStr)
+{
+    if (string.IsNullOrWhiteSpace(timeStr) || timeStr == "N/A" || timeStr == "NA")
+        return 0;
+
+    // Remove thousands separators and parse
+    timeStr = timeStr.Replace(",", "").Trim();
+
+    var match = Regex.Match(timeStr, @"([\d.]+)\s*(\w+)");
+    if (!match.Success)
+        return 0;
+
+    var value = double.Parse(match.Groups[1].Value);
+    var unit = match.Groups[2].Value.ToLower();
+
+    // Convert to microseconds for comparison
+    return unit switch
+    {
+        "s" => value * 1_000_000,
+        "ms" => value * 1_000,
+        "μs" or "us" => value,
+        "ns" => value / 1_000,
+        _ => value,
+    };
+}
+
+static double ParseMemoryValue(string memStr)
+{
+    if (string.IsNullOrWhiteSpace(memStr) || memStr == "N/A" || memStr == "NA")
+        return 0;
+
+    memStr = memStr.Replace(",", "").Trim();
+
+    var match = Regex.Match(memStr, @"([\d.]+)\s*(\w+)");
+    if (!match.Success)
+        return 0;
+
+    var value = double.Parse(match.Groups[1].Value);
+    var unit = match.Groups[2].Value.ToUpper();
+
+    // Convert to KB for comparison
+    return unit switch
+    {
+        "GB" => value * 1_024 * 1_024,
+        "MB" => value * 1_024,
+        "KB" => value,
+        "B" => value / 1_024,
+        _ => value,
+    };
+}
+
+static double CalculateChange(double baseline, double current)
+{
+    if (baseline == 0)
+        return 0;
+    return ((current - baseline) / baseline) * 100;
+}
+
+record BenchmarkMetric
+{
+    public string Method { get; init; } = "";
+    public string Mean { get; init; } = "";
+    public double MeanValue { get; init; }
+    public string Memory { get; init; } = "";
+    public double MemoryValue { get; init; }
+}

build/packages.lock.json

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

docs/API.md

@@ -20,14 +20,18 @@ 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
+// With fluent options (preferred)
+var options = ReaderOptions.ForEncryptedArchive("password")
+    .WithArchiveEncoding(new ArchiveEncoding { Default = Encoding.GetEncoding(932) });
+using (var archive = ZipArchive.OpenArchive("encrypted.zip", options))
+
+// Alternative: object initializer
+var options2 = new ReaderOptions
 {
     Password = "password",
     LeaveStreamOpen = true,
     ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
 };
-using (var archive = ZipArchive.OpenArchive("encrypted.zip", options))
 ```
 
 ### Creating Archives
@@ -44,16 +48,21 @@ 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
-};
+// With fluent options (preferred)
+var options = WriterOptions.ForZip()
+    .WithCompressionLevel(9)
+    .WithLeaveStreamOpen(false);
 using (var archive = ZipArchive.CreateArchive())
 {
     archive.SaveTo("output.zip", options);
 }
+
+// Alternative: constructor with object initializer
+var options2 = new WriterOptions(CompressionType.Deflate)
+{
+    CompressionLevel = 9,
+    LeaveStreamOpen = false
+};
 ```
 
 ---
@@ -72,16 +81,11 @@ using (var archive = ZipArchive.OpenArchive("file.zip"))
     var entry = archive.Entries.FirstOrDefault(e => e.Key == "file.txt");
 
     // Extract all
-    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+    archive.WriteToDirectory(@"C:\output");
 
     // 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())
@@ -95,7 +99,6 @@ using (var asyncArchive = await ZipArchive.OpenAsyncArchive("file.zip"))
 {
     await asyncArchive.WriteToDirectoryAsync(
         @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
         cancellationToken: cancellationToken
     );
 }
@@ -187,7 +190,6 @@ using (var reader = await ReaderFactory.OpenAsyncReader(stream))
     // Async extraction of all entries
     await reader.WriteAllToDirectoryAsync(
         @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
         cancellationToken
     );
 }
@@ -229,43 +231,91 @@ using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Zip, Compressio
 
 ### ReaderOptions
 
+Use factory presets and fluent helpers for common configurations:
+
 ```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)
-    }
-};
+// External stream with password and custom encoding
+var options = ReaderOptions.ForExternalStream()
+    .WithPassword("password")
+    .WithArchiveEncoding(new ArchiveEncoding { Default = Encoding.GetEncoding(932) });
+
 using (var archive = ZipArchive.OpenArchive("file.zip", options))
 {
     // ...
 }
+
+// Common presets
+var safeOptions = ReaderOptions.SafeExtract;      // No overwrite
+var flatOptions = ReaderOptions.FlatExtract;      // No directory structure
+
+// Factory defaults:
+// - file path / FileInfo overloads use LeaveStreamOpen = false
+// - stream overloads use LeaveStreamOpen = true
+```
+
+Alternative: traditional object initializer:
+
+```csharp
+var options = new ReaderOptions
+{
+    Password = "password",
+    LeaveStreamOpen = true,
+    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
+};
 ```
 
 ### WriterOptions
 
+Factory methods provide a clean, discoverable way to create writer options:
+
+```csharp
+// Factory methods for common archive types
+var zipOptions = WriterOptions.ForZip()                           // ZIP with Deflate
+    .WithCompressionLevel(9)                                      // 0-9 for Deflate
+    .WithLeaveStreamOpen(false);                                  // Close stream when done
+
+var tarOptions = WriterOptions.ForTar(CompressionType.GZip)       // TAR with GZip
+    .WithLeaveStreamOpen(false);
+
+var gzipOptions = WriterOptions.ForGZip()                         // GZip file
+    .WithCompressionLevel(6);
+
+archive.SaveTo("output.zip", zipOptions);
+```
+
+Alternative: traditional constructor with object initializer:
+
 ```csharp
 var options = new WriterOptions(CompressionType.Deflate)
 {
-    CompressionLevel = 9,                           // 0-9 for Deflate
-    LeaveStreamOpen = true,                         // Don't close stream
+    CompressionLevel = 9,
+    LeaveStreamOpen = true,
 };
 archive.SaveTo("output.zip", options);
 ```
 
-### ExtractionOptions
+### Extraction behavior
 
 ```csharp
-var options = new ExtractionOptions
+var options = new ReaderOptions
 {
     ExtractFullPath = true,                         // Recreate directory structure
     Overwrite = true,                               // Overwrite existing files
     PreserveFileTime = true                         // Keep original timestamps
 };
-archive.WriteToDirectory(@"C:\output", options);
+
+using (var archive = ZipArchive.OpenArchive("file.zip", options))
+{
+    archive.WriteToDirectory(@"C:\output");
+}
+```
+
+### Options matrix
+
+```text
+ReaderOptions: open-time behavior (password, encoding, stream ownership, extraction defaults)
+WriterOptions: write-time behavior (compression type/level, encoding, stream ownership)
+ZipWriterEntryOptions: per-entry ZIP overrides (compression, level, timestamps, comments, zip64)
 ```
 
 ---
@@ -317,13 +367,9 @@ ArchiveType.ZStandard
 try
 {
     using (var archive = ZipArchive.Open("archive.zip", 
-        new ReaderOptions { Password = "password" }))
+        ReaderOptions.ForEncryptedArchive("password")))
     {
-        archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        });
+        archive.WriteToDirectory(@"C:\output");
     }
 }
 catch (PasswordRequiredException)
@@ -348,7 +394,7 @@ var progress = new Progress<ProgressReport>(report =>
     Console.WriteLine($"Extracting {report.EntryPath}: {report.PercentComplete}%");
 });
 
-var options = new ReaderOptions { Progress = progress };
+var options = ReaderOptions.ForOwnedFile().WithProgress(progress);
 using (var archive = ZipArchive.OpenArchive("archive.zip", options))
 {
     archive.WriteToDirectory(@"C:\output");
@@ -367,7 +413,6 @@ try
     {
         await archive.WriteToDirectoryAsync(
             @"C:\output",
-            new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
             cancellationToken: cts.Token
         );
     }

docs/ARCHITECTURE.md

@@ -90,7 +90,7 @@ Common types, options, and enumerations used across formats.
 - `ArchiveType.cs` - Enum for archive formats
 - `CompressionType.cs` - Enum for compression methods
 - `ArchiveEncoding.cs` - Character encoding configuration
-- `ExtractionOptions.cs` - Extraction configuration
+- `IExtractionOptions.cs` - Extraction configuration exposed through `ReaderOptions`
 - Format-specific headers: `Zip/Headers/`, `Tar/Headers/`, `Rar/Headers/`, etc.
 
 #### `Compressors/` - Compression Algorithms
@@ -215,13 +215,13 @@ using (var compressor = new DeflateStream(nonDisposingStream))
 public abstract class AbstractArchive : IArchive
 {
     // Template methods
-    public virtual void WriteToDirectory(string destinationDirectory, ExtractionOptions options)
+    public virtual void WriteToDirectory(string destinationDirectory)
     {
         // Common extraction logic
         foreach (var entry in Entries)
         {
             // Call subclass method
-            entry.WriteToFile(destinationPath, options);
+            entry.WriteToFile(destinationPath);
         }
     }
     
@@ -267,8 +267,7 @@ public interface IArchive : IDisposable
 {
     IEnumerable<IEntry> Entries { get; }
     
-    void WriteToDirectory(string destinationDirectory, 
-                         ExtractionOptions options = null);
+    void WriteToDirectory(string destinationDirectory);
     
     IEntry FirstOrDefault(Func<IEntry, bool> predicate);
     
@@ -287,8 +286,7 @@ public interface IReader : IDisposable
     
     bool MoveToNextEntry();
     
-    void WriteEntryToDirectory(string destinationDirectory,
-                              ExtractionOptions options = null);
+    void WriteEntryToDirectory(string destinationDirectory);
     
     Stream OpenEntryStream();
     
@@ -327,7 +325,7 @@ public interface IEntry
     DateTime? LastModifiedTime { get; }
     CompressionType CompressionType { get; }
     
-    void WriteToFile(string fullPath, ExtractionOptions options = null);
+    void WriteToFile(string fullPath);
     void WriteToStream(Stream destinationStream);
     Stream OpenEntryStream();
     

docs/ENCODING.md

@@ -18,14 +18,9 @@ Most archive formats store filenames and metadata as bytes. SharpCompress must c
 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
-    }
-};
+// Configure encoding using fluent factory method (preferred)
+var options = ReaderOptions.ForEncoding(
+    new ArchiveEncoding { Default = Encoding.GetEncoding(932) });  // cp932 for Japanese
 
 using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
 {
@@ -34,6 +29,12 @@ using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
         Console.WriteLine(entry.Key);  // Now shows correct characters
     }
 }
+
+// Alternative: object initializer
+var options2 = new ReaderOptions
+{
+    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
+};
 ```
 
 ### ArchiveEncoding Properties
@@ -47,10 +48,8 @@ using (var archive = ZipArchive.OpenArchive("japanese.zip", options))
 
 **Archive API:**
 ```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
-};
+var options = ReaderOptions.ForEncoding(
+    new ArchiveEncoding { Default = Encoding.GetEncoding(932) });
 using (var archive = ZipArchive.OpenArchive("file.zip", options))
 {
     // Use archive with correct encoding
@@ -59,10 +58,8 @@ using (var archive = ZipArchive.OpenArchive("file.zip", options))
 
 **Reader API:**
 ```csharp
-var options = new ReaderOptions
-{
-    ArchiveEncoding = new ArchiveEncoding { Default = Encoding.GetEncoding(932) }
-};
+var options = ReaderOptions.ForEncoding(
+    new ArchiveEncoding { Default = Encoding.GetEncoding(932) });
 using (var stream = File.OpenRead("file.zip"))
 using (var reader = ReaderFactory.OpenReader(stream, options))
 {
@@ -390,11 +387,7 @@ var options = new ReaderOptions
 
 using (var archive = ZipArchive.OpenArchive("japanese_files.zip", options))
 {
-    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+    archive.WriteToDirectory(@"C:\output");
 }
 // Files extracted with correct Japanese names
 ```

docs/PERFORMANCE.md

@@ -213,11 +213,7 @@ using (var archive = RarArchive.OpenArchive("solid.rar"))
 using (var archive = RarArchive.OpenArchive("solid.rar"))
 {
     // Method 1: Use WriteToDirectory (recommended)
-    archive.WriteToDirectory(@"C:\output", new ExtractionOptions
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+    archive.WriteToDirectory(@"C:\output");
     
     // Method 2: Use ExtractAllEntries
     archive.ExtractAllEntries();
@@ -337,7 +333,6 @@ using (var archive = ZipArchive.OpenArchive("archive.zip"))
 {
     await archive.WriteToDirectoryAsync(
         @"C:\output",
-        new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
         cancellationToken
     );
 }
@@ -355,10 +350,7 @@ Async doesn't improve performance for:
 // 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 }
-    );
+    archive.WriteToDirectory(@"C:\output");
 }
 // Simple and fast - no async needed
 ```
@@ -377,7 +369,6 @@ try
     {
         await archive.WriteToDirectoryAsync(
             @"C:\output",
-            new ExtractionOptions { ExtractFullPath = true, Overwrite = true },
             cts.Token
         );
     }

docs/USAGE.md

@@ -6,7 +6,7 @@ SharpCompress now provides full async/await support for all I/O operations. All
 
 **Key Async Methods:**
 - `reader.WriteEntryToAsync(stream, cancellationToken)` - Extract entry asynchronously  
-- `reader.WriteAllToDirectoryAsync(path, options, cancellationToken)` - Extract all asynchronously
+- `reader.WriteAllToDirectoryAsync(path, cancellationToken)` - Extract all asynchronously
 - `writer.WriteAsync(filename, stream, modTime, cancellationToken)` - Write entry asynchronously
 - `writer.WriteAllAsync(directory, pattern, searchOption, cancellationToken)` - Write directory asynchronously
 - `entry.OpenEntryStreamAsync(cancellationToken)` - Open entry stream asynchronously
@@ -40,6 +40,10 @@ To deal with the "correct" rules as well as the expectations of users, I've deci
 
 To be explicit though, consider always using the overloads that use `ReaderOptions` or `WriterOptions` and explicitly set `LeaveStreamOpen` the way you want.
 
+Default behavior in factory APIs:
+- File path / `FileInfo` overloads set `LeaveStreamOpen = false`.
+- Caller-provided `Stream` overloads set `LeaveStreamOpen = true`.
+
 If using Compression Stream classes directly and you don't want the wrapped stream to be closed.  Use the `NonDisposingStream` as a wrapper to prevent the stream being disposed.  The change in 0.21 simplified a lot even though the usage is a bit more convoluted.
 
 ## Samples
@@ -90,14 +94,14 @@ 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 fluent factory method for extraction options
+using (var archive = RarArchive.OpenArchive("Test.rar",
+    ReaderOptions.ForOwnedFile()
+        .WithExtractFullPath(true)
+        .WithOverwrite(true)))
 {
     // Simple extraction with RarArchive; this WriteToDirectory pattern works for all archive types
-    archive.WriteToDirectory(@"D:\temp", new ExtractionOptions()
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+    archive.WriteToDirectory(@"D:\temp");
 }
 ```
 
@@ -126,13 +130,13 @@ 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.OpenArchive("archive.rar",
+    ReaderOptions.ForOwnedFile()
+        .WithProgress(progress)
+        .WithExtractFullPath(true)
+        .WithOverwrite(true))) // Must be solid Rar or 7Zip
 {
-    archive.WriteToDirectory(@"D:\output", new ExtractionOptions()
-    {
-        ExtractFullPath = true,
-        Overwrite = true
-    });
+    archive.WriteToDirectory(@"D:\output");
 }
 ```
 
@@ -147,11 +151,7 @@ using (var reader = ReaderFactory.OpenReader(stream))
         if (!reader.Entry.IsDirectory)
         {
             Console.WriteLine(reader.Entry.Key);
-            reader.WriteEntryToDirectory(@"C:\temp", new ExtractionOptions()
-            {
-                ExtractFullPath = true,
-                Overwrite = true
-            });
+            reader.WriteEntryToDirectory(@"C:\temp");
         }
     }
 }
@@ -180,10 +180,10 @@ 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)
-                                                {
-                                                    LeaveOpenStream = true
-                                                }))
+using (var writer = WriterFactory.OpenWriter(
+    stream,
+    ArchiveType.Tar,
+    WriterOptions.ForTar(CompressionType.GZip).WithLeaveStreamOpen(true)))
 {
     writer.WriteAll("D:\\temp", "*", SearchOption.AllDirectories);
 }
@@ -192,15 +192,15 @@ using (var writer = WriterFactory.OpenWriter(stream, ArchiveType.Tar, new Writer
 ### Extract zip which has non-utf8 encoded filename(cp932)
 
 ```C#
-var opts = new SharpCompress.Readers.ReaderOptions();
 var encoding = Encoding.GetEncoding(932);
-opts.ArchiveEncoding = new SharpCompress.Common.ArchiveEncoding();
-opts.ArchiveEncoding.CustomDecoder = (data, x, y) =>
-{
-    return encoding.GetString(data);
-};
-var tr = SharpCompress.Archives.Zip.ZipArchive.OpenArchive("test.zip", opts);
-foreach(var entry in tr.Entries)
+var opts = new ReaderOptions()
+    .WithArchiveEncoding(new ArchiveEncoding
+    {
+        CustomDecoder = (data, x, y) => encoding.GetString(data)
+    });
+
+using var archive = ZipArchive.OpenArchive("test.zip", opts);
+foreach(var entry in archive.Entries)
 {
     Console.WriteLine($"{entry.Key}");
 }
@@ -238,11 +238,6 @@ using (var reader = ReaderFactory.OpenReader(stream))
 {
     await reader.WriteAllToDirectoryAsync(
         @"D:\temp",
-        new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        },
         cancellationToken
     );
 }
@@ -321,7 +316,6 @@ using (var archive = ZipArchive.OpenArchive("archive.zip"))
     // Simple async extraction - works for all archive types
     await archive.WriteToDirectoryAsync(
         @"C:\output",
-        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
         cancellationToken
     );
 }

src/SharpCompress/Archives/AbstractArchive.Async.cs

@@ -21,7 +21,7 @@ public abstract partial class AbstractArchive<TEntry, TVolume>
         IAsyncEnumerable<TVolume> volumes
     )
     {
-        foreach (var item in LoadEntries(await volumes.ToListAsync()))
+        foreach (var item in LoadEntries(await volumes.ToListAsync().ConfigureAwait(false)))
         {
             yield return item;
         }
@@ -47,8 +47,8 @@ public abstract partial class AbstractArchive<TEntry, TVolume>
 
     private async ValueTask EnsureEntriesLoadedAsync()
     {
-        await _lazyEntriesAsync.EnsureFullyLoaded();
-        await _lazyVolumesAsync.EnsureFullyLoaded();
+        await _lazyEntriesAsync.EnsureFullyLoaded().ConfigureAwait(false);
+        await _lazyVolumesAsync.EnsureFullyLoaded().ConfigureAwait(false);
     }
 
     private async IAsyncEnumerable<IArchiveEntry> EntriesAsyncCast()
@@ -73,29 +73,31 @@ public abstract partial class AbstractArchive<TEntry, TVolume>
 
     public async ValueTask<IAsyncReader> ExtractAllEntriesAsync()
     {
-        if (!await IsSolidAsync() && Type != ArchiveType.SevenZip)
+        if (!await IsSolidAsync().ConfigureAwait(false) && 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();
+        await EnsureEntriesLoadedAsync().ConfigureAwait(false);
+        return await CreateReaderForSolidExtractionAsync().ConfigureAwait(false);
     }
 
     public virtual ValueTask<bool> IsSolidAsync() => new(false);
 
     public async ValueTask<bool> IsCompleteAsync()
     {
-        await EnsureEntriesLoadedAsync();
-        return await EntriesAsync.AllAsync(x => x.IsComplete);
+        await EnsureEntriesLoadedAsync().ConfigureAwait(false);
+        return await EntriesAsync.AllAsync(x => x.IsComplete).ConfigureAwait(false);
     }
 
     public async ValueTask<long> TotalSizeAsync() =>
-        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
+        await EntriesAsync
+            .AggregateAsync(0L, (total, cf) => total + cf.CompressedSize)
+            .ConfigureAwait(false);
 
     public async ValueTask<long> TotalUncompressedSizeAsync() =>
-        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.Size);
+        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.Size).ConfigureAwait(false);
 
     public ValueTask<bool> IsEncryptedAsync() => new(IsEncrypted);
 

src/SharpCompress/Archives/AbstractArchive.cs

@@ -20,7 +20,7 @@ public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyn
     private readonly LazyAsyncReadOnlyCollection<TVolume> _lazyVolumesAsync;
     private readonly LazyAsyncReadOnlyCollection<TEntry> _lazyEntriesAsync;
 
-    protected ReaderOptions ReaderOptions { get; }
+    public ReaderOptions ReaderOptions { get; protected set; }
 
     internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
     {

src/SharpCompress/Archives/AbstractWritableArchive.Async.cs

@@ -5,13 +5,14 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
-using SharpCompress.Writers;
+using SharpCompress.Common.Options;
 
 namespace SharpCompress.Archives;
 
-public abstract partial class AbstractWritableArchive<TEntry, TVolume>
+public abstract partial class AbstractWritableArchive<TEntry, TVolume, TOptions>
     where TEntry : IArchiveEntry
     where TVolume : IVolume
+    where TOptions : IWriterOptions
 {
     // Async property moved from main file
     private IAsyncEnumerable<TEntry> OldEntriesAsync =>
@@ -38,7 +39,7 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         if (!removedEntries.Contains(entry))
         {
             removedEntries.Add(entry);
-            await RebuildModifiedCollectionAsync();
+            await RebuildModifiedCollectionAsync().ConfigureAwait(false);
         }
     }
 
@@ -85,7 +86,7 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         }
         var entry = CreateEntry(key, source, size, modified, closeStream);
         newEntries.Add(entry);
-        await RebuildModifiedCollectionAsync();
+        await RebuildModifiedCollectionAsync().ConfigureAwait(false);
         return entry;
     }
 
@@ -105,13 +106,13 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         }
         var entry = CreateDirectoryEntry(key, modified);
         newEntries.Add(entry);
-        await RebuildModifiedCollectionAsync();
+        await RebuildModifiedCollectionAsync().ConfigureAwait(false);
         return entry;
     }
 
     public async ValueTask SaveToAsync(
         Stream stream,
-        WriterOptions options,
+        TOptions options,
         CancellationToken cancellationToken = default
     )
     {
@@ -120,4 +121,12 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         await SaveToAsync(stream, options, OldEntriesAsync, newEntries, cancellationToken)
             .ConfigureAwait(false);
     }
+
+    protected abstract ValueTask SaveToAsync(
+        Stream stream,
+        TOptions options,
+        IAsyncEnumerable<TEntry> oldEntries,
+        IEnumerable<TEntry> newEntries,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -5,23 +5,25 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.IO;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public abstract partial class AbstractWritableArchive<TEntry, TVolume>
+public abstract partial class AbstractWritableArchive<TEntry, TVolume, TOptions>
     : AbstractArchive<TEntry, TVolume>,
-        IWritableArchive,
-        IWritableAsyncArchive
+        IWritableArchive<TOptions>,
+        IWritableAsyncArchive<TOptions>
     where TEntry : IArchiveEntry
     where TVolume : IVolume
+    where TOptions : IWriterOptions
 {
     private class RebuildPauseDisposable : IDisposable
     {
-        private readonly AbstractWritableArchive<TEntry, TVolume> archive;
+        private readonly AbstractWritableArchive<TEntry, TVolume, TOptions> archive;
 
-        public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume> archive)
+        public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume, TOptions> archive)
         {
             this.archive = archive;
             archive.pauseRebuilding = true;
@@ -150,13 +152,15 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         long size,
         DateTime? modified,
         CancellationToken cancellationToken
-    ) => await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken);
+    ) =>
+        await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken)
+            .ConfigureAwait(false);
 
     async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddDirectoryEntryAsync(
         string key,
         DateTime? modified,
         CancellationToken cancellationToken
-    ) => await AddDirectoryEntryAsync(key, modified, cancellationToken);
+    ) => await AddDirectoryEntryAsync(key, modified, cancellationToken).ConfigureAwait(false);
 
     public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
     {
@@ -174,7 +178,7 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
         return entry;
     }
 
-    public void SaveTo(Stream stream, WriterOptions options)
+    public void SaveTo(Stream stream, TOptions options)
     {
         //reset streams of new entries
         newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
@@ -210,19 +214,11 @@ public abstract partial class AbstractWritableArchive<TEntry, TVolume>
 
     protected abstract void SaveTo(
         Stream stream,
-        WriterOptions options,
+        TOptions options,
         IEnumerable<TEntry> oldEntries,
         IEnumerable<TEntry> newEntries
     );
 
-    protected abstract ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<TEntry> oldEntries,
-        IEnumerable<TEntry> newEntries,
-        CancellationToken cancellationToken = default
-    );
-
     public override void Dispose()
     {
         base.Dispose();

src/SharpCompress/Archives/ArchiveFactory.Async.cs

@@ -19,9 +19,9 @@ public static partial class ArchiveFactory
         CancellationToken cancellationToken = default
     )
     {
-        readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
-        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken);
+        readerOptions ??= ReaderOptions.ForExternalStream;
+        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken)
+            .ConfigureAwait(false);
         return factory.OpenAsyncArchive(stream, readerOptions);
     }
 
@@ -41,9 +41,10 @@ public static partial class ArchiveFactory
         CancellationToken cancellationToken = default
     )
     {
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
+        options ??= ReaderOptions.ForOwnedFile;
 
-        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken);
+        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken)
+            .ConfigureAwait(false);
         return factory.OpenAsyncArchive(fileInfo, options);
     }
 
@@ -63,14 +64,16 @@ public static partial class ArchiveFactory
         var fileInfo = filesArray[0];
         if (filesArray.Length == 1)
         {
-            return await OpenAsyncArchive(fileInfo, options, cancellationToken);
+            return await OpenAsyncArchive(fileInfo, options, cancellationToken)
+                .ConfigureAwait(false);
         }
 
         fileInfo.NotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
+        options ??= ReaderOptions.ForOwnedFile;
 
-        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken);
-        return factory.OpenAsyncArchive(filesArray, options, cancellationToken);
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken)
+            .ConfigureAwait(false);
+        return factory.OpenAsyncArchive(filesArray, options);
     }
 
     public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
@@ -90,13 +93,15 @@ public static partial class ArchiveFactory
         var firstStream = streamsArray[0];
         if (streamsArray.Length == 1)
         {
-            return await OpenAsyncArchive(firstStream, options, cancellationToken);
+            return await OpenAsyncArchive(firstStream, options, cancellationToken)
+                .ConfigureAwait(false);
         }
 
         firstStream.NotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
+        options ??= ReaderOptions.ForExternalStream;
 
-        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken);
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken)
+            .ConfigureAwait(false);
         return factory.OpenAsyncArchive(streamsArray, options);
     }
 
@@ -118,7 +123,7 @@ public static partial class ArchiveFactory
     {
         finfo.NotNull(nameof(finfo));
         using Stream stream = finfo.OpenRead();
-        return await FindFactoryAsync<T>(stream, cancellationToken);
+        return await FindFactoryAsync<T>(stream, cancellationToken).ConfigureAwait(false);
     }
 
     private static async ValueTask<T> FindFactoryAsync<T>(
@@ -141,7 +146,11 @@ public static partial class ArchiveFactory
         {
             stream.Seek(startPosition, SeekOrigin.Begin);
 
-            if (await factory.IsArchiveAsync(stream, cancellationToken: cancellationToken))
+            if (
+                await factory
+                    .IsArchiveAsync(stream, cancellationToken: cancellationToken)
+                    .ConfigureAwait(false)
+            )
             {
                 stream.Seek(startPosition, SeekOrigin.Begin);
 

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Factories;
 using SharpCompress.IO;
 using SharpCompress.Readers;
@@ -15,23 +16,23 @@ public static partial class ArchiveFactory
 {
     public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
     {
-        readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        readerOptions ??= ReaderOptions.ForExternalStream;
         return FindFactory<IArchiveFactory>(stream).OpenArchive(stream, readerOptions);
     }
 
-    public static IWritableArchive CreateArchive(ArchiveType type)
+    public static IWritableArchive<TOptions> CreateArchive<TOptions>()
+        where TOptions : IWriterOptions
     {
         var factory = Factory
-            .Factories.OfType<IWriteableArchiveFactory>()
-            .FirstOrDefault(item => item.KnownArchiveType == type);
+            .Factories.OfType<IWriteableArchiveFactory<TOptions>>()
+            .FirstOrDefault();
 
         if (factory != null)
         {
             return factory.CreateArchive();
         }
 
-        throw new NotSupportedException("Cannot create Archives of type: " + type);
+        throw new NotSupportedException("Cannot create Archives of type: " + typeof(TOptions));
     }
 
     public static IArchive OpenArchive(string filePath, ReaderOptions? options = null)
@@ -42,7 +43,7 @@ public static partial class ArchiveFactory
 
     public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
     {
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
+        options ??= ReaderOptions.ForOwnedFile;
 
         return FindFactory<IArchiveFactory>(fileInfo).OpenArchive(fileInfo, options);
     }
@@ -66,7 +67,7 @@ public static partial class ArchiveFactory
         }
 
         fileInfo.NotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
+        options ??= ReaderOptions.ForOwnedFile;
 
         return FindFactory<IMultiArchiveFactory>(fileInfo).OpenArchive(filesArray, options);
     }
@@ -87,7 +88,7 @@ public static partial class ArchiveFactory
         }
 
         firstStream.NotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
+        options ??= ReaderOptions.ForExternalStream;
 
         return FindFactory<IMultiArchiveFactory>(firstStream).OpenArchive(streamsArray, options);
     }
@@ -95,11 +96,11 @@ public static partial class ArchiveFactory
     public static void WriteToDirectory(
         string sourceArchive,
         string destinationDirectory,
-        ExtractionOptions? options = null
+        ReaderOptions? options = null
     )
     {
-        using var archive = OpenArchive(sourceArchive);
-        archive.WriteToDirectory(destinationDirectory, options);
+        using var archive = OpenArchive(sourceArchive, options);
+        archive.WriteToDirectory(destinationDirectory);
     }
 
     public static T FindFactory<T>(string path)
@@ -150,24 +151,14 @@ public static partial class ArchiveFactory
         );
     }
 
-    // Async methods moved to ArchiveFactory.Async.cs
-
-    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));

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

@@ -5,7 +5,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
-using SharpCompress.IO;
+using SharpCompress.Common.Options;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
@@ -24,13 +24,13 @@ public partial class GZipArchive
     )
     {
         using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
+        await SaveToAsync(stream, new GZipWriterOptions(CompressionType.GZip), cancellationToken)
             .ConfigureAwait(false);
     }
 
     protected override async ValueTask SaveToAsync(
         Stream stream,
-        WriterOptions options,
+        GZipWriterOptions options,
         IAsyncEnumerable<GZipArchiveEntry> oldEntries,
         IEnumerable<GZipArchiveEntry> newEntries,
         CancellationToken cancellationToken = default
@@ -40,14 +40,19 @@ public partial class GZipArchive
         {
             throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
         }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        await using var writer = new GZipWriter(
+            stream,
+            options as GZipWriterOptions ?? new GZipWriterOptions(options)
+        );
         await foreach (
             var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
         )
         {
             if (!entry.IsDirectory)
             {
-                using var entryStream = entry.OpenEntryStream();
+                using var entryStream = await entry
+                    .OpenEntryStreamAsync(cancellationToken)
+                    .ConfigureAwait(false);
                 await writer
                     .WriteAsync(
                         entry.Key.NotNull("Entry Key is null"),
@@ -59,7 +64,9 @@ public partial class GZipArchive
         }
         foreach (var entry in newEntries.Where(x => !x.IsDirectory))
         {
-            using var entryStream = entry.OpenEntryStream();
+            using var entryStream = await entry
+                .OpenEntryStreamAsync(cancellationToken)
+                .ConfigureAwait(false);
             await writer
                 .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
                 .ConfigureAwait(false);
@@ -77,10 +84,13 @@ public partial class GZipArchive
         IAsyncEnumerable<GZipVolume> volumes
     )
     {
-        var stream = (await volumes.SingleAsync()).Stream;
+        var stream = (await volumes.SingleAsync().ConfigureAwait(false)).Stream;
         yield return new GZipArchiveEntry(
             this,
-            await GZipFilePart.CreateAsync(stream, ReaderOptions.ArchiveEncoding)
+            await GZipFilePart
+                .CreateAsync(stream, ReaderOptions.ArchiveEncoding)
+                .ConfigureAwait(false),
+            ReaderOptions
         );
     }
 }

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

@@ -5,43 +5,41 @@ 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>
+    : IWritableArchiveOpenable<GZipWriterOptions>,
+        IMultiArchiveOpenable<
+            IWritableArchive<GZipWriterOptions>,
+            IWritableAsyncArchive<GZipWriterOptions>
+        >
 #endif
 {
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<GZipWriterOptions> OpenAsyncArchive(
         string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         path.NotNullOrEmpty(nameof(path));
-        return (IWritableAsyncArchive)OpenArchive(
-            new FileInfo(path),
-            readerOptions ?? new ReaderOptions()
-        );
+        return (IWritableAsyncArchive<GZipWriterOptions>)
+            OpenArchive(new FileInfo(path), readerOptions ?? new ReaderOptions());
     }
 
-    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    public static IWritableArchive<GZipWriterOptions> OpenArchive(
+        string filePath,
+        ReaderOptions? readerOptions = null
+    )
     {
         filePath.NotNullOrEmpty(nameof(filePath));
         return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<GZipWriterOptions> OpenArchive(
         FileInfo fileInfo,
         ReaderOptions? readerOptions = null
     )
@@ -56,7 +54,7 @@ public partial class GZipArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<GZipWriterOptions> OpenArchive(
         IEnumerable<FileInfo> fileInfos,
         ReaderOptions? readerOptions = null
     )
@@ -72,7 +70,7 @@ public partial class GZipArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<GZipWriterOptions> OpenArchive(
         IEnumerable<Stream> streams,
         ReaderOptions? readerOptions = null
     )
@@ -88,7 +86,10 @@ public partial class GZipArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    public static IWritableArchive<GZipWriterOptions> OpenArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null
+    )
     {
         stream.NotNull(nameof(stream));
 
@@ -102,49 +103,30 @@ public partial class GZipArchive
         );
     }
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<GZipWriterOptions> OpenAsyncArchive(
         Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<GZipWriterOptions>)OpenArchive(stream, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<GZipWriterOptions> OpenAsyncArchive(
         FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<GZipWriterOptions>)OpenArchive(fileInfo, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<GZipWriterOptions> OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<GZipWriterOptions>)OpenArchive(streams, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<GZipWriterOptions> OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<GZipWriterOptions>)OpenArchive(fileInfos, readerOptions);
 
-    public static IWritableArchive CreateArchive() => new GZipArchive();
+    public static IWritableArchive<GZipWriterOptions> CreateArchive() => new GZipArchive();
 
-    public static IWritableAsyncArchive CreateAsyncArchive() => new GZipArchive();
+    public static IWritableAsyncArchive<GZipWriterOptions> CreateAsyncArchive() =>
+        new GZipArchive();
 
     public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
 

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -2,10 +2,9 @@ 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.Common.Options;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
@@ -14,7 +13,8 @@ using SharpCompress.Writers.GZip;
 
 namespace SharpCompress.Archives.GZip;
 
-public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+public partial class GZipArchive
+    : AbstractWritableArchive<GZipArchiveEntry, GZipVolume, GZipWriterOptions>
 {
     private GZipArchive(SourceStream sourceStream)
         : base(ArchiveType.GZip, sourceStream) { }
@@ -33,7 +33,7 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
     public void SaveTo(FileInfo fileInfo)
     {
         using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        SaveTo(stream, new WriterOptions(CompressionType.GZip));
+        SaveTo(stream, new GZipWriterOptions(CompressionType.GZip));
     }
 
     protected override GZipArchiveEntry CreateEntryInternal(
@@ -58,7 +58,7 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
 
     protected override void SaveTo(
         Stream stream,
-        WriterOptions options,
+        GZipWriterOptions options,
         IEnumerable<GZipArchiveEntry> oldEntries,
         IEnumerable<GZipArchiveEntry> newEntries
     )
@@ -67,7 +67,10 @@ 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));
+        using var writer = new GZipWriter(
+            stream,
+            options as GZipWriterOptions ?? new GZipWriterOptions(options)
+        );
         foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
             using var entryStream = entry.OpenEntryStream();
@@ -84,7 +87,8 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         var stream = volumes.Single().Stream;
         yield return new GZipArchiveEntry(
             this,
-            GZipFilePart.Create(stream, ReaderOptions.ArchiveEncoding)
+            GZipFilePart.Create(stream, ReaderOptions.ArchiveEncoding),
+            ReaderOptions
         );
     }
 

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -1,15 +1,16 @@
-using System.IO;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common.GZip;
+using SharpCompress.Common.Options;
 
 namespace SharpCompress.Archives.GZip;
 
 public class GZipArchiveEntry : GZipEntry, IArchiveEntry
 {
-    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart? part)
-        : base(part) => Archive = archive;
+    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart? part, IReaderOptions readerOptions)
+        : base(part, readerOptions) => Archive = archive;
 
     public virtual Stream OpenEntryStream()
     {

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -19,7 +19,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch
         DateTime? lastModified,
         bool closeStream
     )
-        : base(archive, null)
+        : base(archive, null, archive.ReaderOptions)
     {
         this.stream = stream;
         Key = path;
@@ -58,7 +58,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Archives/IArchive.cs

@@ -12,6 +12,11 @@ public interface IArchive : IDisposable
 
     ArchiveType Type { get; }
 
+    /// <summary>
+    /// The options used when opening this archive, including extraction behavior settings.
+    /// </summary>
+    ReaderOptions ReaderOptions { 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

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -9,8 +9,6 @@ namespace SharpCompress.Archives;
 
 public static class IArchiveEntryExtensions
 {
-    private const int BufferSize = 81920;
-
     /// <param name="archiveEntry">The archive entry to extract.</param>
     extension(IArchiveEntry archiveEntry)
     {
@@ -28,7 +26,7 @@ public static class IArchiveEntryExtensions
 
             using var entryStream = archiveEntry.OpenEntryStream();
             var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
-            sourceStream.CopyTo(streamToWriteTo, BufferSize);
+            sourceStream.CopyTo(streamToWriteTo, Constants.BufferSize);
         }
 
         /// <summary>
@@ -48,10 +46,18 @@ public static class IArchiveEntryExtensions
                 throw new ExtractionException("Entry is a file directory and cannot be extracted.");
             }
 
-            using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
+#if LEGACY_DOTNET
+            using var entryStream = await archiveEntry
+                .OpenEntryStreamAsync(cancellationToken)
+                .ConfigureAwait(false);
+#else
+            await using var entryStream = await archiveEntry
+                .OpenEntryStreamAsync(cancellationToken)
+                .ConfigureAwait(false);
+#endif
             var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
             await sourceStream
-                .CopyToAsync(streamToWriteTo, BufferSize, cancellationToken)
+                .CopyToAsync(streamToWriteTo, Constants.BufferSize, cancellationToken)
                 .ConfigureAwait(false);
         }
     }
@@ -96,15 +102,11 @@ public static class IArchiveEntryExtensions
         /// <summary>
         /// Extract to specific directory, retaining filename
         /// </summary>
-        public void WriteToDirectory(
-            string destinationDirectory,
-            ExtractionOptions? options = null
-        ) =>
+        public void WriteToDirectory(string destinationDirectory) =>
             ExtractionMethods.WriteEntryToDirectory(
                 entry,
                 destinationDirectory,
-                options,
-                entry.WriteToFile
+                (path) => entry.WriteToFile(path)
             );
 
         /// <summary>
@@ -112,15 +114,14 @@ public static class IArchiveEntryExtensions
         /// </summary>
         public async ValueTask WriteToDirectoryAsync(
             string destinationDirectory,
-            ExtractionOptions? options = null,
             CancellationToken cancellationToken = default
         ) =>
             await ExtractionMethods
                 .WriteEntryToDirectoryAsync(
                     entry,
                     destinationDirectory,
-                    options,
-                    entry.WriteToFileAsync,
+                    async (path, ct) =>
+                        await entry.WriteToFileAsync(path, ct).ConfigureAwait(false),
                     cancellationToken
                 )
                 .ConfigureAwait(false);
@@ -128,11 +129,10 @@ public static class IArchiveEntryExtensions
         /// <summary>
         /// Extract to specific file
         /// </summary>
-        public void WriteToFile(string destinationFileName, ExtractionOptions? options = null) =>
+        public void WriteToFile(string destinationFileName) =>
             ExtractionMethods.WriteEntryToFile(
                 entry,
                 destinationFileName,
-                options,
                 (x, fm) =>
                 {
                     using var fs = File.Open(destinationFileName, fm);
@@ -145,14 +145,12 @@ public static class IArchiveEntryExtensions
         /// </summary>
         public async ValueTask 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);

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -14,28 +14,25 @@ public static class IArchiveExtensions
         /// Extract to specific directory with progress reporting
         /// </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>
         public void WriteToDirectory(
             string destinationDirectory,
-            ExtractionOptions? options = null,
             IProgress<ProgressReport>? progress = null
         )
         {
             if (archive.IsSolid || archive.Type == ArchiveType.SevenZip)
             {
                 using var reader = archive.ExtractAllEntries();
-                reader.WriteAllToDirectory(destinationDirectory, options);
+                reader.WriteAllToDirectory(destinationDirectory);
             }
             else
             {
-                archive.WriteToDirectoryInternal(destinationDirectory, options, progress);
+                archive.WriteToDirectoryInternal(destinationDirectory, progress);
             }
         }
 
         private void WriteToDirectoryInternal(
             string destinationDirectory,
-            ExtractionOptions? options,
             IProgress<ProgressReport>? progress
         )
         {
@@ -61,7 +58,7 @@ public static class IArchiveExtensions
                     continue;
                 }
 
-                entry.WriteToDirectory(destinationDirectory, options);
+                entry.WriteToDirectory(destinationDirectory);
 
                 bytesRead += entry.Size;
                 progress?.Report(

src/SharpCompress/Archives/IArchiveOpenable.cs

@@ -20,20 +20,17 @@ public interface IArchiveOpenable<TSync, TASync>
 
     public static abstract TASync OpenAsyncArchive(
         string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     );
 
     public static abstract TASync OpenAsyncArchive(
         Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     );
 
     public static abstract TASync OpenAsyncArchive(
         FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     );
 }
 

src/SharpCompress/Archives/IAsyncArchiveExtensions.cs

@@ -17,44 +17,45 @@ public static class IAsyncArchiveExtensions
         /// </summary>
         /// <param name="archive">The archive to extract.</param>
         /// <param name="destinationDirectory">The folder to extract into.</param>
-        /// <param name="options">Extraction options.</param>
         /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
         /// <param name="cancellationToken">Optional cancellation token.</param>
         public async ValueTask WriteToDirectoryAsync(
             string destinationDirectory,
-            ExtractionOptions? options = null,
             IProgress<ProgressReport>? progress = null,
             CancellationToken cancellationToken = default
         )
         {
-            if (await archive.IsSolidAsync() || archive.Type == ArchiveType.SevenZip)
+            if (
+                await archive.IsSolidAsync().ConfigureAwait(false)
+                || archive.Type == ArchiveType.SevenZip
+            )
             {
-                await using var reader = await archive.ExtractAllEntriesAsync();
-                await reader.WriteAllToDirectoryAsync(
-                    destinationDirectory,
-                    options,
-                    cancellationToken
-                );
+                await using var reader = await archive
+                    .ExtractAllEntriesAsync()
+                    .ConfigureAwait(false);
+                await reader
+                    .WriteAllToDirectoryAsync(destinationDirectory, cancellationToken)
+                    .ConfigureAwait(false);
             }
             else
             {
-                await archive.WriteToDirectoryAsyncInternal(
-                    destinationDirectory,
-                    options,
-                    progress,
-                    cancellationToken
-                );
+                await archive
+                    .WriteToDirectoryAsyncInternal(
+                        destinationDirectory,
+                        progress,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
             }
         }
 
         private async ValueTask WriteToDirectoryAsyncInternal(
             string destinationDirectory,
-            ExtractionOptions? options,
             IProgress<ProgressReport>? progress,
             CancellationToken cancellationToken
         )
         {
-            var totalBytes = await archive.TotalUncompressedSizeAsync();
+            var totalBytes = await archive.TotalUncompressedSizeAsync().ConfigureAwait(false);
             var bytesRead = 0L;
             var seenDirectories = new HashSet<string>();
 
@@ -79,7 +80,7 @@ public static class IAsyncArchiveExtensions
                 }
 
                 await entry
-                    .WriteToDirectoryAsync(destinationDirectory, options, cancellationToken)
+                    .WriteToDirectoryAsync(destinationDirectory, cancellationToken)
                     .ConfigureAwait(false);
 
                 bytesRead += entry.Size;

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -50,10 +50,8 @@ public interface IMultiArchiveFactory : IFactory
     /// </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
+        ReaderOptions? readerOptions = null
     );
 }

src/SharpCompress/Archives/IMultiArchiveOpenable.cs

@@ -22,14 +22,12 @@ public interface IMultiArchiveOpenable<TSync, TASync>
 
     public static abstract TASync OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     );
 
     public static abstract TASync OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     );
 }
 #endif

src/SharpCompress/Archives/IWritableArchive.cs

@@ -2,6 +2,7 @@ using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using SharpCompress.Common.Options;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
@@ -27,28 +28,23 @@ 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
+public interface IWritableArchive<TOptions> : IWritableArchive
+    where TOptions : IWriterOptions
 {
     /// <summary>
-    /// Asynchronously saves the archive to the specified stream using the given writer options.
+    /// Saves the archive to the specified stream using the given writer options.
     /// </summary>
-    ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    );
+    void SaveTo(Stream stream, TOptions options);
+}
 
+public interface IWritableAsyncArchive : IAsyncArchive, IWritableArchiveCommon
+{
     /// <summary>
     /// Asynchronously adds an entry to the archive with the specified key, source stream, and options.
     /// </summary>
@@ -75,3 +71,16 @@ public interface IWritableAsyncArchive : IAsyncArchive, IWritableArchiveCommon
     /// </summary>
     ValueTask RemoveEntryAsync(IArchiveEntry entry);
 }
+
+public interface IWritableAsyncArchive<TOptions> : IWritableAsyncArchive
+    where TOptions : IWriterOptions
+{
+    /// <summary>
+    /// Asynchronously saves the archive to the specified stream using the given writer options.
+    /// </summary>
+    ValueTask SaveToAsync(
+        Stream stream,
+        TOptions options,
+        CancellationToken cancellationToken = default
+    );
+}

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
@@ -57,14 +58,23 @@ public static class IWritableArchiveExtensions
                 fileInfo.LastWriteTime
             );
         }
+    }
 
-        public void SaveTo(string filePath, WriterOptions? options = null) =>
-            writableArchive.SaveTo(new FileInfo(filePath), options ?? new(CompressionType.Deflate));
+    public static void SaveTo<TOptions>(
+        this IWritableArchive<TOptions> writableArchive,
+        string filePath,
+        TOptions options
+    )
+        where TOptions : IWriterOptions => writableArchive.SaveTo(new FileInfo(filePath), options);
 
-        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 void SaveTo<TOptions>(
+        this IWritableArchive<TOptions> writableArchive,
+        FileInfo fileInfo,
+        TOptions options
+    )
+        where TOptions : IWriterOptions
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        writableArchive.SaveTo(stream, options);
     }
 }

src/SharpCompress/Archives/IWritableArchiveOpenable.cs

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

src/SharpCompress/Archives/IWritableAsyncArchiveExtensions.cs

@@ -3,6 +3,7 @@ using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
@@ -24,13 +25,15 @@ public static class IWritableAsyncArchiveExtensions
                 )
                 {
                     var fileInfo = new FileInfo(path);
-                    await writableArchive.AddEntryAsync(
-                        path.Substring(filePath.Length),
-                        fileInfo.OpenRead(),
-                        true,
-                        fileInfo.Length,
-                        fileInfo.LastWriteTime
-                    );
+                    await writableArchive
+                        .AddEntryAsync(
+                            path.Substring(filePath.Length),
+                            fileInfo.OpenRead(),
+                            true,
+                            fileInfo.Length,
+                            fileInfo.LastWriteTime
+                        )
+                        .ConfigureAwait(false);
                 }
             }
         }
@@ -59,28 +62,26 @@ public static class IWritableAsyncArchiveExtensions
                 fileInfo.LastWriteTime
             );
         }
+    }
 
-        public ValueTask SaveToAsync(
-            string filePath,
-            WriterOptions? options = null,
-            CancellationToken cancellationToken = default
-        ) =>
-            writableArchive.SaveToAsync(
-                new FileInfo(filePath),
-                options ?? new(CompressionType.Deflate),
-                cancellationToken
-            );
+    public static ValueTask SaveToAsync<TOptions>(
+        this IWritableAsyncArchive<TOptions> writableArchive,
+        string filePath,
+        TOptions options,
+        CancellationToken cancellationToken = default
+    )
+        where TOptions : IWriterOptions =>
+        writableArchive.SaveToAsync(new FileInfo(filePath), options, 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);
-        }
+    public static async ValueTask SaveToAsync<TOptions>(
+        this IWritableAsyncArchive<TOptions> writableArchive,
+        FileInfo fileInfo,
+        TOptions options,
+        CancellationToken cancellationToken = default
+    )
+        where TOptions : IWriterOptions
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await writableArchive.SaveToAsync(stream, options, cancellationToken).ConfigureAwait(false);
     }
 }

src/SharpCompress/Archives/IWriteableArchiveFactory.cs

@@ -1,3 +1,5 @@
+using SharpCompress.Common.Options;
+
 namespace SharpCompress.Archives;
 
 /// <summary>
@@ -10,11 +12,12 @@ namespace SharpCompress.Archives;
 /// <item><see cref="Factories.ZipFactory"/></item>
 /// <item><see cref="Factories.GZipFactory"/></item>
 /// </list>
-public interface IWriteableArchiveFactory : Factories.IFactory
+public interface IWriteableArchiveFactory<TOptions> : Factories.IFactory
+    where TOptions : IWriterOptions
 {
     /// <summary>
     /// Creates a new, empty archive, ready to be written.
     /// </summary>
     /// <returns></returns>
-    IWritableArchive CreateArchive();
+    IWritableArchive<TOptions> CreateArchive();
 }

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -24,8 +24,7 @@ internal class FileInfoRarArchiveVolume : RarVolume
     private static ReaderOptions FixOptions(ReaderOptions options)
     {
         //make sure we're closing streams with fileinfo
-        options.LeaveStreamOpen = false;
-        return options;
+        return options with { LeaveStreamOpen = false };
     }
 
     internal ReadOnlyCollection<RarFilePart> FileParts { get; }

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

@@ -25,13 +25,13 @@ public partial class RarArchive
             }
 
             _disposed = true;
-            await base.DisposeAsync();
+            await base.DisposeAsync().ConfigureAwait(false);
         }
     }
 
     protected override async ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
     {
-        if (await this.IsMultipartVolumeAsync())
+        if (await this.IsMultipartVolumeAsync().ConfigureAwait(false))
         {
             var streams = await VolumesAsync
                 .Select(volume =>
@@ -39,15 +39,18 @@ public partial class RarArchive
                     volume.Stream.Position = 0;
                     return volume.Stream;
                 })
-                .ToListAsync();
+                .ToListAsync()
+                .ConfigureAwait(false);
             return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
         }
 
-        var stream = (await VolumesAsync.FirstAsync()).Stream;
+        var stream = (await VolumesAsync.FirstAsync().ConfigureAwait(false)).Stream;
         stream.Position = 0;
         return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
     }
 
     public override async ValueTask<bool> IsSolidAsync() =>
-        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsSolidArchiveAsync();
+        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync().ConfigureAwait(false))
+            .IsSolidArchiveAsync()
+            .ConfigureAwait(false);
 }

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

@@ -25,12 +25,16 @@ public static class RarArchiveExtensions
         /// 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;
+            (
+                await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync().ConfigureAwait(false)
+            ).IsFirstVolume;
 
         /// <summary>
         /// RarArchive is part of a multi-part archive.
         /// </summary>
         public async ValueTask<bool> IsMultipartVolumeAsync() =>
-            (await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsMultiVolume;
+            (
+                await archive.VolumesAsync.CastAsync<RarVolume>().FirstAsync().ConfigureAwait(false)
+            ).IsMultiVolume;
     }
 }

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

@@ -22,11 +22,9 @@ public partial class RarArchive
 {
     public static IRarAsyncArchive OpenAsyncArchive(
         string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         path.NotNullOrEmpty(nameof(path));
         return (IRarAsyncArchive)OpenArchive(new FileInfo(path), readerOptions);
     }
@@ -102,41 +100,33 @@ public partial class RarArchive
 
     public static IRarAsyncArchive OpenAsyncArchive(
         Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IRarAsyncArchive)OpenArchive(stream, readerOptions);
     }
 
     public static IRarAsyncArchive OpenAsyncArchive(
         FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IRarAsyncArchive)OpenArchive(fileInfo, readerOptions);
     }
 
     public static IRarAsyncArchive OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IRarAsyncArchive)OpenArchive(streams, readerOptions);
     }
 
     public static IRarAsyncArchive OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IRarAsyncArchive)OpenArchive(fileInfos, readerOptions);
     }
 

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

@@ -21,9 +21,9 @@ public partial class RarArchiveEntry
             stream = new RarStream(
                 archive.UnpackV1.Value,
                 FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
+                await MultiVolumeReadOnlyAsyncStream
+                    .Create(Parts.ToAsyncEnumerable().CastAsync<RarFilePart>())
+                    .ConfigureAwait(false)
             );
         }
         else
@@ -31,13 +31,13 @@ public partial class RarArchiveEntry
             stream = new RarStream(
                 archive.UnpackV2017.Value,
                 FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
+                await MultiVolumeReadOnlyAsyncStream
+                    .Create(Parts.ToAsyncEnumerable().CastAsync<RarFilePart>())
+                    .ConfigureAwait(false)
             );
         }
 
-        await stream.InitializeAsync(cancellationToken);
+        await stream.InitializeAsync(cancellationToken).ConfigureAwait(false);
         return stream;
     }
 }

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -23,6 +23,7 @@ public partial class RarArchiveEntry : RarEntry, IArchiveEntry
         IEnumerable<RarFilePart> parts,
         ReaderOptions readerOptions
     )
+        : base(readerOptions)
     {
         this.parts = parts.ToList();
         this.archive = archive;

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

@@ -21,15 +21,12 @@ public partial class SevenZipArchive
         {
             stream.Position = 0;
             var reader = new ArchiveReader();
-            await reader.OpenAsync(
-                stream,
-                lookForHeader: ReaderOptions.LookForHeader,
-                cancellationToken
-            );
-            _database = await reader.ReadDatabaseAsync(
-                new PasswordProvider(ReaderOptions.Password),
-                cancellationToken
-            );
+            await reader
+                .OpenAsync(stream, lookForHeader: ReaderOptions.LookForHeader, cancellationToken)
+                .ConfigureAwait(false);
+            _database = await reader
+                .ReadDatabaseAsync(new PasswordProvider(ReaderOptions.Password), cancellationToken)
+                .ConfigureAwait(false);
         }
     }
 
@@ -37,8 +34,8 @@ public partial class SevenZipArchive
         IAsyncEnumerable<SevenZipVolume> volumes
     )
     {
-        var stream = (await volumes.SingleAsync()).Stream;
-        await LoadFactoryAsync(stream);
+        var stream = (await volumes.SingleAsync().ConfigureAwait(false)).Stream;
+        await LoadFactoryAsync(stream).ConfigureAwait(false);
         if (_database is null)
         {
             yield break;
@@ -49,7 +46,8 @@ public partial class SevenZipArchive
             var file = _database._files[i];
             entries[i] = new SevenZipArchiveEntry(
                 this,
-                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
+                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding),
+                ReaderOptions
             );
         }
         foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))

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

@@ -16,13 +16,8 @@ public partial class SevenZipArchive
         IMultiArchiveOpenable<IArchive, IAsyncArchive>
 #endif
 {
-    public static IAsyncArchive OpenAsyncArchive(
-        string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
+    public static IAsyncArchive OpenAsyncArchive(string path, ReaderOptions? readerOptions = null)
     {
-        cancellationToken.ThrowIfCancellationRequested();
         path.NotNullOrEmpty("path");
         return (IAsyncArchive)OpenArchive(new FileInfo(path), readerOptions ?? new ReaderOptions());
     }
@@ -91,43 +86,32 @@ public partial class SevenZipArchive
         );
     }
 
-    public static IAsyncArchive OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
+    public static IAsyncArchive OpenAsyncArchive(Stream stream, ReaderOptions? readerOptions = null)
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IAsyncArchive)OpenArchive(stream, readerOptions);
     }
 
     public static IAsyncArchive OpenAsyncArchive(
         FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IAsyncArchive)OpenArchive(fileInfo, readerOptions);
     }
 
     public static IAsyncArchive OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IAsyncArchive)OpenArchive(streams, readerOptions);
     }
 
     public static IAsyncArchive OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
+        ReaderOptions? readerOptions = null
     )
     {
-        cancellationToken.ThrowIfCancellationRequested();
         return (IAsyncArchive)OpenArchive(fileInfos, readerOptions);
     }
 
@@ -163,7 +147,7 @@ public partial class SevenZipArchive
         cancellationToken.ThrowIfCancellationRequested();
         try
         {
-            return await SignatureMatchAsync(stream, cancellationToken);
+            return await SignatureMatchAsync(stream, cancellationToken).ConfigureAwait(false);
         }
         catch
         {

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -16,18 +16,22 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
 {
     private ArchiveDatabase? _database;
 
+    /// <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
     }
 
+    internal SevenZipArchive()
+        : base(ArchiveType.SevenZip) { }
+
     protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(
         IEnumerable<SevenZipVolume> volumes
     )
@@ -51,7 +55,8 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
                         i,
                         file,
                         ReaderOptions.ArchiveEncoding
-                    )
+                    ),
+                    ReaderOptions
                 );
             }
             foreach (
@@ -98,13 +103,34 @@ 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;
+            : base(readerOptions, ArchiveType.SevenZip, false) => this._archive = archive;
 
         public override SevenZipVolume Volume => _archive.Volumes.Single();
 
@@ -117,6 +143,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;
@@ -131,10 +161,53 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
             {
                 return CreateEntryStream(Stream.Null);
             }
-            return CreateEntryStream(new SyncOnlyStream(entry.FilePart.GetCompressedStream()));
+
+            var folder = entry.FilePart.Folder;
+
+            // Check if we're starting a new folder - dispose old folder stream if needed
+            if (folder != _currentFolder)
+            {
+                _currentFolderStream?.Dispose();
+                _currentFolderStream = null;
+                _currentFolder = folder;
+            }
+
+            // Create the folder stream once per folder
+            if (_currentFolderStream is null)
+            {
+                _currentFolderStream = _archive._database!.GetFolderStream(
+                    _archive.Volumes.Single().Stream,
+                    folder!,
+                    _archive._database.PasswordProvider
+                );
+            }
+
+            // Wrap with SyncOnlyStream to work around LZMA async bugs
+            // Return a ReadOnlySubStream that reads from the shared folder stream
+            return CreateEntryStream(
+                new SyncOnlyStream(
+                    new ReadOnlySubStream(_currentFolderStream, entry.Size, leaveOpen: true)
+                )
+            );
+        }
+
+        public override void Dispose()
+        {
+            _currentFolderStream?.Dispose();
+            _currentFolderStream = null;
+            base.Dispose();
         }
     }
 
+    /// <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;
@@ -164,6 +237,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

@@ -1,19 +1,28 @@
-using System.IO;
+using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.SevenZip;
 
 namespace SharpCompress.Archives.SevenZip;
 
 public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 {
-    internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
-        : base(part) => Archive = archive;
+    internal SevenZipArchiveEntry(
+        SevenZipArchive archive,
+        SevenZipFilePart part,
+        IReaderOptions readerOptions
+    )
+        : base(part, readerOptions) => Archive = archive;
 
     public Stream OpenEntryStream() => FilePart.GetCompressedStream();
 
-    public ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        new(OpenEntryStream());
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) =>
+        (
+            await FilePart.GetCompressedStreamAsync(cancellationToken).ConfigureAwait(false)
+        ).NotNull();
 
     public IArchive Archive { get; }
 

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

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
@@ -18,13 +19,16 @@ public partial class TarArchive
 {
     protected override async ValueTask SaveToAsync(
         Stream stream,
-        WriterOptions options,
+        TarWriterOptions options,
         IAsyncEnumerable<TarArchiveEntry> oldEntries,
         IEnumerable<TarArchiveEntry> newEntries,
         CancellationToken cancellationToken = default
     )
     {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        using var writer = new TarWriter(
+            stream,
+            options as TarWriterOptions ?? new TarWriterOptions(options)
+        );
         await foreach (
             var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
         )
@@ -92,7 +96,7 @@ public partial class TarArchive
         IAsyncEnumerable<TarVolume> volumes
     )
     {
-        var stream = (await volumes.SingleAsync()).Stream;
+        var stream = (await volumes.SingleAsync().ConfigureAwait(false)).Stream;
         if (stream.CanSeek)
         {
             stream.Position = 0;
@@ -123,7 +127,8 @@ public partial class TarArchive
                             var entry = new TarArchiveEntry(
                                 this,
                                 new TarFilePart(previousHeader, stream),
-                                CompressionType.None
+                                CompressionType.None,
+                                ReaderOptions
                             );
 
                             var oldStreamPos = stream.Position;
@@ -131,7 +136,7 @@ public partial class TarArchive
                             using (var entryStream = entry.OpenEntryStream())
                             {
                                 using var memoryStream = new MemoryStream();
-                                await entryStream.CopyToAsync(memoryStream);
+                                await entryStream.CopyToAsync(memoryStream).ConfigureAwait(false);
                                 memoryStream.Position = 0;
                                 var bytes = memoryStream.ToArray();
 
@@ -147,7 +152,8 @@ public partial class TarArchive
                         yield return new TarArchiveEntry(
                             this,
                             new TarFilePart(header, stream),
-                            CompressionType.None
+                            CompressionType.None,
+                            ReaderOptions
                         );
                     }
                 }

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

@@ -9,22 +9,29 @@ using SharpCompress.Common;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
+using SharpCompress.Writers.Tar;
 
 namespace SharpCompress.Archives.Tar;
 
 public partial class TarArchive
 #if NET8_0_OR_GREATER
-    : IWritableArchiveOpenable,
-        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
+    : IWritableArchiveOpenable<TarWriterOptions>,
+        IMultiArchiveOpenable<
+            IWritableArchive<TarWriterOptions>,
+            IWritableAsyncArchive<TarWriterOptions>
+        >
 #endif
 {
-    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    public static IWritableArchive<TarWriterOptions> OpenArchive(
+        string filePath,
+        ReaderOptions? readerOptions = null
+    )
     {
         filePath.NotNullOrEmpty(nameof(filePath));
         return OpenArchive(new FileInfo(filePath), readerOptions);
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<TarWriterOptions> OpenArchive(
         FileInfo fileInfo,
         ReaderOptions? readerOptions = null
     )
@@ -39,7 +46,7 @@ public partial class TarArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<TarWriterOptions> OpenArchive(
         IEnumerable<FileInfo> fileInfos,
         ReaderOptions? readerOptions = null
     )
@@ -55,7 +62,7 @@ public partial class TarArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<TarWriterOptions> OpenArchive(
         IEnumerable<Stream> streams,
         ReaderOptions? readerOptions = null
     )
@@ -71,7 +78,10 @@ public partial class TarArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    public static IWritableArchive<TarWriterOptions> OpenArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null
+    )
     {
         stream.NotNull(nameof(stream));
 
@@ -85,55 +95,30 @@ public partial class TarArchive
         );
     }
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<TarWriterOptions> OpenAsyncArchive(
         Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<TarWriterOptions>)OpenArchive(stream, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<TarWriterOptions> OpenAsyncArchive(
         string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(new FileInfo(path), readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<TarWriterOptions>)OpenArchive(new FileInfo(path), readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<TarWriterOptions> OpenAsyncArchive(
         FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<TarWriterOptions>)OpenArchive(fileInfo, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<TarWriterOptions> OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<TarWriterOptions>)OpenArchive(streams, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<TarWriterOptions> OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<TarWriterOptions>)OpenArchive(fileInfos, readerOptions);
 
     public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
 
@@ -176,8 +161,12 @@ public partial class TarArchive
         try
         {
             var tarHeader = new TarHeader(new ArchiveEncoding());
-            var reader = new AsyncBinaryReader(stream, false);
-            var readSucceeded = await tarHeader.ReadAsync(reader);
+#if NET8_0_OR_GREATER
+            await using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
+#else
+            using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
+#endif
+            var readSucceeded = await tarHeader.ReadAsync(reader).ConfigureAwait(false);
             var isEmptyArchive =
                 tarHeader.Name?.Length == 0
                 && tarHeader.Size == 0
@@ -192,7 +181,7 @@ public partial class TarArchive
         }
     }
 
-    public static IWritableArchive CreateArchive() => new TarArchive();
+    public static IWritableArchive<TarWriterOptions> CreateArchive() => new TarArchive();
 
-    public static IWritableAsyncArchive CreateAsyncArchive() => new TarArchive();
+    public static IWritableAsyncArchive<TarWriterOptions> CreateAsyncArchive() => new TarArchive();
 }

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
@@ -15,7 +16,8 @@ using SharpCompress.Writers.Tar;
 
 namespace SharpCompress.Archives.Tar;
 
-public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+public partial class TarArchive
+    : AbstractWritableArchive<TarArchiveEntry, TarVolume, TarWriterOptions>
 {
     protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
     {
@@ -58,7 +60,8 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
                         var entry = new TarArchiveEntry(
                             this,
                             new TarFilePart(previousHeader, stream),
-                            CompressionType.None
+                            CompressionType.None,
+                            ReaderOptions
                         );
 
                         var oldStreamPos = stream.Position;
@@ -66,7 +69,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();
 
@@ -80,7 +83,8 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
                     yield return new TarArchiveEntry(
                         this,
                         new TarFilePart(header, stream),
-                        CompressionType.None
+                        CompressionType.None,
+                        ReaderOptions
                     );
                 }
             }
@@ -115,12 +119,15 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
 
     protected override void SaveTo(
         Stream stream,
-        WriterOptions options,
+        TarWriterOptions options,
         IEnumerable<TarArchiveEntry> oldEntries,
         IEnumerable<TarArchiveEntry> newEntries
     )
     {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        using var writer = new TarWriter(
+            stream,
+            options as TarWriterOptions ?? new TarWriterOptions(options)
+        );
         foreach (var entry in oldEntries.Concat(newEntries))
         {
             if (entry.IsDirectory)

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -1,21 +1,31 @@
-using System.IO;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.Tar;
 
 namespace SharpCompress.Archives.Tar;
 
 public class TarArchiveEntry : TarEntry, IArchiveEntry
 {
-    internal TarArchiveEntry(TarArchive archive, TarFilePart? part, CompressionType compressionType)
-        : base(part, compressionType) => Archive = archive;
+    internal TarArchiveEntry(
+        TarArchive archive,
+        TarFilePart? part,
+        CompressionType compressionType,
+        IReaderOptions readerOptions
+    )
+        : base(part, compressionType, readerOptions) => Archive = archive;
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        new(OpenEntryStream());
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) =>
+        (
+            await Parts.Single().GetCompressedStreamAsync(cancellationToken).ConfigureAwait(false)
+        ).NotNull();
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -21,7 +21,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
         DateTime? lastModified,
         bool closeStream
     )
-        : base(archive, null, compressionType)
+        : base(archive, null, compressionType, archive.ReaderOptions)
     {
         this.stream = stream;
         Key = path;
@@ -36,7 +36,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
         string directoryPath,
         DateTime? lastModified
     )
-        : base(archive, null, CompressionType.None)
+        : base(archive, null, CompressionType.None, archive.ReaderOptions)
     {
         stream = null;
         Key = directoryPath;
@@ -79,7 +79,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

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

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
@@ -20,7 +21,7 @@ public partial class ZipArchive
         IAsyncEnumerable<ZipVolume> volumes
     )
     {
-        var vols = await volumes.ToListAsync();
+        var vols = await volumes.ToListAsync().ConfigureAwait(false);
         var volsArray = vols.ToArray();
 
         await foreach (
@@ -54,7 +55,8 @@ public partial class ZipArchive
 
                             yield return new ZipArchiveEntry(
                                 this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s),
+                                ReaderOptions
                             );
                         }
                         break;
@@ -71,13 +73,16 @@ public partial class ZipArchive
 
     protected override async ValueTask SaveToAsync(
         Stream stream,
-        WriterOptions options,
+        ZipWriterOptions options,
         IAsyncEnumerable<ZipArchiveEntry> oldEntries,
         IEnumerable<ZipArchiveEntry> newEntries,
         CancellationToken cancellationToken = default
     )
     {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        using var writer = new ZipWriter(
+            stream,
+            options as ZipWriterOptions ?? new ZipWriterOptions(options)
+        );
         await foreach (
             var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
         )

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

@@ -9,22 +9,29 @@ using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
+using SharpCompress.Writers.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
 public partial class ZipArchive
 #if NET8_0_OR_GREATER
-    : IWritableArchiveOpenable,
-        IMultiArchiveOpenable<IWritableArchive, IWritableAsyncArchive>
+    : IWritableArchiveOpenable<ZipWriterOptions>,
+        IMultiArchiveOpenable<
+            IWritableArchive<ZipWriterOptions>,
+            IWritableAsyncArchive<ZipWriterOptions>
+        >
 #endif
 {
-    public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
+    public static IWritableArchive<ZipWriterOptions> OpenArchive(
+        string filePath,
+        ReaderOptions? readerOptions = null
+    )
     {
         filePath.NotNullOrEmpty(nameof(filePath));
         return OpenArchive(new FileInfo(filePath), readerOptions);
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<ZipWriterOptions> OpenArchive(
         FileInfo fileInfo,
         ReaderOptions? readerOptions = null
     )
@@ -39,7 +46,7 @@ public partial class ZipArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<ZipWriterOptions> OpenArchive(
         IEnumerable<FileInfo> fileInfos,
         ReaderOptions? readerOptions = null
     )
@@ -55,7 +62,7 @@ public partial class ZipArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(
+    public static IWritableArchive<ZipWriterOptions> OpenArchive(
         IEnumerable<Stream> streams,
         ReaderOptions? readerOptions = null
     )
@@ -71,7 +78,10 @@ public partial class ZipArchive
         );
     }
 
-    public static IWritableArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
+    public static IWritableArchive<ZipWriterOptions> OpenArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null
+    )
     {
         stream.NotNull(nameof(stream));
 
@@ -85,90 +95,49 @@ public partial class ZipArchive
         );
     }
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<ZipWriterOptions> OpenAsyncArchive(
         string path,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(path, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<ZipWriterOptions>)OpenArchive(path, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<ZipWriterOptions> OpenAsyncArchive(
         Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(stream, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<ZipWriterOptions>)OpenArchive(stream, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<ZipWriterOptions> OpenAsyncArchive(
         FileInfo fileInfo,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfo, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<ZipWriterOptions>)OpenArchive(fileInfo, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<ZipWriterOptions> OpenAsyncArchive(
         IReadOnlyList<Stream> streams,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(streams, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<ZipWriterOptions>)OpenArchive(streams, readerOptions);
 
-    public static IWritableAsyncArchive OpenAsyncArchive(
+    public static IWritableAsyncArchive<ZipWriterOptions> OpenAsyncArchive(
         IReadOnlyList<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        return (IWritableAsyncArchive)OpenArchive(fileInfos, readerOptions);
-    }
+        ReaderOptions? readerOptions = null
+    ) => (IWritableAsyncArchive<ZipWriterOptions>)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(string filePath, string? password = null) =>
+        IsZipFile(new FileInfo(filePath), password);
 
-    public static bool IsZipFile(
-        FileInfo fileInfo,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
+    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
     {
         if (!fileInfo.Exists)
         {
             return false;
         }
         using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password, bufferSize);
+        return IsZipFile(stream, password);
     }
 
-    public static bool IsZipFile(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
+    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: bufferSize);
-            }
-
             var header = headerFactory
                 .ReadStreamHeader(stream)
                 .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
@@ -188,20 +157,11 @@ public partial class ZipArchive
         }
     }
 
-    public static bool IsZipMulti(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    )
+    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: bufferSize);
-            }
-
             var header = headerFactory
                 .ReadStreamHeader(stream)
                 .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
@@ -233,7 +193,6 @@ public partial class ZipArchive
     public static async ValueTask<bool> IsZipFileAsync(
         Stream stream,
         string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
         CancellationToken cancellationToken = default
     )
     {
@@ -241,15 +200,11 @@ public partial class ZipArchive
         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);
+                .FirstOrDefaultAsync(cancellationToken)
+                .ConfigureAwait(false);
             if (header is null)
             {
                 return false;
@@ -266,14 +221,13 @@ public partial class ZipArchive
         }
     }
 
-    public static IWritableArchive CreateArchive() => new ZipArchive();
+    public static IWritableArchive<ZipWriterOptions> CreateArchive() => new ZipArchive();
 
-    public static IWritableAsyncArchive CreateAsyncArchive() => new ZipArchive();
+    public static IWritableAsyncArchive<ZipWriterOptions> CreateAsyncArchive() => new ZipArchive();
 
     public static async ValueTask<bool> IsZipMultiAsync(
         Stream stream,
         string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize,
         CancellationToken cancellationToken = default
     )
     {
@@ -281,11 +235,6 @@ public partial class ZipArchive
         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);
@@ -298,6 +247,7 @@ public partial class ZipArchive
                     await foreach (
                         var h in z.ReadSeekableHeaderAsync(stream)
                             .WithCancellation(cancellationToken)
+                            .ConfigureAwait(false)
                     )
                     {
                         x = h;

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
@@ -16,7 +17,8 @@ using SharpCompress.Writers.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+public partial class ZipArchive
+    : AbstractWritableArchive<ZipArchiveEntry, ZipVolume, ZipWriterOptions>
 {
     private readonly SeekableZipHeaderFactory? headerFactory;
 
@@ -35,7 +37,7 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
     protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
     {
         stream.LoadAllParts();
-        stream.Position = 0;
+        //stream.Position = 0;
 
         var streams = stream.Streams.ToList();
         var idx = 0;
@@ -45,11 +47,7 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
             var headerProbeStream = streams[1];
             var startPosition = headerProbeStream.Position;
             headerProbeStream.Position = startPosition + 4;
-            var isZip = IsZipFile(
-                headerProbeStream,
-                ReaderOptions.Password,
-                ReaderOptions.BufferSize
-            );
+            var isZip = IsZipFile(headerProbeStream, ReaderOptions.Password);
             headerProbeStream.Position = startPosition;
             if (isZip)
             {
@@ -98,7 +96,8 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
 
                             yield return new ZipArchiveEntry(
                                 this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s),
+                                ReaderOptions
                             );
                         }
                         break;
@@ -113,16 +112,20 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         }
     }
 
-    public void SaveTo(Stream stream) => SaveTo(stream, new WriterOptions(CompressionType.Deflate));
+    public void SaveTo(Stream stream) =>
+        SaveTo(stream, new ZipWriterOptions(CompressionType.Deflate));
 
     protected override void SaveTo(
         Stream stream,
-        WriterOptions options,
+        ZipWriterOptions options,
         IEnumerable<ZipArchiveEntry> oldEntries,
         IEnumerable<ZipArchiveEntry> newEntries
     )
     {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        using var writer = new ZipWriter(
+            stream,
+            options as ZipWriterOptions ?? new ZipWriterOptions(options)
+        );
         foreach (var entry in oldEntries.Concat(newEntries))
         {
             if (entry.IsDirectory)
@@ -160,7 +163,7 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
-        ((IStreamStack)stream).StackSeek(0);
+        //stream.Position = 0;
         return ZipReader.OpenReader(stream, ReaderOptions, Entries);
     }
 

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

@@ -15,7 +15,9 @@ public partial class ZipArchiveEntry
         var part = Parts.Single();
         if (part is SeekableZipFilePart seekablePart)
         {
-            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
+            return (
+                await seekablePart.GetCompressedStreamAsync(cancellationToken).ConfigureAwait(false)
+            ).NotNull();
         }
         return OpenEntryStream();
     }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -1,15 +1,20 @@
-using System.IO;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using SharpCompress.Common.Options;
 using SharpCompress.Common.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
 public partial class ZipArchiveEntry : ZipEntry, IArchiveEntry
 {
-    internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
-        : base(part) => Archive = archive;
+    internal ZipArchiveEntry(
+        ZipArchive archive,
+        SeekableZipFilePart? part,
+        IReaderOptions readerOptions
+    )
+        : base(part, readerOptions) => Archive = archive;
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -21,7 +21,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
         DateTime? lastModified,
         bool closeStream
     )
-        : base(archive, null)
+        : base(archive, null, archive.ReaderOptions)
     {
         this.stream = stream;
         Key = path;
@@ -36,7 +36,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
         string directoryPath,
         DateTime? lastModified
     )
-        : base(archive, null)
+        : base(archive, null, archive.ReaderOptions)
     {
         stream = null;
         Key = directoryPath;
@@ -80,7 +80,7 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Common/Ace/AceCrc.cs

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

src/SharpCompress/Common/Ace/AceEntry.cs

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

src/SharpCompress/Common/Ace/AceFilePart.cs

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

src/SharpCompress/Common/Ace/AceVolume.cs

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

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

@@ -18,7 +18,7 @@ public sealed partial class AceFileHeader
         CancellationToken cancellationToken = default
     )
     {
-        var headerData = await ReadHeaderAsync(stream, cancellationToken);
+        var headerData = await ReadHeaderAsync(stream, cancellationToken).ConfigureAwait(false);
         if (headerData.Length == 0)
         {
             return null;

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

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

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

@@ -19,7 +19,9 @@ public abstract partial class AceHeader
     {
         // Read header CRC (2 bytes) and header size (2 bytes)
         var headerBytes = new byte[4];
-        if (await stream.ReadAsync(headerBytes, 0, 4, cancellationToken) != 4)
+        if (
+            !await stream.ReadFullyAsync(headerBytes, 0, 4, cancellationToken).ConfigureAwait(false)
+        )
         {
             return Array.Empty<byte>();
         }
@@ -33,7 +35,11 @@ public abstract partial class AceHeader
 
         // Read the header data
         var body = new byte[HeaderSize];
-        if (await stream.ReadAsync(body, 0, HeaderSize, cancellationToken) != HeaderSize)
+        if (
+            !await stream
+                .ReadFullyAsync(body, 0, HeaderSize, cancellationToken)
+                .ConfigureAwait(false)
+        )
         {
             return Array.Empty<byte>();
         }
@@ -59,7 +65,7 @@ public abstract partial class AceHeader
     )
     {
         var bytes = new byte[14];
-        if (await stream.ReadAsync(bytes, 0, 14, cancellationToken) != 14)
+        if (!await stream.ReadFullyAsync(bytes, 0, 14, cancellationToken).ConfigureAwait(false))
         {
             return false;
         }

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

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

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

@@ -19,7 +19,7 @@ public sealed partial class AceMainHeader
         CancellationToken cancellationToken = default
     )
     {
-        var headerData = await ReadHeaderAsync(stream, cancellationToken);
+        var headerData = await ReadHeaderAsync(stream, cancellationToken).ConfigureAwait(false);
         if (headerData.Length == 0)
         {
             return null;

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

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

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

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

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

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

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

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

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

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

src/SharpCompress/Common/Arc/ArcEntry.cs

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

src/SharpCompress/Common/Arc/ArcEntryHeader.cs

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

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

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

src/SharpCompress/Common/Arc/ArcFilePart.cs

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

src/SharpCompress/Common/Arc/ArcVolume.cs

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

src/SharpCompress/Common/ArchiveType.cs

@@ -10,4 +10,5 @@ public enum ArchiveType
     Arc,
     Arj,
     Ace,
+    Lzw,
 }

src/SharpCompress/Common/Arj/ArjEntry.cs

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

src/SharpCompress/Common/Arj/ArjFilePart.cs

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

src/SharpCompress/Common/Arj/ArjVolume.cs

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

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

@@ -21,7 +21,7 @@ public abstract partial class ArjHeader
     {
         // check for magic bytes
         var magic = new byte[2];
-        if (await stream.ReadAsync(magic, 0, 2, cancellationToken) != 2)
+        if (await stream.ReadAsync(magic, 0, 2, cancellationToken).ConfigureAwait(false) != 2)
         {
             return Array.Empty<byte>();
         }
@@ -33,7 +33,7 @@ public abstract partial class ArjHeader
 
         // read header_size
         byte[] headerBytes = new byte[2];
-        await stream.ReadAsync(headerBytes, 0, 2, cancellationToken);
+        await stream.ReadAsync(headerBytes, 0, 2, cancellationToken).ConfigureAwait(false);
         var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
         if (headerSize < 1)
         {
@@ -41,14 +41,16 @@ public abstract partial class ArjHeader
         }
 
         var body = new byte[headerSize];
-        var read = await stream.ReadAsync(body, 0, headerSize, cancellationToken);
+        var read = await stream
+            .ReadAsync(body, 0, headerSize, cancellationToken)
+            .ConfigureAwait(false);
         if (read < headerSize)
         {
             return Array.Empty<byte>();
         }
 
         byte[] crc = new byte[4];
-        read = await stream.ReadAsync(crc, 0, 4, cancellationToken);
+        await stream.ReadFullyAsync(crc, 0, 4, cancellationToken).ConfigureAwait(false);
         var checksum = Crc32Stream.Compute(body);
         // Compute the hash value
         if (checksum != BitConverter.ToUInt32(crc, 0))
@@ -68,7 +70,9 @@ public abstract partial class ArjHeader
 
         while (true)
         {
-            int bytesRead = await reader.ReadAsync(buffer, 0, 2, cancellationToken);
+            int bytesRead = await reader
+                .ReadAsync(buffer, 0, 2, cancellationToken)
+                .ConfigureAwait(false);
             if (bytesRead < 2)
             {
                 throw new EndOfStreamException(
@@ -83,7 +87,9 @@ public abstract partial class ArjHeader
             }
 
             byte[] header = new byte[extHeaderSize];
-            bytesRead = await reader.ReadAsync(header, 0, extHeaderSize, cancellationToken);
+            bytesRead = await reader
+                .ReadAsync(header, 0, extHeaderSize, cancellationToken)
+                .ConfigureAwait(false);
             if (bytesRead < extHeaderSize)
             {
                 throw new EndOfStreamException(
@@ -92,7 +98,9 @@ public abstract partial class ArjHeader
             }
 
             byte[] crcextended = new byte[4];
-            bytesRead = await reader.ReadAsync(crcextended, 0, 4, cancellationToken);
+            bytesRead = await reader
+                .ReadAsync(crcextended, 0, 4, cancellationToken)
+                .ConfigureAwait(false);
             if (bytesRead < 4)
             {
                 throw new EndOfStreamException(
@@ -122,7 +130,7 @@ public abstract partial class ArjHeader
     )
     {
         var bytes = new byte[2];
-        if (await stream.ReadAsync(bytes, 0, 2, cancellationToken) != 2)
+        if (await stream.ReadAsync(bytes, 0, 2, cancellationToken).ConfigureAwait(false) != 2)
         {
             return false;
         }

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

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

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

@@ -11,10 +11,10 @@ public partial class ArjLocalHeader
         CancellationToken cancellationToken = default
     )
     {
-        var body = await ReadHeaderAsync(stream, cancellationToken);
+        var body = await ReadHeaderAsync(stream, cancellationToken).ConfigureAwait(false);
         if (body.Length > 0)
         {
-            await ReadExtendedHeadersAsync(stream, cancellationToken);
+            await ReadExtendedHeadersAsync(stream, cancellationToken).ConfigureAwait(false);
             var header = LoadFrom(body);
             header.DataStartPosition = stream.Position;
             return header;

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

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

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

@@ -11,8 +11,8 @@ public partial class ArjMainHeader
         CancellationToken cancellationToken = default
     )
     {
-        var body = await ReadHeaderAsync(stream, cancellationToken);
-        await ReadExtendedHeadersAsync(stream, cancellationToken);
+        var body = await ReadHeaderAsync(stream, cancellationToken).ConfigureAwait(false);
+        await ReadExtendedHeadersAsync(stream, cancellationToken).ConfigureAwait(false);
         return LoadFrom(body);
     }
 }

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

@@ -6,137 +6,136 @@ using System.Threading.Tasks;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Crypto;
 
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public partial class ArjMainHeader : ArjHeader
 {
-    public partial class ArjMainHeader : ArjHeader
+    private const int FIRST_HDR_SIZE = 34;
+    private const ushort ARJ_MAGIC = 0xEA60;
+
+    public ArchiveEncoding ArchiveEncoding { get; }
+
+    public int ArchiverVersionNumber { get; private set; }
+    public int MinVersionToExtract { get; private set; }
+    public HostOS HostOs { get; private set; }
+    public int SecurityVersion { get; private set; }
+    public DosDateTime CreationDateTime { get; private set; } = new DosDateTime(0);
+    public long CompressedSize { get; private set; }
+    public long ArchiveSize { get; private set; }
+    public long SecurityEnvelope { get; private set; }
+    public int FileSpecPosition { get; private set; }
+    public int SecurityEnvelopeLength { get; private set; }
+    public int EncryptionVersion { get; private set; }
+    public int LastChapter { get; private set; }
+
+    public int ArjProtectionFactor { get; private set; }
+    public int Flags2 { get; private set; }
+    public string Name { get; private set; } = string.Empty;
+    public string Comment { get; private set; } = string.Empty;
+
+    public ArjMainHeader(ArchiveEncoding archiveEncoding)
+        : base(ArjHeaderType.MainHeader)
     {
-        private const int FIRST_HDR_SIZE = 34;
-        private const ushort ARJ_MAGIC = 0xEA60;
+        ArchiveEncoding =
+            archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
+    }
 
-        public ArchiveEncoding ArchiveEncoding { get; }
+    public override ArjHeader? Read(Stream stream)
+    {
+        var body = ReadHeader(stream);
+        ReadExtendedHeaders(stream);
+        return LoadFrom(body);
+    }
 
-        public int ArchiverVersionNumber { get; private set; }
-        public int MinVersionToExtract { get; private set; }
-        public HostOS HostOs { get; private set; }
-        public int SecurityVersion { get; private set; }
-        public DosDateTime CreationDateTime { get; private set; } = new DosDateTime(0);
-        public long CompressedSize { get; private set; }
-        public long ArchiveSize { get; private set; }
-        public long SecurityEnvelope { get; private set; }
-        public int FileSpecPosition { get; private set; }
-        public int SecurityEnvelopeLength { get; private set; }
-        public int EncryptionVersion { get; private set; }
-        public int LastChapter { get; private set; }
+    // ReadAsync moved to ArjMainHeader.Async.cs
 
-        public int ArjProtectionFactor { get; private set; }
-        public int Flags2 { get; private set; }
-        public string Name { get; private set; } = string.Empty;
-        public string Comment { get; private set; } = string.Empty;
+    public ArjMainHeader LoadFrom(byte[] headerBytes)
+    {
+        var offset = 1;
 
-        public ArjMainHeader(ArchiveEncoding archiveEncoding)
-            : base(ArjHeaderType.MainHeader)
+        byte ReadByte()
         {
-            ArchiveEncoding =
-                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
+            if (offset >= headerBytes.Length)
+            {
+                throw new EndOfStreamException();
+            }
+            return (byte)(headerBytes[offset++] & 0xFF);
         }
 
-        public override ArjHeader? Read(Stream stream)
+        int ReadInt16()
         {
-            var body = ReadHeader(stream);
-            ReadExtendedHeaders(stream);
-            return LoadFrom(body);
+            if (offset + 1 >= headerBytes.Length)
+            {
+                throw new EndOfStreamException();
+            }
+            var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
+            offset += 2;
+            return v;
         }
 
-        // ReadAsync moved to ArjMainHeader.Async.cs
-
-        public ArjMainHeader LoadFrom(byte[] headerBytes)
+        long ReadInt32()
         {
-            var offset = 1;
-
-            byte ReadByte()
+            if (offset + 3 >= headerBytes.Length)
             {
-                if (offset >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                return (byte)(headerBytes[offset++] & 0xFF);
+                throw new EndOfStreamException();
             }
+            long v =
+                headerBytes[offset] & 0xFF
+                | (headerBytes[offset + 1] & 0xFF) << 8
+                | (headerBytes[offset + 2] & 0xFF) << 16
+                | (headerBytes[offset + 3] & 0xFF) << 24;
+            offset += 4;
+            return v;
+        }
+        string ReadNullTerminatedString(byte[] x, int startIndex)
+        {
+            var result = new StringBuilder();
+            int i = startIndex;
 
-            int ReadInt16()
+            while (i < x.Length && x[i] != 0)
             {
-                if (offset + 1 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
-                offset += 2;
-                return v;
-            }
-
-            long ReadInt32()
-            {
-                if (offset + 3 >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                long v =
-                    headerBytes[offset] & 0xFF
-                    | (headerBytes[offset + 1] & 0xFF) << 8
-                    | (headerBytes[offset + 2] & 0xFF) << 16
-                    | (headerBytes[offset + 3] & 0xFF) << 24;
-                offset += 4;
-                return v;
-            }
-            string ReadNullTerminatedString(byte[] x, int startIndex)
-            {
-                var result = new StringBuilder();
-                int i = startIndex;
-
-                while (i < x.Length && x[i] != 0)
-                {
-                    result.Append((char)x[i]);
-                    i++;
-                }
-
-                // Skip the null terminator
+                result.Append((char)x[i]);
                 i++;
-                if (i < x.Length)
-                {
-                    byte[] remainder = new byte[x.Length - i];
-                    Array.Copy(x, i, remainder, 0, remainder.Length);
-                    x = remainder;
-                }
-
-                return result.ToString();
             }
 
-            ArchiverVersionNumber = ReadByte();
-            MinVersionToExtract = ReadByte();
+            // Skip the null terminator
+            i++;
+            if (i < x.Length)
+            {
+                byte[] remainder = new byte[x.Length - i];
+                Array.Copy(x, i, remainder, 0, remainder.Length);
+                x = remainder;
+            }
 
-            var hostOsByte = ReadByte();
-            HostOs = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
-
-            Flags = ReadByte();
-            SecurityVersion = ReadByte();
-            FileType = FileTypeFromByte(ReadByte());
-
-            offset++; // skip reserved
-
-            CreationDateTime = new DosDateTime((int)ReadInt32());
-            CompressedSize = ReadInt32();
-            ArchiveSize = ReadInt32();
-
-            SecurityEnvelope = ReadInt32();
-            FileSpecPosition = ReadInt16();
-            SecurityEnvelopeLength = ReadInt16();
-
-            EncryptionVersion = ReadByte();
-            LastChapter = ReadByte();
-
-            Name = ReadNullTerminatedString(headerBytes, offset);
-            Comment = ReadNullTerminatedString(headerBytes, offset + 1 + Name.Length);
-
-            return this;
+            return result.ToString();
         }
+
+        ArchiverVersionNumber = ReadByte();
+        MinVersionToExtract = ReadByte();
+
+        var hostOsByte = ReadByte();
+        HostOs = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
+
+        Flags = ReadByte();
+        SecurityVersion = ReadByte();
+        FileType = FileTypeFromByte(ReadByte());
+
+        offset++; // skip reserved
+
+        CreationDateTime = new DosDateTime((int)ReadInt32());
+        CompressedSize = ReadInt32();
+        ArchiveSize = ReadInt32();
+
+        SecurityEnvelope = ReadInt32();
+        FileSpecPosition = ReadInt16();
+        SecurityEnvelopeLength = ReadInt16();
+
+        EncryptionVersion = ReadByte();
+        LastChapter = ReadByte();
+
+        Name = ReadNullTerminatedString(headerBytes, offset);
+        Comment = ReadNullTerminatedString(headerBytes, offset + 1 + Name.Length);
+
+        return this;
     }
 }

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

@@ -4,17 +4,16 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public enum CompressionMethod
 {
-    public enum CompressionMethod
-    {
-        Stored = 0,
-        CompressedMost = 1,
-        Compressed = 2,
-        CompressedFaster = 3,
-        CompressedFastest = 4,
-        NoDataNoCrc = 8,
-        NoData = 9,
-        Unknown,
-    }
+    Stored = 0,
+    CompressedMost = 1,
+    Compressed = 2,
+    CompressedFaster = 3,
+    CompressedFastest = 4,
+    NoDataNoCrc = 8,
+    NoData = 9,
+    Unknown,
 }

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

@@ -1,37 +1,36 @@
 using System;
 
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public class DosDateTime
 {
-    public class DosDateTime
+    public DateTime DateTime { get; }
+
+    public DosDateTime(long dosValue)
     {
-        public DateTime DateTime { get; }
+        // Ensure only the lower 32 bits are used
+        int value = unchecked((int)(dosValue & 0xFFFFFFFF));
 
-        public DosDateTime(long dosValue)
+        var date = (value >> 16) & 0xFFFF;
+        var time = value & 0xFFFF;
+
+        var day = date & 0x1F;
+        var month = (date >> 5) & 0x0F;
+        var year = ((date >> 9) & 0x7F) + 1980;
+
+        var second = (time & 0x1F) * 2;
+        var minute = (time >> 5) & 0x3F;
+        var hour = (time >> 11) & 0x1F;
+
+        try
         {
-            // Ensure only the lower 32 bits are used
-            int value = unchecked((int)(dosValue & 0xFFFFFFFF));
-
-            var date = (value >> 16) & 0xFFFF;
-            var time = value & 0xFFFF;
-
-            var day = date & 0x1F;
-            var month = (date >> 5) & 0x0F;
-            var year = ((date >> 9) & 0x7F) + 1980;
-
-            var second = (time & 0x1F) * 2;
-            var minute = (time >> 5) & 0x3F;
-            var hour = (time >> 11) & 0x1F;
-
-            try
-            {
-                DateTime = new DateTime(year, month, day, hour, minute, second);
-            }
-            catch
-            {
-                DateTime = DateTime.MinValue;
-            }
+            DateTime = new DateTime(year, month, day, hour, minute, second);
+        }
+        catch
+        {
+            DateTime = DateTime.MinValue;
         }
-
-        public override string ToString() => DateTime.ToString("yyyy-MM-dd HH:mm:ss");
     }
+
+    public override string ToString() => DateTime.ToString("yyyy-MM-dd HH:mm:ss");
 }

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

@@ -1,13 +1,12 @@
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public enum FileType : byte
 {
-    public enum FileType : byte
-    {
-        Binary = 0,
-        Text7Bit = 1,
-        CommentHeader = 2,
-        Directory = 3,
-        VolumeLabel = 4,
-        ChapterLabel = 5,
-        Unknown = 255,
-    }
+    Binary = 0,
+    Text7Bit = 1,
+    CommentHeader = 2,
+    Directory = 3,
+    VolumeLabel = 4,
+    ChapterLabel = 5,
+    Unknown = 255,
 }

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

@@ -1,19 +1,18 @@
-namespace SharpCompress.Common.Arj.Headers
+namespace SharpCompress.Common.Arj.Headers;
+
+public enum HostOS
 {
-    public enum HostOS
-    {
-        MsDos = 0,
-        PrimOS = 1,
-        Unix = 2,
-        Amiga = 3,
-        MacOs = 4,
-        OS2 = 5,
-        AppleGS = 6,
-        AtariST = 7,
-        NeXT = 8,
-        VaxVMS = 9,
-        Win95 = 10,
-        Win32 = 11,
-        Unknown = 255,
-    }
+    MsDos = 0,
+    PrimOS = 1,
+    Unix = 2,
+    Amiga = 3,
+    MacOs = 4,
+    OS2 = 5,
+    AppleGS = 6,
+    AtariST = 7,
+    NeXT = 8,
+    VaxVMS = 9,
+    Win95 = 10,
+    Win32 = 11,
+    Unknown = 255,
 }

src/SharpCompress/Common/AsyncBinaryReader.cs

@@ -1,108 +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)
-        {
-            if (!stream.CanRead)
-            {
-                throw new ArgumentException("Stream must be readable.");
-            }
-
-            _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 NET8_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,41 @@
+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;
+
+    /// <summary>
+    /// The default size for rewindable buffers in SharpCompressStream.
+    /// Used for format detection on non-seekable streams.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// When opening archives from non-seekable streams (network streams, pipes,
+    /// compressed streams), SharpCompress uses a ring buffer to enable format
+    /// auto-detection. This buffer allows the library to try multiple decoders
+    /// by rewinding and re-reading the same data.
+    /// </para>
+    /// <para>
+    /// <b>Default:</b> 81920 bytes (81KB) - sufficient for typical format detection.
+    /// </para>
+    /// <para>
+    /// <b>Typical usage:</b> 500-1000 bytes for most archives
+    /// </para>
+    /// <para>
+    /// <b>Can be overridden per-stream via ReaderOptions.RewindableBufferSize.</b>
+    /// </para>
+    /// <para>
+    /// <b>Increase if:</b>
+    /// <list type="bullet">
+    /// <item>Handling self-extracting archives (may need 512KB+)</item>
+    /// <item>Format detection fails with buffer overflow errors</item>
+    /// <item>Using custom formats with large headers</item>
+    /// </list>
+    /// </para>
+    /// </remarks>
+    public static int RewindableBufferSize { get; set; } = 81920;
+}

src/SharpCompress/Common/Entry.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using SharpCompress.Common.Options;
 
 namespace SharpCompress.Common;
 
@@ -87,4 +88,14 @@ public abstract class Entry : IEntry
     /// Entry file attribute.
     /// </summary>
     public virtual int? Attrib => throw new NotImplementedException();
+
+    /// <summary>
+    /// The options used when opening this entry's source (reader or archive).
+    /// </summary>
+    public IReaderOptions Options { get; protected set; }
+
+    protected Entry(IReaderOptions readerOptions)
+    {
+        Options = readerOptions;
+    }
 }

src/SharpCompress/Common/EntryStream.Async.cs

@@ -42,9 +42,6 @@ public partial class EntryStream
                 await lzmaStream.FlushAsync().ConfigureAwait(false);
             }
         }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(EntryStream));
-#endif
         await base.DisposeAsync().ConfigureAwait(false);
         await _stream.DisposeAsync().ConfigureAwait(false);
     }

src/SharpCompress/Common/EntryStream.cs

@@ -8,28 +8,8 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
-public partial class EntryStream : Stream, IStreamStack
+public partial class EntryStream : Stream
 {
-#if DEBUG_STREAMS
-    long IStreamStack.InstanceId { get; set; }
-#endif
-    int IStreamStack.DefaultBufferSize { get; set; }
-
-    Stream IStreamStack.BaseStream() => _stream;
-
-    int IStreamStack.BufferSize
-    {
-        get => 0;
-        set { }
-    }
-    int IStreamStack.BufferPosition
-    {
-        get => 0;
-        set { }
-    }
-
-    void IStreamStack.SetPosition(long position) { }
-
     private readonly IReader _reader;
     private readonly Stream _stream;
     private bool _completed;
@@ -39,9 +19,6 @@ public partial class EntryStream : Stream, IStreamStack
     {
         _reader = reader;
         _stream = stream;
-#if DEBUG_STREAMS
-        this.DebugConstruct(typeof(EntryStream));
-#endif
     }
 
     /// <summary>
@@ -62,24 +39,34 @@ public partial class EntryStream : Stream, IStreamStack
         _isDisposed = true;
         if (!(_completed || _reader.Cancelled))
         {
-            SkipEntry();
+            if (Utility.UseSyncOverAsyncDispose())
+            {
+                SkipEntryAsync().GetAwaiter().GetResult();
+            }
+            else
+            {
+                SkipEntry();
+            }
         }
 
         //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
         if (_stream is IStreamStack ss)
         {
-            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
+            if (
+                ss.GetStream<SharpCompress.Compressors.Deflate.DeflateStream>()
+                is SharpCompress.Compressors.Deflate.DeflateStream deflateStream
+            )
             {
                 deflateStream.Flush(); //Deflate over reads. Knock it back
             }
-            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
+            else if (
+                ss.GetStream<SharpCompress.Compressors.LZMA.LzmaStream>()
+                is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream
+            )
             {
                 lzmaStream.Flush(); //Lzma over reads. Knock it back
             }
         }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(EntryStream));
-#endif
         base.Dispose(disposing);
         _stream.Dispose();
     }

src/SharpCompress/Common/ExtractionMethods.Async.cs

@@ -2,6 +2,7 @@ using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
+using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
@@ -10,8 +11,7 @@ internal static partial class ExtractionMethods
     public static async ValueTask WriteEntryToDirectoryAsync(
         IEntry entry,
         string destinationDirectory,
-        ExtractionOptions? options,
-        Func<string, ExtractionOptions?, CancellationToken, ValueTask> writeAsync,
+        Func<string, CancellationToken, ValueTask> writeAsync,
         CancellationToken cancellationToken = default
     )
     {
@@ -34,11 +34,9 @@ internal static partial class ExtractionMethods
             );
         }
 
-        options ??= new ExtractionOptions() { Overwrite = true };
-
         var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
         file = Utility.ReplaceInvalidFileNameChars(file);
-        if (options.ExtractFullPath)
+        if (entry.Options.ExtractFullPath)
         {
             var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
                 .NotNull("Directory is null");
@@ -72,9 +70,9 @@ internal static partial class ExtractionMethods
                     "Entry is trying to write a file outside of the destination directory."
                 );
             }
-            await writeAsync(destinationFileName, options, cancellationToken).ConfigureAwait(false);
+            await writeAsync(destinationFileName, cancellationToken).ConfigureAwait(false);
         }
-        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
+        else if (entry.Options.ExtractFullPath && !Directory.Exists(destinationFileName))
         {
             Directory.CreateDirectory(destinationFileName);
         }
@@ -83,34 +81,34 @@ internal static partial class ExtractionMethods
     public static async ValueTask WriteEntryToFileAsync(
         IEntry entry,
         string destinationFileName,
-        ExtractionOptions? options,
         Func<string, FileMode, CancellationToken, ValueTask> openAndWriteAsync,
         CancellationToken cancellationToken = default
     )
     {
         if (entry.LinkTarget != null)
         {
-            if (options?.WriteSymbolicLink is null)
+            if (entry.Options.SymbolicLinkHandler is not null)
             {
-                throw new ExtractionException(
-                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
-                );
+                entry.Options.SymbolicLinkHandler(destinationFileName, entry.LinkTarget);
             }
-            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
+            else
+            {
+                ReaderOptions.DefaultSymbolicLinkHandler(destinationFileName, entry.LinkTarget);
+            }
+            return;
         }
         else
         {
             var fm = FileMode.Create;
-            options ??= new ExtractionOptions() { Overwrite = true };
 
-            if (!options.Overwrite)
+            if (!entry.Options.Overwrite)
             {
                 fm = FileMode.CreateNew;
             }
 
             await openAndWriteAsync(destinationFileName, fm, cancellationToken)
                 .ConfigureAwait(false);
-            entry.PreserveExtractionOptions(destinationFileName, options);
+            entry.PreserveExtractionOptions(destinationFileName);
         }
     }
 }

src/SharpCompress/Common/ExtractionMethods.cs

@@ -3,6 +3,7 @@ using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
+using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
@@ -23,8 +24,7 @@ internal static partial class ExtractionMethods
     public static void WriteEntryToDirectory(
         IEntry entry,
         string destinationDirectory,
-        ExtractionOptions? options,
-        Action<string, ExtractionOptions?> write
+        Action<string> write
     )
     {
         string destinationFileName;
@@ -46,11 +46,9 @@ internal static partial class ExtractionMethods
             );
         }
 
-        options ??= new ExtractionOptions() { Overwrite = true };
-
         var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
         file = Utility.ReplaceInvalidFileNameChars(file);
-        if (options.ExtractFullPath)
+        if (entry.Options.ExtractFullPath)
         {
             var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
                 .NotNull("Directory is null");
@@ -84,9 +82,9 @@ internal static partial class ExtractionMethods
                     "Entry is trying to write a file outside of the destination directory."
                 );
             }
-            write(destinationFileName, options);
+            write(destinationFileName);
         }
-        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
+        else if (entry.Options.ExtractFullPath && !Directory.Exists(destinationFileName))
         {
             Directory.CreateDirectory(destinationFileName);
         }
@@ -95,32 +93,32 @@ internal static partial class ExtractionMethods
     public static void WriteEntryToFile(
         IEntry entry,
         string destinationFileName,
-        ExtractionOptions? options,
         Action<string, FileMode> openAndWrite
     )
     {
         if (entry.LinkTarget != null)
         {
-            if (options?.WriteSymbolicLink is null)
+            if (entry.Options.SymbolicLinkHandler is not null)
             {
-                throw new ExtractionException(
-                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
-                );
+                entry.Options.SymbolicLinkHandler(destinationFileName, entry.LinkTarget);
             }
-            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
+            else
+            {
+                ReaderOptions.DefaultSymbolicLinkHandler(destinationFileName, entry.LinkTarget);
+            }
+            return;
         }
         else
         {
             var fm = FileMode.Create;
-            options ??= new ExtractionOptions() { Overwrite = true };
 
-            if (!options.Overwrite)
+            if (!entry.Options.Overwrite)
             {
                 fm = FileMode.CreateNew;
             }
 
             openAndWrite(destinationFileName, fm);
-            entry.PreserveExtractionOptions(destinationFileName, options);
+            entry.PreserveExtractionOptions(destinationFileName);
         }
     }
 }

src/SharpCompress/Common/ExtractionOptions.cs

@@ -1,40 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ExtractionOptions
-{
-    /// <summary>
-    /// overwrite target if it exists
-    /// </summary>
-    public bool Overwrite { get; set; }
-
-    /// <summary>
-    /// extract with internal directory structure
-    /// </summary>
-    public bool ExtractFullPath { get; set; }
-
-    /// <summary>
-    /// preserve file time
-    /// </summary>
-    public bool PreserveFileTime { get; set; }
-
-    /// <summary>
-    /// preserve windows file attributes
-    /// </summary>
-    public bool PreserveAttributes { get; set; }
-
-    /// <summary>
-    /// Delegate for writing symbolic links to disk.
-    /// sourcePath is where the symlink is created.
-    /// targetPath is what the symlink refers to.
-    /// </summary>
-    public delegate void SymbolicLinkWriterDelegate(string sourcePath, string targetPath);
-
-    public SymbolicLinkWriterDelegate WriteSymbolicLink = (sourcePath, targetPath) =>
-    {
-        Console.WriteLine(
-            $"Could not write symlink {sourcePath} -> {targetPath}, for more information please see https://github.com/dotnet/runtime/issues/24271"
-        );
-    };
-}