more reverts

split files
revert naming changes
2026-02-04 13:34:59 +00:00 · 2024-03-29 16:05:20 +00:00 · 2024-03-29 16:00:05 +00:00 · 2024-03-29 15:53:11 +00:00 · 2024-03-29 15:27:43 +00:00 · 2024-03-12 15:40:29 +00:00
430 changed files with 7367 additions and 42994 deletions
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -3,11 +3,10 @@
  "isRoot": true,
  "tools": {
    "csharpier": {
-      "version": "1.2.1",
+      "version": "0.27.3",
      "commands": [
-        "csharpier"
-      ],
-      "rollForward": false
+        "dotnet-csharpier"
+      ]
    }
  }
 }
--- a/.copilot-agent.yml
+++ b/.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
--- a/.editorconfig
+++ b/.editorconfig
@@ -70,7 +70,7 @@ indent_style = tab

 [*.{cs,csx,cake,vb,vbx}]
 # Default Severity for all .NET Code Style rules below
-dotnet_analyzer_diagnostic.severity = silent
+dotnet_analyzer_diagnostic.severity = warning

 ##########################################
 # File Header (Uncomment to support file headers)
@@ -269,8 +269,6 @@ dotnet_diagnostic.CA1305.severity = suggestion
 dotnet_diagnostic.CA1307.severity = suggestion
 dotnet_diagnostic.CA1309.severity = suggestion
 dotnet_diagnostic.CA1310.severity = error
-dotnet_diagnostic.CA1507.severity = suggestion
-dotnet_diagnostic.CA1513.severity = suggestion
 dotnet_diagnostic.CA1707.severity = suggestion
 dotnet_diagnostic.CA1708.severity = suggestion
 dotnet_diagnostic.CA1711.severity = suggestion
@@ -288,7 +286,6 @@ dotnet_diagnostic.CA1834.severity = error
 dotnet_diagnostic.CA1845.severity = suggestion
 dotnet_diagnostic.CA1848.severity = suggestion
 dotnet_diagnostic.CA1852.severity = suggestion
-dotnet_diagnostic.CA1860.severity = silent
 dotnet_diagnostic.CA2016.severity = suggestion
 dotnet_diagnostic.CA2201.severity = error
 dotnet_diagnostic.CA2206.severity = error
@@ -306,12 +303,13 @@ dotnet_diagnostic.CS1998.severity = error
 dotnet_diagnostic.CS8602.severity = error
 dotnet_diagnostic.CS8604.severity = error
 dotnet_diagnostic.CS8618.severity = error
-dotnet_diagnostic.CS0618.severity = suggestion
+dotnet_diagnostic.CS0618.severity = error
 dotnet_diagnostic.CS1998.severity = error
 dotnet_diagnostic.CS4014.severity = error
 dotnet_diagnostic.CS8600.severity = error
 dotnet_diagnostic.CS8603.severity = error
 dotnet_diagnostic.CS8625.severity = error
+dotnet_diagnostic.CS8981.severity = suggestion

 dotnet_diagnostic.BL0005.severity = suggestion

@@ -320,7 +318,7 @@ dotnet_diagnostic.MVC1000.severity = suggestion
 dotnet_diagnostic.RZ10012.severity = error

 dotnet_diagnostic.IDE0004.severity = error # redundant cast
-dotnet_diagnostic.IDE0005.severity = suggestion
+dotnet_diagnostic.IDE0005.severity = error
 dotnet_diagnostic.IDE0007.severity = error # Use var
 dotnet_diagnostic.IDE0011.severity = error # Use braces on if statements
 dotnet_diagnostic.IDE0010.severity = silent # populate switch
@@ -331,7 +329,7 @@ dotnet_diagnostic.IDE0023.severity = suggestion # use expression body for operat
 dotnet_diagnostic.IDE0024.severity = silent # expression body for operators
 dotnet_diagnostic.IDE0025.severity = suggestion # use expression body for properties
 dotnet_diagnostic.IDE0027.severity = suggestion # Use expression body for accessors
-dotnet_diagnostic.IDE0028.severity = silent # expression body for accessors
+dotnet_diagnostic.IDE0028.severity = silent
 dotnet_diagnostic.IDE0032.severity = suggestion # Use auto property
 dotnet_diagnostic.IDE0033.severity = error # prefer tuple name
 dotnet_diagnostic.IDE0037.severity = suggestion # simplify anonymous type
@@ -339,7 +337,7 @@ dotnet_diagnostic.IDE0040.severity = error # modifiers required
 dotnet_diagnostic.IDE0041.severity = error # simplify null
 dotnet_diagnostic.IDE0042.severity = error # deconstruct variable
 dotnet_diagnostic.IDE0044.severity = suggestion # make field only when possible
-dotnet_diagnostic.IDE0047.severity = suggestion # parameter name
+dotnet_diagnostic.IDE0047.severity = suggestion # paratemeter name
 dotnet_diagnostic.IDE0051.severity = error # unused field
 dotnet_diagnostic.IDE0052.severity = error # unused member
 dotnet_diagnostic.IDE0053.severity = suggestion # lambda not needed
@@ -353,20 +351,11 @@ dotnet_diagnostic.IDE0066.severity = suggestion # switch expression
 dotnet_diagnostic.IDE0072.severity = suggestion # Populate switch - forces population of all cases even when default specified
 dotnet_diagnostic.IDE0078.severity = suggestion # use pattern matching
 dotnet_diagnostic.IDE0090.severity = suggestion # new can be simplified
-dotnet_diagnostic.IDE0130.severity = suggestion # namespace folder structure
+dotnet_diagnostic.IDE0130.severity = error # namespace folder structure
 dotnet_diagnostic.IDE0160.severity = silent # Use block namespaces ARE NOT required
 dotnet_diagnostic.IDE0161.severity = error # Please use file namespaces
 dotnet_diagnostic.IDE0200.severity = suggestion # lambda not needed
 dotnet_diagnostic.IDE1006.severity = suggestion # Naming rule violation: These words cannot contain lower case characters
-dotnet_diagnostic.IDE0260.severity = suggestion # Use pattern matching
-dotnet_diagnostic.IDE0270.severity = suggestion # Null check simplifcation
-dotnet_diagnostic.IDE0290.severity = error # Primary Constructor
-dotnet_diagnostic.IDE0300.severity = suggestion # Collection
-dotnet_diagnostic.IDE0305.severity = suggestion # Collection ToList
-
-dotnet_diagnostic.NX0001.severity = error
-dotnet_diagnostic.NX0002.severity = silent
-dotnet_diagnostic.NX0003.severity = silent

 ##########################################
 # Styles
--- a/.github/COPILOT_AGENT_README.md
+++ b/.github/COPILOT_AGENT_README.md
@@ -1,15 +0,0 @@
-# Copilot Coding Agent Configuration
-
-This repository includes a minimal opt-in configuration and CI workflow to allow the GitHub Copilot coding agent to open and validate PRs.
-
- .copilot-agent.yml: opt-in config for automated agents
- .github/agents/copilot-agent.yml: detailed agent policy configuration
- .github/workflows/dotnetcore.yml: CI runs on PRs touching the solution, source, or tests to validate changes
- AGENTS.md: general instructions for Copilot coding agent with project-specific guidelines
-
-Maintainers can adjust the allowed paths or disable the agent by editing or removing .copilot-agent.yml.
-
-Notes:
- The agent can create, modify, and delete files within the allowed paths (src, tests, README.md, AGENTS.md)
- All changes require review before merge
- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Test test project.
--- a/.github/agents/copilot-agent.yml
+++ b/.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.
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,13 +1,6 @@
 version: 2
 updates:
-  - package-ecosystem: "github-actions"
-    directory: "/" 
+  - package-ecosystem: "github-actions" # search for actions - there are other options available
+    directory: "/" # search in .github/workflows under root `/`
    schedule:
-      interval: "weekly"
-
-  - package-ecosystem: "nuget"
-    directory: "/"    # change to "/src/YourProject" if .csproj files are in subfolders
-    schedule:
-      interval: "weekly"
-    open-pull-requests-limit: 5
-    # optional: target-branch: "master"
+      interval: "weekly" # check for action update every week
--- a/.github/workflows/dotnetcore.yml
+++ b/.github/workflows/dotnetcore.yml
@@ -3,7 +3,6 @@ on:
  push:
    branches:
      - 'master'
-      - 'release'
  pull_request:
    types: [ opened, synchronize, reopened, ready_for_review ]

@@ -15,12 +14,12 @@ jobs:
        os: [windows-latest, ubuntu-latest]

    steps:
-    - uses: actions/checkout@v6
-    - uses: actions/setup-dotnet@v5
+    - uses: actions/checkout@v4
+    - uses: actions/setup-dotnet@v4
      with:
        dotnet-version: 8.0.x
    - run: dotnet run --project build/build.csproj
-    - uses: actions/upload-artifact@v5
+    - uses: actions/upload-artifact@v4
      with:
        name: ${{ matrix.os }}-sharpcompress.nupkg
        path: artifacts/*
--- a/.gitignore
+++ b/.gitignore
@@ -11,8 +11,6 @@ TestResults/
 packages/*/
 project.lock.json
 tests/TestArchives/Scratch
-tests/TestArchives/*/Scratch
-tests/TestArchives/*/Scratch2
 .vs
 tools
 .vscode
@@ -20,3 +18,4 @@ tools

 .DS_Store
 *.snupkg
+/tests/TestArchives/6d23a38c-f064-4ef1-ad89-b942396f53b9/Scratch
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,118 +0,0 @@
---
-description: 'Guidelines for building SharpCompress - A C# compression library'
-applyTo: '**/*.cs'
---
-
-# SharpCompress Development
-
-## About SharpCompress
-SharpCompress is a pure C# compression library supporting multiple archive formats (Zip, Tar, GZip, BZip2, 7Zip, Rar, LZip, XZ, ZStandard) for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0, and .NET 8.0. The library provides both seekable Archive APIs and forward-only Reader/Writer APIs for streaming scenarios.
-
-## C# Instructions
- Always use the latest version C#, currently C# 13 features.
- Write clear and concise comments for each function.
- Follow the existing code style and patterns in the codebase.
-
-## General Instructions
- Make only high confidence suggestions when reviewing code changes.
- Write code with good maintainability practices, including comments on why certain design decisions were made.
- Handle edge cases and write clear exception handling.
- For libraries or external dependencies, mention their usage and purpose in comments.
- Preserve backward compatibility when making changes to public APIs.
-
-## Naming Conventions
-
- Follow PascalCase for component names, method names, and public members.
- Use camelCase for private fields and local variables.
- Prefix interface names with "I" (e.g., IUserService).
-
-## Code Formatting
-
- Use CSharpier for code formatting to ensure consistent style across the project
- CSharpier is configured as a local tool in `.config/dotnet-tools.json`
- Restore tools with: `dotnet tool restore`
- Format files from the project root with: `dotnet csharpier .`
- **Run `dotnet csharpier .` from the project root after making code changes before committing**
- Configure your IDE to format on save using CSharpier for the best experience
- The project also uses `.editorconfig` for editor settings (indentation, encoding, etc.)
- Let CSharpier handle code style while `.editorconfig` handles editor behavior
-
-## Project Setup and Structure
-
- The project targets multiple frameworks: .NET Framework 4.62, .NET Standard 2.1, .NET 6.0, and .NET 8.0
- Main library is in `src/SharpCompress/`
- Tests are in `tests/SharpCompress.Test/`
- Performance tests are in `tests/SharpCompress.Performance/`
- Test archives are in `tests/TestArchives/`
- Build project is in `build/`
- Use `dotnet build` to build the solution
- Use `dotnet test` to run tests
- Solution file: `SharpCompress.sln`
-
-## Nullable Reference Types
-
- Declare variables non-nullable, and check for `null` at entry points.
- Always use `is null` or `is not null` instead of `== null` or `!= null`.
- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
-
-## SharpCompress-Specific Guidelines
-
-### Supported Formats
-SharpCompress supports multiple archive and compression formats:
- **Archive Formats**: Zip, Tar, 7Zip, Rar (read-only)
- **Compression**: DEFLATE, BZip2, LZMA/LZMA2, PPMd, ZStandard (decompress only), Deflate64 (decompress only)
- **Combined Formats**: Tar.GZip, Tar.BZip2, Tar.LZip, Tar.XZ, Tar.ZStandard
- See FORMATS.md for complete format support matrix
-
-### Stream Handling Rules
- **Disposal**: As of version 0.21, SharpCompress closes wrapped streams by default
- Use `ReaderOptions` or `WriterOptions` with `LeaveStreamOpen = true` to control stream disposal
- Use `NonDisposingStream` wrapper when working with compression streams directly to prevent disposal
- Always dispose of readers, writers, and archives in `using` blocks
- For forward-only operations, use Reader/Writer APIs; for random access, use Archive APIs
-
-### Async/Await Patterns
- All I/O operations support async/await with `CancellationToken`
- Async methods follow the naming convention: `MethodNameAsync`
- Key async methods:
-  - `WriteEntryToAsync` - Extract entry asynchronously
-  - `WriteAllToDirectoryAsync` - Extract all entries asynchronously
-  - `WriteAsync` - Write entry asynchronously
-  - `WriteAllAsync` - Write directory asynchronously
-  - `OpenEntryStreamAsync` - Open entry stream asynchronously
- Always provide `CancellationToken` parameter in async methods
-
-### Archive APIs vs Reader/Writer APIs
- **Archive API**: Use for random access with seekable streams (e.g., `ZipArchive`, `TarArchive`)
- **Reader API**: Use for forward-only reading on non-seekable streams (e.g., `ZipReader`, `TarReader`)
- **Writer API**: Use for forward-only writing on streams (e.g., `ZipWriter`, `TarWriter`)
- 7Zip only supports Archive API due to format limitations
-
-### Tar-Specific Considerations
- Tar format requires file size in the header
- If no size is specified to TarWriter and the stream is not seekable, an exception will be thrown
- Tar combined with compression (GZip, BZip2, LZip, XZ) is supported
-
-### Zip-Specific Considerations
- Supports Zip64 for large files (seekable streams only)
- Supports PKWare and WinZip AES encryption
- Multiple compression methods: None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA, PPMd
- Encrypted LZMA is not supported
-
-### Performance Considerations
- For large files, use Reader/Writer APIs with non-seekable streams to avoid loading entire file in memory
- Leverage async I/O for better scalability
- Consider compression level trade-offs (speed vs. size)
- Use appropriate buffer sizes for stream operations
-
-## Testing
-
- Always include test cases for critical paths of the application.
- Test with multiple archive formats when making changes to core functionality.
- Include tests for both Archive and Reader/Writer APIs when applicable.
- Test async operations with cancellation tokens.
- Do not emit "Act", "Arrange" or "Assert" comments.
- Copy existing style in nearby files for test method names and capitalization.
- Use test archives from `tests/TestArchives` directory for consistency.
- Test stream disposal and `LeaveStreamOpen` behavior.
- Test edge cases: empty archives, large files, corrupted archives, encrypted archives.
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -10,7 +10,5 @@
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
    <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
-    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
-    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
  </PropertyGroup>
 </Project>
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -1,21 +0,0 @@
-<Project>
-  <ItemGroup>
-    <PackageVersion Include="Bullseye" Version="6.0.0" />
-    <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
-    <PackageVersion Include="Glob" Version="1.1.9" />
-    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.14" />
-    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
-    <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
-    <PackageVersion Include="SimpleExec" Version="12.0.0" />
-    <PackageVersion Include="System.Buffers" Version="4.6.1" />
-    <PackageVersion Include="System.Memory" Version="4.6.3" />
-    <PackageVersion Include="System.Text.Encoding.CodePages" Version="8.0.0" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
-    <PackageVersion Include="ZstdSharp.Port" Version="0.8.6" />
-    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="8.0.21" />
-    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
-    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
-  </ItemGroup>
-</Project>
--- a/FORMATS.md
+++ b/FORMATS.md
@@ -11,11 +11,10 @@
 | Archive Format         | Compression Format(s)                             | Compress/Decompress | Archive API     | Reader API | Writer API    |
 | ---------------------- | ------------------------------------------------- | ------------------- | --------------- | ---------- | ------------- |
 | Rar                    | Rar                                               | Decompress (1)      | RarArchive      | RarReader  | N/A           |
-| Zip (2)                | None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd                           | Both                | ZipArchive      | ZipReader  | ZipWriter     | 
+| Zip (2)                | None, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd | Both                | ZipArchive      | ZipReader  | ZipWriter     |
 | Tar                    | None                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.GZip               | DEFLATE                                           | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.BZip2              | BZip2                                             | Both                | TarArchive      | TarReader  | TarWriter (3) |
-| Tar.Zstandard          | ZStandard                                         | Decompress          | TarArchive      | TarReader  | N/A |
 | Tar.LZip               | LZMA                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
@@ -42,7 +41,6 @@ For those who want to directly compress/decompress bits. The single file formats
 | ADCStream       | Decompress          |
 | LZipStream      | Both                |
 | XZStream        | Decompress          |
-| ZStandardStream | Decompress          |

 ## Archive Formats vs Compression

--- a/NuGet.config
+++ b/NuGet.config
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSourceMapping>
-    <!-- key value for <packageSource> should match key values from <packageSources> element -->
-    <packageSource key="nuget.org">
-      <package pattern="*" />
-    </packageSource>
-  </packageSourceMapping>
-</configuration>
--- a/README.md
+++ b/README.md
@@ -1,14 +1,12 @@
 # SharpCompress

-SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1, .NET Core 3.1 and .NET 5.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.

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

-**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [Async Usage](#async-usage) section below.
-
 GitHub Actions Build -
 [![SharpCompress](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml/badge.svg)](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml)
-[![Static Badge](https://img.shields.io/badge/API%20Docs-DNDocs-190088?logo=readme&logoColor=white)](https://dndocs.com/d/sharpcompress/api/index.html)
+[![Static Badge](https://img.shields.io/badge/API%20Documentation-RobiniaDocs-43bc00?logo=readme&logoColor=white)](https://www.robiniadocs.com/d/sharpcompress/api/SharpCompress.html)

 ## Need Help?

@@ -22,94 +20,16 @@ In general, I recommend GZip (Deflate)/BZip2 (BZip)/LZip (LZMA) as the simplicit

 Zip is okay, but it's a very hap-hazard format and the variation in headers and implementations makes it hard to get correct. Uses Deflate by default but supports a lot of compression methods.

-RAR is not recommended as it's a proprietary format and the compression is closed source. Use Tar/LZip for LZMA
+RAR is not recommended as it's a propriatory format and the compression is closed source. Use Tar/LZip for LZMA

 7Zip and XZ both are overly complicated. 7Zip does not support streamable formats. XZ has known holes explained here: (http://www.nongnu.org/lzip/xz_inadequate.html) Use Tar/LZip for LZMA compression instead.

-ZStandard is an efficient format that works well for streaming with a flexible compression level to tweak the speed/performance trade off you are looking for.  We currently only implement decompression for ZStandard but as we leverage the [ZstdSharp](https://github.com/oleg-st/ZstdSharp) library one could likely add compression support without much trouble (PRs are welcome!).
-
 ## A Simple Request

 Hi everyone. I hope you're using SharpCompress and finding it useful. Please give me feedback on what you'd like to see changed especially as far as usability goes. New feature suggestions are always welcome as well. I would also like to know what projects SharpCompress is being used in. I like seeing how it is used to give me ideas for future versions. Thanks!

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

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

 I'm always looking for help or ideas. Please submit code or email with ideas. Unfortunately, just letting me know you'd like to help is not enough because I really have no overall plan of what needs to be done. I'll definitely accept code submissions and add you as a member of the project!
@@ -120,7 +40,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 * 7Zip writing
 * Zip64 (Need writing and extend Reading)
 * Multi-volume Zip support.
-* ZStandard writing

 ## Version Log

--- a/SharpCompress.sln
+++ b/SharpCompress.sln
@@ -17,18 +17,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB425
 	ProjectSection(SolutionItems) = preProject
 		Directory.Build.props = Directory.Build.props
 		global.json = global.json
-		.editorconfig = .editorconfig
-		Directory.Packages.props = Directory.Packages.props
-		NuGet.config = NuGet.config
-		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
-		USAGE.md = USAGE.md
-		README.md = README.md
-		FORMATS.md = FORMATS.md
-		AGENTS.md = AGENTS.md
 	EndProjectSection
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.Performance", "tests\SharpCompress.Performance\SharpCompress.Performance.csproj", "{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -47,10 +37,6 @@ Global
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -58,6 +44,5 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
-		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
 	EndGlobalSection
 EndGlobal
--- a/SharpCompress.sln.DotSettings
+++ b/SharpCompress.sln.DotSettings
@@ -15,17 +15,17 @@
 	
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValue">Basic Clean</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/APPLY_ON_COMPLETION/@EntryValue">True</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Positional</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Named</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOR/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOREACH/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_IFELSE/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_WHILE/@EntryValue">Required</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_LINQ_QUERY/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARGUMENT/@EntryValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_CALLS_CHAIN/@EntryValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXTENDS_LIST/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_FOR_STMT/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_PARAMETER/@EntryValue">True</s:Boolean>
@@ -42,7 +42,7 @@
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_IFELSE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_USING_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_WHILE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">True</s:Boolean>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
@@ -50,12 +50,12 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_CONSTRUCTOR_INITIALIZER_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_EMBEDDED_STATEMENT_ON_SAME_LINE/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
 	
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">True</s:Boolean>
 	
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_EMBEDDED_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_AFTER_TYPECAST_PARENTHESES/@EntryValue">False</s:Boolean>
@@ -67,22 +67,18 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_BEFORE_TYPEOF_PARENTHESES/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/STICK_COMMENT/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARGUMENTS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_ALWAYS</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_EXTENDS_LIST_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_LINES/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_PARAMETERS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVar</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVar</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVar</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVarWhenEvident</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVarWhenEvident</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVarWhenEvident</s:String>
 	
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=StaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=15b5b1f1_002D457c_002D4ca6_002Db278_002D5615aedc07d3/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static readonly fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=4a98fdf6_002D7d98_002D4f5a_002Dafeb_002Dea44ad98c70c/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Instance" AccessRightKinds="Private" Description="Instance fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=c873eafb_002Dd57f_002D481d_002D8c93_002D77f6863c2f88/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Protected, ProtectedInternal, Internal, Public, PrivateProtected" Description="Static readonly fields (not private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=f9fce829_002De6f4_002D4cb2_002D80f1_002D5497c44f51df/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FCONSTANT/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
@@ -122,7 +118,6 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:String x:Key="/Default/CustomTools/CustomToolsData/@EntryValue"></s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
@@ -132,7 +127,6 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EPredefinedNamingRulesToUserRulesUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=6af8f80e_002D9fdd_002D4223_002D8e02_002D473db916f9b2/@EntryIndexedValue">&lt;SessionState ContinuousTestingIsOn="False" ContinuousTestingMode="0" FrameworkVersion="{x:Null}" IsLocked="False" Name="All tests from Solution" PlatformMonoPreference="{x:Null}" PlatformType="{x:Null}" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"&gt;
  &lt;Solution /&gt;
 &lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>
--- a/USAGE.md
+++ b/USAGE.md
@@ -1,18 +1,5 @@
 # SharpCompress Usage

-## Async/Await Support
-
-SharpCompress now provides full async/await support for all I/O operations. All `Read`, `Write`, and extraction operations have async equivalents ending in `Async` that accept an optional `CancellationToken`. This enables better performance and scalability for I/O-bound operations.
-
-**Key Async Methods:**
- `reader.WriteEntryToAsync(stream, cancellationToken)` - Extract entry asynchronously  
- `reader.WriteAllToDirectoryAsync(path, options, 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
-
-See [Async Examples](#async-examples) section below for usage patterns.
-
 ## Stream Rules (changed with 0.21)

 When dealing with Streams, the rule should be that you don't close a stream you didn't create. This, in effect, should mean you should always put a Stream in a using block to dispose it. 
@@ -40,7 +27,7 @@ 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.

-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.
+If using Compression Stream classes directly and you don't want the wrapped stream to be closed.  Use the `NonDisposingStream` as a wrapped to prevent the stream being disposed.  The change in 0.21 simplified a lot even though the usage is a bit more convoluted.

 ## Samples

@@ -84,34 +71,18 @@ using (var archive = ZipArchive.Create())
 memoryStream.Position = 0;
 ```

-### Extract all files from a rar file to a directory using RarArchive
-
-Note: Extracting a solid rar or 7z file needs to be done in sequential order to get acceptable decompression speed.
-It is explicitly recommended to use `ExtractAllEntries` when extracting an entire `IArchive` instead of iterating over all its `Entries`.
-Alternatively, use `IArchive.WriteToDirectory`.
-
-```C#
-using (var archive = RarArchive.Open("Test.rar"))
-{
-    using (var reader = archive.ExtractAllEntries())
-    {
-        reader.WriteAllToDirectory(@"D:\temp", new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        });
-    }
-}
-```
-
-### Iterate over all files from a Rar file using RarArchive
+### Extract all files from a Rar file to a directory using RarArchive

 ```C#
 using (var archive = RarArchive.Open("Test.rar"))
 {
    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
    {
-        Console.WriteLine($"{entry.Key}: {entry.Size} bytes");
+        entry.WriteToDirectory("D:\\temp", new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
    }
 }
 ```
@@ -185,133 +156,3 @@ foreach(var entry in tr.Entries)
    Console.WriteLine($"{entry.Key}");
 }
 ```
-
-## Async Examples
-
-### Async Reader Examples
-
-**Extract single entry asynchronously:**
-```C#
-using (Stream stream = File.OpenRead("archive.zip"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    while (reader.MoveToNextEntry())
-    {
-        if (!reader.Entry.IsDirectory)
-        {
-            using (var entryStream = reader.OpenEntryStream())
-            {
-                using (var outputStream = File.Create("output.bin"))
-                {
-                    await reader.WriteEntryToAsync(outputStream, cancellationToken);
-                }
-            }
-        }
-    }
-}
-```
-
-**Extract all entries asynchronously:**
-```C#
-using (Stream stream = File.OpenRead("archive.tar.gz"))
-using (var reader = ReaderFactory.Open(stream))
-{
-    await reader.WriteAllToDirectoryAsync(
-        @"D:\temp",
-        new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        },
-        cancellationToken
-    );
-}
-```
-
-**Open and process entry stream asynchronously:**
-```C#
-using (var archive = ZipArchive.Open("archive.zip"))
-{
-    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
-    {
-        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
-        {
-            // Process the decompressed stream asynchronously
-            await ProcessStreamAsync(entryStream, cancellationToken);
-        }
-    }
-}
-```
-
-### Async Writer Examples
-
-**Write single file asynchronously:**
-```C#
-using (Stream archiveStream = File.OpenWrite("output.zip"))
-using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    using (Stream fileStream = File.OpenRead("input.txt"))
-    {
-        await writer.WriteAsync("entry.txt", fileStream, DateTime.Now, cancellationToken);
-    }
-}
-```
-
-**Write entire directory asynchronously:**
-```C#
-using (Stream stream = File.OpenWrite("backup.tar.gz"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
-{
-    await writer.WriteAllAsync(
-        @"D:\files",
-        "*",
-        SearchOption.AllDirectories,
-        cancellationToken
-    );
-}
-```
-
-**Write with progress tracking and cancellation:**
-```C#
-var cts = new CancellationTokenSource();
-
-// Set timeout or cancel from UI
-cts.CancelAfter(TimeSpan.FromMinutes(5));
-
-using (Stream stream = File.OpenWrite("archive.zip"))
-using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
-{
-    try
-    {
-        await writer.WriteAllAsync(@"D:\data", "*", SearchOption.AllDirectories, cts.Token);
-    }
-    catch (OperationCanceledException)
-    {
-        Console.WriteLine("Operation was cancelled");
-    }
-}
-```
-
-### Archive Async Examples
-
-**Extract from archive asynchronously:**
-```C#
-using (var archive = ZipArchive.Open("archive.zip"))
-{
-    using (var reader = archive.ExtractAllEntries())
-    {
-        await reader.WriteAllToDirectoryAsync(
-            @"C:\output",
-            new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
-            cancellationToken
-        );
-    }
-}
-```
-
-**Benefits of Async Operations:**
- Non-blocking I/O for better application responsiveness
- Improved scalability for server applications
- Support for cancellation via CancellationToken
- Better resource utilization in async/await contexts
- Compatible with modern .NET async patterns
--- a/build/Program.cs
+++ b/build/Program.cs
@@ -15,7 +15,7 @@ const string Publish = "publish";

 Target(
    Clean,
-    ["**/bin", "**/obj"],
+    ForEach("**/bin", "**/obj"),
    dir =>
    {
        IEnumerable<string> GetDirectories(string d)
@@ -44,14 +44,14 @@ Target(
    () =>
    {
        Run("dotnet", "tool restore");
-        Run("dotnet", "csharpier check .");
+        Run("dotnet", "csharpier --check .");
    }
 );
-Target(Restore, [Format], () => Run("dotnet", "restore"));
+Target(Restore, DependsOn(Format), () => Run("dotnet", "restore"));

 Target(
    Build,
-    [Restore],
+    DependsOn(Restore),
    () =>
    {
        Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release --no-restore");
@@ -60,8 +60,8 @@ Target(

 Target(
    Test,
-    [Build],
-    ["net8.0", "net48"],
+    DependsOn(Build),
+    ForEach("net8.0", "net462"),
    framework =>
    {
        IEnumerable<string> GetFiles(string d)
@@ -69,7 +69,7 @@ Target(
            return Glob.Files(".", d);
        }

-        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net48")
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net462")
        {
            return;
        }
@@ -83,13 +83,13 @@ Target(

 Target(
    Publish,
-    [Test],
+    DependsOn(Test),
    () =>
    {
        Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
    }
 );

-Target("default", [Publish], () => Console.WriteLine("Done!"));
+Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));

 await RunTargetsAndExitAsync(args);
--- a/build/build.csproj
+++ b/build/build.csproj
@@ -1,11 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
+
  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
  </PropertyGroup>
+
  <ItemGroup>
-    <PackageReference Include="Bullseye" />
-    <PackageReference Include="Glob" />
-    <PackageReference Include="SimpleExec" />
+    <PackageReference Include="Bullseye" Version="4.2.1" />
+    <PackageReference Include="Glob" Version="1.1.9" />
+    <PackageReference Include="SimpleExec" Version="11.0.0" />
  </ItemGroup>
+
 </Project>
--- a/build/packages.lock.json
+++ b/build/packages.lock.json
@@ -1,25 +0,0 @@
-{
-  "version": 2,
-  "dependencies": {
-    "net8.0": {
-      "Bullseye": {
-        "type": "Direct",
-        "requested": "[6.0.0, )",
-        "resolved": "6.0.0",
-        "contentHash": "vgwwXfzs7jJrskWH7saHRMgPzziq/e86QZNWY1MnMxd7e+De7E7EX4K3C7yrvaK9y02SJoLxNxcLG/q5qUAghw=="
-      },
-      "Glob": {
-        "type": "Direct",
-        "requested": "[1.1.9, )",
-        "resolved": "1.1.9",
-        "contentHash": "AfK5+ECWYTP7G3AAdnU8IfVj+QpGjrh9GC2mpdcJzCvtQ4pnerAGwHsxJ9D4/RnhDUz2DSzd951O/lQjQby2Sw=="
-      },
-      "SimpleExec": {
-        "type": "Direct",
-        "requested": "[12.0.0, )",
-        "resolved": "12.0.0",
-        "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q=="
-      }
-    }
-  }
-}
--- a/src/SharpCompress/Algorithms/Adler32.cs
+++ b/src/SharpCompress/Algorithms/Adler32.cs
@@ -141,7 +141,7 @@ internal static class Adler32 // From https://github.com/SixLabors/ImageSharp/bl
            4,
            3,
            2,
-            1, // tap2
+            1 // tap2
        };
 #endif

--- a/src/SharpCompress/Archives/AbstractArchive.cs
+++ b/src/SharpCompress/Archives/AbstractArchive.cs
@@ -12,35 +12,39 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
    where TEntry : IArchiveEntry
    where TVolume : IVolume
 {
-    private readonly LazyReadOnlyCollection<TVolume> _lazyVolumes;
-    private readonly LazyReadOnlyCollection<TEntry> _lazyEntries;
-    private bool _disposed;
-    private readonly SourceStream? _sourceStream;
+    private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
+    private readonly LazyReadOnlyCollection<TEntry> lazyEntries;

    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;

    public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
    public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
+
    protected ReaderOptions ReaderOptions { get; }

-    internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
+    private bool disposed;
+    protected SourceStream SrcStream;
+
+    internal AbstractArchive(ArchiveType type, SourceStream srcStream)
    {
        Type = type;
-        ReaderOptions = sourceStream.ReaderOptions;
-        _sourceStream = sourceStream;
-        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(_sourceStream));
-        _lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+        ReaderOptions = srcStream.ReaderOptions;
+        SrcStream = srcStream;
+        lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
+        lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
    }

+#nullable disable
    internal AbstractArchive(ArchiveType type)
    {
        Type = type;
-        ReaderOptions = new();
-        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
-        _lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+        lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
+        lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
    }

+#nullable enable
+
    public ArchiveType Type { get; }

    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
@@ -53,7 +57,7 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
    {
        if (!stream.CanSeek || !stream.CanRead)
        {
-            throw new ArchiveException("Archive streams must be Readable and Seekable");
+            throw new ArgumentException("Archive streams must be Readable and Seekable");
        }
        return stream;
    }
@@ -61,12 +65,12 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
    /// <summary>
    /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
    /// </summary>
-    public virtual ICollection<TEntry> Entries => _lazyEntries;
+    public virtual ICollection<TEntry> Entries => lazyEntries;

    /// <summary>
    /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
    /// </summary>
-    public ICollection<TVolume> Volumes => _lazyVolumes;
+    public ICollection<TVolume> Volumes => lazyVolumes;

    /// <summary>
    /// The total size of the files compressed in the archive.
@@ -80,29 +84,29 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
    public virtual long TotalUncompressSize =>
        Entries.Aggregate(0L, (total, cf) => total + cf.Size);

-    protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
+    protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream srcStream);
    protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);

    IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();

-    IEnumerable<IVolume> IArchive.Volumes => _lazyVolumes.Cast<IVolume>();
+    IEnumerable<IVolume> IArchive.Volumes => lazyVolumes.Cast<IVolume>();

    public virtual void Dispose()
    {
-        if (!_disposed)
+        if (!disposed)
        {
-            _lazyVolumes.ForEach(v => v.Dispose());
-            _lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
-            _sourceStream?.Dispose();
+            lazyVolumes.ForEach(v => v.Dispose());
+            lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+            SrcStream?.Dispose();

-            _disposed = true;
+            disposed = true;
        }
    }

    void IArchiveExtractionListener.EnsureEntriesLoaded()
    {
-        _lazyEntries.EnsureFullyLoaded();
-        _lazyVolumes.EnsureFullyLoaded();
+        lazyEntries.EnsureFullyLoaded();
+        lazyVolumes.EnsureFullyLoaded();
    }

    void IExtractionListener.FireCompressedBytesRead(
@@ -144,12 +148,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
    /// <returns></returns>
    public IReader ExtractAllEntries()
    {
-        if (!IsSolid && Type != ArchiveType.SevenZip)
-        {
-            throw new InvalidOperationException(
-                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
-            );
-        }
        ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
        return CreateReaderForSolidExtraction();
    }
--- a/src/SharpCompress/Archives/AbstractWritableArchive.cs
+++ b/src/SharpCompress/Archives/AbstractWritableArchive.cs
@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 using SharpCompress.Writers;
@@ -43,8 +41,8 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
    internal AbstractWritableArchive(ArchiveType type)
        : base(type) { }

-    internal AbstractWritableArchive(ArchiveType type, SourceStream sourceStream)
-        : base(type, sourceStream) { }
+    internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
+        : base(type, srcStream) { }

    public override ICollection<TEntry> Entries
    {
@@ -96,9 +94,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
        DateTime? modified
    ) => AddEntry(key, source, closeStream, size, modified);

-    IArchiveEntry IWritableArchive.AddDirectoryEntry(string key, DateTime? modified) =>
-        AddDirectoryEntry(key, modified);
-
    public TEntry AddEntry(
        string key,
        Stream source,
@@ -125,10 +120,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
    {
        foreach (var path in Entries.Select(x => x.Key))
        {
-            if (path is null)
-            {
-                continue;
-            }
            var p = path.Replace('/', '\\');
            if (p.Length > 0 && p[0] == '\\')
            {
@@ -139,22 +130,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
        return false;
    }

-    public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (DoesKeyMatchExisting(key))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateDirectoryEntry(key, modified);
-        newEntries.Add(entry);
-        RebuildModifiedCollection();
-        return entry;
-    }
-
    public void SaveTo(Stream stream, WriterOptions options)
    {
        //reset streams of new entries
@@ -162,18 +137,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
        SaveTo(stream, options, OldEntries, newEntries);
    }

-    public async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        //reset streams of new entries
-        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        await SaveToAsync(stream, options, OldEntries, newEntries, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
    protected TEntry CreateEntry(
        string key,
        Stream source,
@@ -184,7 +147,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
    {
        if (!source.CanRead || !source.CanSeek)
        {
-            throw new ArchiveException(
+            throw new ArgumentException(
                "Streams must be readable and seekable to use the Writing Archive API"
            );
        }
@@ -199,8 +162,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
        bool closeStream
    );

-    protected abstract TEntry CreateDirectoryEntry(string key, DateTime? modified);
-
    protected abstract void SaveTo(
        Stream stream,
        WriterOptions options,
@@ -208,14 +169,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
        IEnumerable<TEntry> newEntries
    );

-    protected abstract Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TEntry> oldEntries,
-        IEnumerable<TEntry> newEntries,
-        CancellationToken cancellationToken = default
-    );
-
    public override void Dispose()
    {
        base.Dispose();
--- a/src/SharpCompress/Archives/ArchiveFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveFactory.cs
@@ -4,7 +4,6 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Factories;
-using SharpCompress.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Archives;
@@ -20,7 +19,7 @@ public static class ArchiveFactory
    public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
    {
        readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+
        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
    }

@@ -45,7 +44,7 @@ public static class ArchiveFactory
    /// <param name="options"></param>
    public static IArchive Open(string filePath, ReaderOptions? options = null)
    {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
        return Open(new FileInfo(filePath), options);
    }

@@ -68,7 +67,7 @@ public static class ArchiveFactory
    /// <param name="options"></param>
    public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
    {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
        var filesArray = fileInfos.ToArray();
        if (filesArray.Length == 0)
        {
@@ -81,7 +80,7 @@ public static class ArchiveFactory
            return Open(fileInfo, options);
        }

-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
        options ??= new ReaderOptions { LeaveStreamOpen = false };

        return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
@@ -94,7 +93,7 @@ public static class ArchiveFactory
    /// <param name="options"></param>
    public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
    {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
        var streamsArray = streams.ToArray();
        if (streamsArray.Length == 0)
        {
@@ -107,7 +106,7 @@ public static class ArchiveFactory
            return Open(firstStream, options);
        }

-        firstStream.NotNull(nameof(firstStream));
+        firstStream.CheckNotNull(nameof(firstStream));
        options ??= new ReaderOptions();

        return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
@@ -123,13 +122,16 @@ public static class ArchiveFactory
    )
    {
        using var archive = Open(sourceArchive);
-        archive.WriteToDirectory(destinationDirectory, options);
+        foreach (var entry in archive.Entries)
+        {
+            entry.WriteToDirectory(destinationDirectory, options);
+        }
    }

    private static T FindFactory<T>(FileInfo finfo)
        where T : IFactory
    {
-        finfo.NotNull(nameof(finfo));
+        finfo.CheckNotNull(nameof(finfo));
        using Stream stream = finfo.OpenRead();
        return FindFactory<T>(stream);
    }
@@ -137,7 +139,7 @@ public static class ArchiveFactory
    private static T FindFactory<T>(Stream stream)
        where T : IFactory
    {
-        stream.NotNull(nameof(stream));
+        stream.CheckNotNull(nameof(stream));
        if (!stream.CanRead || !stream.CanSeek)
        {
            throw new ArgumentException("Stream should be readable and seekable");
@@ -166,25 +168,17 @@ public static class ArchiveFactory
        );
    }

-    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));
+        filePath.CheckNotNullOrEmpty(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));
+        stream.CheckNotNull(nameof(stream));

        if (!stream.CanRead || !stream.CanSeek)
        {
@@ -195,10 +189,9 @@ public static class ArchiveFactory

        foreach (var factory in Factory.Factories)
        {
-            var isArchive = factory.IsArchive(stream);
            stream.Position = startPosition;

-            if (isArchive)
+            if (factory.IsArchive(stream, null))
            {
                type = factory.KnownArchiveType;
                return true;
@@ -215,7 +208,7 @@ public static class ArchiveFactory
    /// <returns></returns>
    public static IEnumerable<string> GetFileParts(string part1)
    {
-        part1.NotNullOrEmpty(nameof(part1));
+        part1.CheckNotNullOrEmpty(nameof(part1));
        return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
    }

@@ -226,7 +219,7 @@ public static class ArchiveFactory
    /// <returns></returns>
    public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
    {
-        part1.NotNull(nameof(part1));
+        part1.CheckNotNull(nameof(part1));
        yield return part1;

        foreach (var factory in Factory.Factories.OfType<IFactory>())
@@ -246,6 +239,4 @@ public static class ArchiveFactory
            }
        }
    }
-
-    public static IArchiveFactory AutoFactory { get; } = new AutoArchiveFactory();
 }
--- a/src/SharpCompress/Archives/AutoArchiveFactory.cs
+++ b/src/SharpCompress/Archives/AutoArchiveFactory.cs
@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Common;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-class AutoArchiveFactory : IArchiveFactory
-{
-    public string Name => nameof(AutoArchiveFactory);
-
-    public ArchiveType? KnownArchiveType => null;
-
-    public IEnumerable<string> GetSupportedExtensions() => throw new NotSupportedException();
-
-    public bool IsArchive(
-        Stream stream,
-        string? password = null,
-        int bufferSize = ReaderOptions.DefaultBufferSize
-    ) => throw new NotSupportedException();
-
-    public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
-
-    public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
-        ArchiveFactory.Open(stream, readerOptions);
-
-    public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
-        ArchiveFactory.Open(fileInfo, readerOptions);
-}
--- a/src/SharpCompress/Archives/GZip/GZipArchive.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchive.cs
@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
 using SharpCompress.IO;
@@ -23,7 +21,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    /// <param name="readerOptions"></param>
    public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
    {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
    }

@@ -34,7 +32,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    /// <param name="readerOptions"></param>
    public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
    {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
        return new GZipArchive(
            new SourceStream(
                fileInfo,
@@ -54,7 +52,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
        ReaderOptions? readerOptions = null
    )
    {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
        var files = fileInfos.ToArray();
        return new GZipArchive(
            new SourceStream(
@@ -72,7 +70,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    /// <param name="readerOptions"></param>
    public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
    {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
        var strms = streams.ToArray();
        return new GZipArchive(
            new SourceStream(
@@ -90,15 +88,9 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    /// <param name="readerOptions"></param>
    public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
+        stream.CheckNotNull(nameof(stream));
        return new GZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
        );
    }

@@ -107,14 +99,16 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    /// <summary>
    /// Constructor with a SourceStream able to handle FileInfo and Streams.
    /// </summary>
-    /// <param name="sourceStream"></param>
-    private GZipArchive(SourceStream sourceStream)
-        : base(ArchiveType.GZip, sourceStream) { }
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal GZipArchive(SourceStream srcStream)
+        : base(ArchiveType.Tar, srcStream) { }

-    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream sourceStream)
+    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
    {
-        sourceStream.LoadAllParts();
-        return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0));
+        srcStream.LoadAllParts();
+        var idx = 0;
+        return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, idx++));
    }

    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
@@ -138,16 +132,6 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
        SaveTo(stream, new WriterOptions(CompressionType.GZip));
    }

-    public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
-        SaveToAsync(new FileInfo(filePath), cancellationToken);
-
-    public async Task SaveToAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
-            .ConfigureAwait(false);
-    }
-
    public static bool IsGZipFile(Stream stream)
    {
        // read the header on the first read
@@ -180,16 +164,11 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    {
        if (Entries.Any())
        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
+            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
        }
        return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
    }

-    protected override GZipArchiveEntry CreateDirectoryEntry(
-        string directoryPath,
-        DateTime? modified
-    ) => throw new NotSupportedException("GZip archives do not support directory entries.");
-
    protected override void SaveTo(
        Stream stream,
        WriterOptions options,
@@ -199,39 +178,13 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    {
        if (Entries.Count > 1)
        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
+            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
        }
        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
        {
            using var entryStream = entry.OpenEntryStream();
-            writer.Write(
-                entry.Key.NotNull("Entry Key is null"),
-                entryStream,
-                entry.LastModifiedTime
-            );
-        }
-    }
-
-    protected override async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<GZipArchiveEntry> oldEntries,
-        IEnumerable<GZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (Entries.Count > 1)
-        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-        }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
-        {
-            using var entryStream = entry.OpenEntryStream();
-            await writer
-                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
-                .ConfigureAwait(false);
+            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
        }
    }

--- a/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
@@ -1,32 +1,23 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.GZip;

 namespace SharpCompress.Archives.GZip;

 public class GZipArchiveEntry : GZipEntry, IArchiveEntry
 {
-    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart? part)
+    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
        : base(part) => Archive = archive;

    public virtual Stream OpenEntryStream()
    {
        //this is to reset the stream to be read multiple times
        var part = (GZipFilePart)Parts.Single();
-        var rawStream = part.GetRawStream();
-        if (rawStream.CanSeek && rawStream.Position != part.EntryStartPosition)
+        if (part.GetRawStream().Position != part.EntryStartPosition)
        {
-            rawStream.Position = part.EntryStartPosition;
+            part.GetRawStream().Position = part.EntryStartPosition;
        }
-        return Parts.Single().GetCompressedStream().NotNull();
-    }
-
-    public virtual Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
-    {
-        // GZip synchronous implementation is fast enough, just wrap it
-        return Task.FromResult(OpenEntryStream());
+        return Parts.Single().GetCompressedStream();
    }

    #region IArchiveEntry Members
--- a/src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs
@@ -1,3 +1,5 @@
+#nullable disable
+
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -30,7 +32,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch

    public override long Crc => 0;

-    public override string? Key { get; }
+    public override string Key { get; }

    public override long CompressedSize => 0;

@@ -58,7 +60,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 NonDisposingStream.Create(stream);
    }

    internal override void Close()
--- a/src/SharpCompress/Archives/IArchiveEntry.cs
+++ b/src/SharpCompress/Archives/IArchiveEntry.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;

 namespace SharpCompress.Archives;
@@ -13,12 +11,6 @@ public interface IArchiveEntry : IEntry
    /// </summary>
    Stream OpenEntryStream();

-    /// <summary>
-    /// Opens the current entry as a stream that will decompress as it is read asynchronously.
-    /// Read the entire stream or use SkipEntry on EntryStream.
-    /// </summary>
-    Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
-
    /// <summary>
    /// The archive can find all the parts of the archive needed to extract this entry.
    /// </summary>
--- a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

@@ -19,43 +17,19 @@ public static class IArchiveEntryExtensions
        streamListener.EnsureEntriesLoaded();
        streamListener.FireEntryExtractionBegin(archiveEntry);
        streamListener.FireFilePartExtractionBegin(
-            archiveEntry.Key ?? "Key",
+            archiveEntry.Key,
            archiveEntry.Size,
            archiveEntry.CompressedSize
        );
        var entryStream = archiveEntry.OpenEntryStream();
+        if (entryStream is null)
+        {
+            return;
+        }
        using (entryStream)
        {
            using Stream s = new ListeningStream(streamListener, entryStream);
-            s.CopyTo(streamToWriteTo);
-        }
-        streamListener.FireEntryExtractionEnd(archiveEntry);
-    }
-
-    public static async Task WriteToAsync(
-        this IArchiveEntry archiveEntry,
-        Stream streamToWriteTo,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (archiveEntry.IsDirectory)
-        {
-            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-        }
-
-        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
-        streamListener.EnsureEntriesLoaded();
-        streamListener.FireEntryExtractionBegin(archiveEntry);
-        streamListener.FireFilePartExtractionBegin(
-            archiveEntry.Key ?? "Key",
-            archiveEntry.Size,
-            archiveEntry.CompressedSize
-        );
-        var entryStream = archiveEntry.OpenEntryStream();
-        using (entryStream)
-        {
-            using Stream s = new ListeningStream(streamListener, entryStream);
-            await s.CopyToAsync(streamToWriteTo, 81920, cancellationToken).ConfigureAwait(false);
+            s.TransferTo(streamToWriteTo);
        }
        streamListener.FireEntryExtractionEnd(archiveEntry);
    }
@@ -75,23 +49,6 @@ public static class IArchiveEntryExtensions
            entry.WriteToFile
        );

-    /// <summary>
-    /// Extract to specific directory asynchronously, retaining filename
-    /// </summary>
-    public static Task WriteToDirectoryAsync(
-        this IArchiveEntry entry,
-        string destinationDirectory,
-        ExtractionOptions? options = null,
-        CancellationToken cancellationToken = default
-    ) =>
-        ExtractionMethods.WriteEntryToDirectoryAsync(
-            entry,
-            destinationDirectory,
-            options,
-            (x, opt) => entry.WriteToFileAsync(x, opt, cancellationToken),
-            cancellationToken
-        );
-
    /// <summary>
    /// Extract to specific file
    /// </summary>
@@ -110,25 +67,4 @@ public static class IArchiveEntryExtensions
                entry.WriteTo(fs);
            }
        );
-
-    /// <summary>
-    /// Extract to specific file asynchronously
-    /// </summary>
-    public static Task WriteToFileAsync(
-        this IArchiveEntry entry,
-        string destinationFileName,
-        ExtractionOptions? options = null,
-        CancellationToken cancellationToken = default
-    ) =>
-        ExtractionMethods.WriteEntryToFileAsync(
-            entry,
-            destinationFileName,
-            options,
-            async (x, fm) =>
-            {
-                using var fs = File.Open(destinationFileName, fm);
-                await entry.WriteToAsync(fs, cancellationToken).ConfigureAwait(false);
-            },
-            cancellationToken
-        );
 }
--- a/src/SharpCompress/Archives/IArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveExtensions.cs
@@ -3,8 +3,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
-using SharpCompress.Readers;

 namespace SharpCompress.Archives;

@@ -19,8 +19,10 @@ public static class IArchiveExtensions
        ExtractionOptions? options = null
    )
    {
-        using var reader = archive.ExtractAllEntries();
-        reader.WriteAllToDirectory(destinationDirectory, options);
+        foreach (var entry in archive.Entries.Where(x => !x.IsDirectory))
+        {
+            entry.WriteToDirectory(destinationDirectory, options);
+        }
    }

    /// <summary>
@@ -45,37 +47,27 @@ public static class IArchiveExtensions
        var seenDirectories = new HashSet<string>();

        // Extract
-        foreach (var entry in archive.Entries)
+        var entries = archive.ExtractAllEntries();
+        while (entries.MoveToNextEntry())
        {
            cancellationToken.ThrowIfCancellationRequested();

+            var entry = entries.Entry;
            if (entry.IsDirectory)
            {
-                var dirPath = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
-                if (
-                    Path.GetDirectoryName(dirPath + "/") is { } emptyDirectory
-                    && seenDirectories.Add(dirPath)
-                )
-                {
-                    Directory.CreateDirectory(emptyDirectory);
-                }
                continue;
            }

-            // Create each directory if not already created
-            var path = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
-            if (Path.GetDirectoryName(path) is { } directory)
+            // Create each directory
+            var path = Path.Combine(destination, entry.Key);
+            if (Path.GetDirectoryName(path) is { } directory && seenDirectories.Add(path))
            {
-                if (!Directory.Exists(directory) && !seenDirectories.Contains(directory))
-                {
-                    Directory.CreateDirectory(directory);
-                    seenDirectories.Add(directory);
-                }
+                Directory.CreateDirectory(directory);
            }

            // Write file
            using var fs = File.OpenWrite(path);
-            entry.WriteTo(fs);
+            entries.WriteEntryTo(fs);

            // Update progress
            bytesRead += entry.Size;
--- a/src/SharpCompress/Archives/IWritableArchive.cs
+++ b/src/SharpCompress/Archives/IWritableArchive.cs
@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Writers;

 namespace SharpCompress.Archives;
@@ -18,16 +16,8 @@ public interface IWritableArchive : IArchive
        DateTime? modified = null
    );

-    IArchiveEntry AddDirectoryEntry(string key, DateTime? modified = null);
-
    void SaveTo(Stream stream, WriterOptions options);

-    Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    );
-
    /// <summary>
    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
    /// </summary>
--- a/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
@@ -1,7 +1,5 @@
 using System;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Writers;

 namespace SharpCompress.Archives;
@@ -44,24 +42,6 @@ public static class IWritableArchiveExtensions
        writableArchive.SaveTo(stream, options);
    }

-    public static Task SaveToAsync(
-        this IWritableArchive writableArchive,
-        string filePath,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    ) => writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
-
-    public static async Task SaveToAsync(
-        this IWritableArchive writableArchive,
-        FileInfo fileInfo,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await writableArchive.SaveToAsync(stream, options, cancellationToken).ConfigureAwait(false);
-    }
-
    public static void AddAllFromDirectory(
        this IWritableArchive writableArchive,
        string filePath,
--- a/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Rar;
@@ -14,7 +13,7 @@ namespace SharpCompress.Archives.Rar;
 /// </summary>
 internal class FileInfoRarArchiveVolume : RarVolume
 {
-    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index)
+    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index = 0)
        : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options), index)
    {
        FileInfo = fileInfo;
--- a/src/SharpCompress/Archives/Rar/RarArchive.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.cs
@@ -14,7 +14,6 @@ namespace SharpCompress.Archives.Rar;

 public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 {
-    private bool _disposed;
    internal Lazy<IRarUnpack> UnpackV2017 { get; } =
        new(() => new Compressors.Rar.UnpackV2017.Unpack());
    internal Lazy<IRarUnpack> UnpackV1 { get; } = new(() => new Compressors.Rar.UnpackV1.Unpack());
@@ -22,61 +21,39 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    /// <summary>
    /// Constructor with a SourceStream able to handle FileInfo and Streams.
    /// </summary>
-    /// <param name="sourceStream"></param>
-    private RarArchive(SourceStream sourceStream)
-        : base(ArchiveType.Rar, sourceStream) { }
-
-    public override void Dispose()
-    {
-        if (!_disposed)
-        {
-            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
-            {
-                unpackV1.Dispose();
-            }
-
-            _disposed = true;
-            base.Dispose();
-        }
-    }
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal RarArchive(SourceStream srcStream)
+        : base(ArchiveType.Rar, srcStream) { }

    protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
        RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);

-    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
+    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream srcStream)
    {
-        sourceStream.LoadAllParts(); //request all streams
-        var streams = sourceStream.Streams.ToArray();
-        var i = 0;
+        SrcStream.LoadAllParts(); //request all streams
+        var streams = SrcStream.Streams.ToArray();
+        var idx = 0;
        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
        {
-            sourceStream.IsVolumes = true;
+            SrcStream.IsVolumes = true;
            streams[1].Position = 0;
-            sourceStream.Position = 0;
+            SrcStream.Position = 0;

-            return sourceStream.Streams.Select(a => new StreamRarArchiveVolume(
+            return srcStream.Streams.Select(a => new StreamRarArchiveVolume(
                a,
                ReaderOptions,
-                i++
+                idx++
            ));
        }
-
-        //split mode or single file
-        return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
+        else //split mode or single file
+        {
+            return new StreamRarArchiveVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
+        }
    }

    protected override IReader CreateReaderForSolidExtraction()
    {
-        if (this.IsMultipartVolume())
-        {
-            var streams = Volumes.Select(volume =>
-            {
-                volume.Stream.Position = 0;
-                return volume.Stream;
-            });
-            return RarReader.Open(streams, ReaderOptions);
-        }
-
        var stream = Volumes.First().Stream;
        stream.Position = 0;
        return RarReader.Open(stream, ReaderOptions);
@@ -95,7 +72,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    /// <param name="options"></param>
    public static RarArchive Open(string filePath, ReaderOptions? options = null)
    {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
        var fileInfo = new FileInfo(filePath);
        return new RarArchive(
            new SourceStream(
@@ -113,7 +90,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    /// <param name="options"></param>
    public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
    {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
        return new RarArchive(
            new SourceStream(
                fileInfo,
@@ -130,14 +107,8 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    /// <param name="options"></param>
    public static RarArchive Open(Stream stream, ReaderOptions? options = null)
    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
-        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
+        stream.CheckNotNull(nameof(stream));
+        return new RarArchive(new SourceStream(stream, i => null, options ?? new ReaderOptions()));
    }

    /// <summary>
@@ -150,7 +121,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
        ReaderOptions? readerOptions = null
    )
    {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
        var files = fileInfos.ToArray();
        return new RarArchive(
            new SourceStream(
@@ -168,7 +139,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    /// <param name="readerOptions"></param>
    public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
    {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
        var strms = streams.ToArray();
        return new RarArchive(
            new SourceStream(
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
@@ -44,7 +42,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
        {
            CheckIncomplete();
            return BitConverter.ToUInt32(
-                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc.NotNull(),
+                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc,
                0
            );
        }
@@ -70,50 +68,20 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry

    public Stream OpenEntryStream()
    {
-        RarStream stream;
        if (IsRarV3)
        {
-            stream = new RarStream(
+            return new RarStream(
                archive.UnpackV1.Value,
                FileHeader,
                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
            );
        }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
-        }

-        stream.Initialize();
-        return stream;
-    }
-
-    public async Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
-    {
-        RarStream stream;
-        if (IsRarV3)
-        {
-            stream = new RarStream(
-                archive.UnpackV1.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
-        }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
-        }
-
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
+        return new RarStream(
+            archive.UnpackV2017.Value,
+            FileHeader,
+            new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+        );
    }

    public bool IsComplete
--- a/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
@@ -6,8 +6,8 @@ namespace SharpCompress.Archives.Rar;

 internal class SeekableFilePart : RarFilePart
 {
-    private readonly Stream _stream;
-    private readonly string? _password;
+    private readonly Stream stream;
+    private readonly string? password;

    internal SeekableFilePart(
        MarkHeader mh,
@@ -18,27 +18,27 @@ internal class SeekableFilePart : RarFilePart
    )
        : base(mh, fh, index)
    {
-        _stream = stream;
-        _password = password;
+        this.stream = stream;
+        this.password = password;
    }

    internal override Stream GetCompressedStream()
    {
-        _stream.Position = FileHeader.DataStartPosition;
+        stream.Position = FileHeader.DataStartPosition;

        if (FileHeader.R4Salt != null)
        {
-            var cryptKey = new CryptKey3(_password!);
-            return new RarCryptoWrapper(_stream, FileHeader.R4Salt, cryptKey);
+            var cryptKey = new CryptKey3(password!);
+            return new RarCryptoWrapper(stream, FileHeader.R4Salt, cryptKey);
        }

        if (FileHeader.Rar5CryptoInfo != null)
        {
-            var cryptKey = new CryptKey5(_password!, FileHeader.Rar5CryptoInfo);
-            return new RarCryptoWrapper(_stream, FileHeader.Rar5CryptoInfo.Salt, cryptKey);
+            var cryptKey = new CryptKey5(password!, FileHeader.Rar5CryptoInfo);
+            return new RarCryptoWrapper(stream, FileHeader.Rar5CryptoInfo.Salt, cryptKey);
        }

-        return _stream;
+        return stream;
    }

    internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
--- a/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
@@ -9,7 +9,7 @@ namespace SharpCompress.Archives.Rar;

 internal class StreamRarArchiveVolume : RarVolume
 {
-    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index)
+    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index = 0)
        : base(StreamingMode.Seekable, stream, options, index) { }

    internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
@@ -1,3 +1,5 @@
+#nullable disable
+
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -12,16 +14,16 @@ namespace SharpCompress.Archives.SevenZip;

 public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
 {
-    private ArchiveDatabase? _database;
+    private ArchiveDatabase database;

    /// <summary>
    /// Constructor expects a filepath to an existing file.
    /// </summary>
    /// <param name="filePath"></param>
    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    public static SevenZipArchive Open(string filePath, ReaderOptions readerOptions = null)
    {
-        filePath.NotNullOrEmpty("filePath");
+        filePath.CheckNotNullOrEmpty("filePath");
        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
    }

@@ -30,9 +32,9 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
    /// </summary>
    /// <param name="fileInfo"></param>
    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
    {
-        fileInfo.NotNull("fileInfo");
+        fileInfo.CheckNotNull("fileInfo");
        return new SevenZipArchive(
            new SourceStream(
                fileInfo,
@@ -49,10 +51,10 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
    /// <param name="readerOptions"></param>
    public static SevenZipArchive Open(
        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
+        ReaderOptions readerOptions = null
    )
    {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
        var files = fileInfos.ToArray();
        return new SevenZipArchive(
            new SourceStream(
@@ -70,10 +72,10 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
    /// <param name="readerOptions"></param>
    public static SevenZipArchive Open(
        IEnumerable<Stream> streams,
-        ReaderOptions? readerOptions = null
+        ReaderOptions readerOptions = null
    )
    {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
        var strms = streams.ToArray();
        return new SevenZipArchive(
            new SourceStream(
@@ -89,31 +91,27 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
    /// </summary>
    /// <param name="stream"></param>
    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
    {
-        stream.NotNull("stream");
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
+        stream.CheckNotNull("stream");
        return new SevenZipArchive(
-            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
        );
    }

    /// <summary>
    /// Constructor with a SourceStream able to handle FileInfo and Streams.
    /// </summary>
-    /// <param name="sourceStream"></param>
-    private SevenZipArchive(SourceStream sourceStream)
-        : base(ArchiveType.SevenZip, sourceStream) { }
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal SevenZipArchive(SourceStream srcStream)
+        : base(ArchiveType.SevenZip, srcStream) { }

-    protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream sourceStream)
+    protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream srcStream)
    {
-        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
-        return new SevenZipVolume(sourceStream, ReaderOptions, 0).AsEnumerable(); //simple single volume or split, multivolume not supported
+        SrcStream.LoadAllParts(); //request all streams
+        var idx = 0;
+        return new SevenZipVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
    }

    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
@@ -137,17 +135,13 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
    {
        var stream = volumes.Single().Stream;
        LoadFactory(stream);
-        if (_database is null)
+        var entries = new SevenZipArchiveEntry[database._files.Count];
+        for (var i = 0; i < database._files.Count; i++)
        {
-            return Enumerable.Empty<SevenZipArchiveEntry>();
-        }
-        var entries = new SevenZipArchiveEntry[_database._files.Count];
-        for (var i = 0; i < _database._files.Count; i++)
-        {
-            var file = _database._files[i];
+            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)
            );
        }
        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
@@ -165,12 +159,12 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol

    private void LoadFactory(Stream stream)
    {
-        if (_database is null)
+        if (database is null)
        {
            stream.Position = 0;
            var reader = new ArchiveReader();
-            reader.Open(stream, lookForHeader: ReaderOptions.LookForHeader);
-            _database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
+            reader.Open(stream);
+            database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
        }
    }

@@ -186,43 +180,46 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
        }
    }

-    private static ReadOnlySpan<byte> Signature =>
+    private static ReadOnlySpan<byte> SIGNATURE =>
        new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };

    private static bool SignatureMatch(Stream stream)
    {
        var reader = new BinaryReader(stream);
        ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
-        return signatureBytes.SequenceEqual(Signature);
+        return signatureBytes.SequenceEqual(SIGNATURE);
    }

    protected override IReader CreateReaderForSolidExtraction() =>
        new SevenZipReader(ReaderOptions, this);

    public override bool IsSolid =>
-        Entries
-            .Where(x => !x.IsDirectory)
-            .GroupBy(x => x.FilePart.Folder)
-            .Any(folder => folder.Count() > 1);
+        Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1;

-    public override long TotalSize =>
-        _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;
+    public override long TotalSize
+    {
+        get
+        {
+            var i = Entries.Count;
+            return database._packSizes.Aggregate(0L, (total, packSize) => total + packSize);
+        }
+    }

    private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
    {
-        private readonly SevenZipArchive _archive;
-        private CFolder? _currentFolder;
-        private Stream? _currentStream;
-        private CFileItem? _currentItem;
+        private readonly SevenZipArchive archive;
+        private CFolder currentFolder;
+        private Stream currentStream;
+        private CFileItem currentItem;

        internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-            : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive;
+            : base(readerOptions, ArchiveType.SevenZip) => this.archive = archive;

-        public override SevenZipVolume Volume => _archive.Volumes.Single();
+        public override SevenZipVolume Volume => archive.Volumes.Single();

        protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
        {
-            var entries = _archive.Entries.ToList();
+            var entries = archive.Entries.ToList();
            stream.Position = 0;
            foreach (var dir in entries.Where(x => x.IsDirectory))
            {
@@ -232,42 +229,37 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
            )
            {
-                _currentFolder = group.Key;
+                currentFolder = group.Key;
                if (group.Key is null)
                {
-                    _currentStream = Stream.Null;
+                    currentStream = Stream.Null;
                }
                else
                {
-                    _currentStream = _archive._database?.GetFolderStream(
+                    currentStream = archive.database.GetFolderStream(
                        stream,
-                        _currentFolder,
+                        currentFolder,
                        new PasswordProvider(Options.Password)
                    );
                }
                foreach (var entry in group)
                {
-                    _currentItem = entry.FilePart.Header;
+                    currentItem = entry.FilePart.Header;
                    yield return entry;
                }
            }
        }

        protected override EntryStream GetEntryStream() =>
-            CreateEntryStream(
-                new ReadOnlySubStream(
-                    _currentStream.NotNull("currentStream is not null"),
-                    _currentItem?.Size ?? 0
-                )
-            );
+            CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
    }

    private class PasswordProvider : IPasswordProvider
    {
-        private readonly string? _password;
+        private readonly string _password;

-        public PasswordProvider(string? password) => _password = password;
+        public PasswordProvider(string password) => _password = password;

-        public string? CryptoGetTextPassword() => _password;
+        public string CryptoGetTextPassword() => _password;
    }
 }
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs
@@ -1,6 +1,4 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.SevenZip;

 namespace SharpCompress.Archives.SevenZip;
@@ -12,9 +10,6 @@ public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry

    public Stream OpenEntryStream() => FilePart.GetCompressedStream();

-    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        Task.FromResult(OpenEntryStream());
-
    public IArchive Archive { get; }

    public bool IsComplete => true;
--- a/src/SharpCompress/Archives/Tar/TarArchive.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchive.cs
@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
@@ -24,7 +22,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    /// <param name="readerOptions"></param>
    public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
    {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
    }

@@ -35,7 +33,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    /// <param name="readerOptions"></param>
    public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
    {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
        return new TarArchive(
            new SourceStream(
                fileInfo,
@@ -55,7 +53,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
        ReaderOptions? readerOptions = null
    )
    {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
        var files = fileInfos.ToArray();
        return new TarArchive(
            new SourceStream(
@@ -73,7 +71,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    /// <param name="readerOptions"></param>
    public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
    {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
        var strms = streams.ToArray();
        return new TarArchive(
            new SourceStream(
@@ -91,13 +89,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    /// <param name="readerOptions"></param>
    public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
+        stream.CheckNotNull(nameof(stream));
        return new TarArchive(
            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
        );
@@ -122,7 +114,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
            var tarHeader = new TarHeader(new ArchiveEncoding());
            var readSucceeded = tarHeader.Read(new BinaryReader(stream));
            var isEmptyArchive =
-                tarHeader.Name?.Length == 0
+                tarHeader.Name.Length == 0
                && tarHeader.Size == 0
                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
            return readSucceeded || isEmptyArchive;
@@ -131,20 +123,22 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
        return false;
    }

-    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
+    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
    {
-        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
-        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable(); //simple single volume or split, multivolume not supported
+        SrcStream.LoadAllParts(); //request all streams
+        var idx = 0;
+        return new TarVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
    }

    /// <summary>
    /// Constructor with a SourceStream able to handle FileInfo and Streams.
    /// </summary>
-    /// <param name="sourceStream"></param>
-    private TarArchive(SourceStream sourceStream)
-        : base(ArchiveType.Tar, sourceStream) { }
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal TarArchive(SourceStream srcStream)
+        : base(ArchiveType.Tar, srcStream) { }

-    private TarArchive()
+    internal TarArchive()
        : base(ArchiveType.Tar) { }

    protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
@@ -180,7 +174,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                        using (var entryStream = entry.OpenEntryStream())
                        {
                            using var memoryStream = new MemoryStream();
-                            entryStream.CopyTo(memoryStream);
+                            entryStream.TransferTo(memoryStream);
                            memoryStream.Position = 0;
                            var bytes = memoryStream.ToArray();

@@ -198,10 +192,6 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                    );
                }
            }
-            else
-            {
-                throw new IncompleteArchiveException("Failed to read TAR header");
-            }
        }
    }

@@ -224,11 +214,6 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
            closeStream
        );

-    protected override TarArchiveEntry CreateDirectoryEntry(
-        string directoryPath,
-        DateTime? modified
-    ) => new TarWritableArchiveEntry(this, directoryPath, modified);
-
    protected override void SaveTo(
        Stream stream,
        WriterOptions options,
@@ -237,62 +222,10 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    )
    {
        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
        {
-            if (entry.IsDirectory)
-            {
-                writer.WriteDirectory(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entry.LastModifiedTime
-                );
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                writer.Write(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entryStream,
-                    entry.LastModifiedTime,
-                    entry.Size
-                );
-            }
-        }
-    }
-
-    protected override async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TarArchiveEntry> oldEntries,
-        IEnumerable<TarArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
        }
    }

--- a/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;

@@ -9,14 +7,10 @@ namespace SharpCompress.Archives.Tar;

 public class TarArchiveEntry : TarEntry, IArchiveEntry
 {
-    internal TarArchiveEntry(TarArchive archive, TarFilePart? part, CompressionType compressionType)
+    internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
        : base(part, compressionType) => Archive = archive;

-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
-
-    public virtual Task<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => Task.FromResult(OpenEntryStream());
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();

    #region IArchiveEntry Members

--- a/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
@@ -1,3 +1,5 @@
+#nullable disable
+
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -9,8 +11,7 @@ namespace SharpCompress.Archives.Tar;
 internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
 {
    private readonly bool closeStream;
-    private readonly Stream? stream;
-    private readonly bool isDirectory;
+    private readonly Stream stream;

    internal TarWritableArchiveEntry(
        TarArchive archive,
@@ -28,22 +29,6 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
        Size = size;
        LastModifiedTime = lastModified;
        this.closeStream = closeStream;
-        isDirectory = false;
-    }
-
-    internal TarWritableArchiveEntry(
-        TarArchive archive,
-        string directoryPath,
-        DateTime? lastModified
-    )
-        : base(archive, null, CompressionType.None)
-    {
-        stream = null;
-        Key = directoryPath;
-        Size = 0;
-        LastModifiedTime = lastModified;
-        closeStream = false;
-        isDirectory = true;
    }

    public override long Crc => 0;
@@ -64,27 +49,23 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv

    public override bool IsEncrypted => false;

-    public override bool IsDirectory => isDirectory;
+    public override bool IsDirectory => false;

    public override bool IsSplitAfter => false;

    internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
-    Stream IWritableArchiveEntry.Stream => stream ?? Stream.Null;
+    Stream IWritableArchiveEntry.Stream => stream;

    public override Stream OpenEntryStream()
    {
-        if (stream is null)
-        {
-            return Stream.Null;
-        }
        //ensure new stream is at the start, this could be reset
        stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return NonDisposingStream.Create(stream);
    }

    internal override void Close()
    {
-        if (closeStream && stream is not null)
+        if (closeStream)
        {
            stream.Dispose();
        }
--- a/src/SharpCompress/Archives/Zip/ZipArchive.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchive.cs
@@ -2,8 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
@@ -18,7 +16,10 @@ namespace SharpCompress.Archives.Zip;

 public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
-    private readonly SeekableZipHeaderFactory? headerFactory;
+#nullable disable
+    private readonly SeekableZipHeaderFactory headerFactory;
+
+#nullable enable

    /// <summary>
    /// Gets or sets the compression level applied to files added to the archive,
@@ -29,13 +30,13 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    /// <summary>
    /// Constructor with a SourceStream able to handle FileInfo and Streams.
    /// </summary>
-    /// <param name="sourceStream"></param>
+    /// <param name="srcStream"></param>
    /// <param name="options"></param>
-    internal ZipArchive(SourceStream sourceStream)
-        : base(ArchiveType.Zip, sourceStream) =>
+    internal ZipArchive(SourceStream srcStream)
+        : base(ArchiveType.Zip, srcStream) =>
        headerFactory = new SeekableZipHeaderFactory(
-            sourceStream.ReaderOptions.Password,
-            sourceStream.ReaderOptions.ArchiveEncoding
+            srcStream.ReaderOptions.Password,
+            srcStream.ReaderOptions.ArchiveEncoding
        );

    /// <summary>
@@ -45,7 +46,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    /// <param name="readerOptions"></param>
    public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
    {
-        filePath.NotNullOrEmpty(nameof(filePath));
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
    }

@@ -56,7 +57,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    /// <param name="readerOptions"></param>
    public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
    {
-        fileInfo.NotNull(nameof(fileInfo));
+        fileInfo.CheckNotNull(nameof(fileInfo));
        return new ZipArchive(
            new SourceStream(
                fileInfo,
@@ -76,7 +77,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
        ReaderOptions? readerOptions = null
    )
    {
-        fileInfos.NotNull(nameof(fileInfos));
+        fileInfos.CheckNotNull(nameof(fileInfos));
        var files = fileInfos.ToArray();
        return new ZipArchive(
            new SourceStream(
@@ -94,7 +95,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    /// <param name="readerOptions"></param>
    public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
    {
-        streams.NotNull(nameof(streams));
+        streams.CheckNotNull(nameof(streams));
        var strms = streams.ToArray();
        return new ZipArchive(
            new SourceStream(
@@ -112,52 +113,30 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    /// <param name="readerOptions"></param>
    public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
    {
-        stream.NotNull(nameof(stream));
-
-        if (stream is not { CanSeek: true })
-        {
-            throw new ArgumentException("Stream must be seekable", nameof(stream));
-        }
-
+        stream.CheckNotNull(nameof(stream));
        return new ZipArchive(
            new SourceStream(stream, i => null, readerOptions ?? new 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);
@@ -177,20 +156,11 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
        }
    }

-    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);
@@ -219,21 +189,21 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
        }
    }

-    protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
+    protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream srcStream)
    {
-        stream.LoadAllParts(); //request all streams
-        stream.Position = 0;
+        SrcStream.LoadAllParts(); //request all streams
+        SrcStream.Position = 0;

-        var streams = stream.Streams.ToList();
+        var streams = SrcStream.Streams.ToList();
        var idx = 0;
-        if (streams.Count() > 1) //test part 2 - true = multipart not split
+        if (streams.Count > 1) //test part 2 - true = multipart not split
        {
            streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
-            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password);
            streams[1].Position -= 4;
            if (isZip)
            {
-                stream.IsVolumes = true;
+                SrcStream.IsVolumes = true;

                var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
                streams.RemoveAt(0);
@@ -245,7 +215,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
        }

        //split mode or single file
-        return new ZipVolume(stream, ReaderOptions, idx++).AsEnumerable();
+        return new ZipVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
    }

    internal ZipArchive()
@@ -254,13 +224,14 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
    {
        var vols = volumes.ToArray();
-        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
+        foreach (var h in headerFactory.ReadSeekableHeader(vols.Last().Stream))
        {
            if (h != null)
            {
                switch (h.ZipHeaderType)
                {
                    case ZipHeaderType.DirectoryEntry:
+
                        {
                            var deh = (DirectoryEntryHeader)h;
                            Stream s;
@@ -283,14 +254,14 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>

                            yield return new ZipArchiveEntry(
                                this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                                new SeekableZipFilePart(headerFactory, deh, s)
                            );
                        }
                        break;
                    case ZipHeaderType.DirectoryEnd:
                    {
                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                        vols.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                        volumes.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
                        yield break;
                    }
                }
@@ -308,59 +279,10 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    )
    {
        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
        {
-            if (entry.IsDirectory)
-            {
-                writer.WriteDirectory(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entry.LastModifiedTime
-                );
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                writer.Write(
-                    entry.Key.NotNull("Entry Key is null"),
-                    entryStream,
-                    entry.LastModifiedTime
-                );
-            }
-        }
-    }
-
-    protected override async Task SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<ZipArchiveEntry> oldEntries,
-        IEnumerable<ZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries))
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
        }
    }

@@ -372,17 +294,12 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
        bool closeStream
    ) => new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);

-    protected override ZipArchiveEntry CreateDirectoryEntry(
-        string directoryPath,
-        DateTime? modified
-    ) => new ZipWritableArchiveEntry(this, directoryPath, modified);
-
    public static ZipArchive Create() => new();

    protected override IReader CreateReaderForSolidExtraction()
    {
        var stream = Volumes.Single().Stream;
-        ((IStreamStack)stream).StackSeek(0);
+        stream.Position = 0;
        return ZipReader.Open(stream, ReaderOptions, Entries);
    }
 }
--- a/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
@@ -1,7 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip;

 namespace SharpCompress.Archives.Zip;
@@ -11,11 +9,7 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
    internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
        : base(part) => Archive = archive;

-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
-
-    public virtual Task<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    ) => Task.FromResult(OpenEntryStream());
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();

    #region IArchiveEntry Members

@@ -24,4 +18,6 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
    public bool IsComplete => true;

    #endregion
+
+    public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
 }
--- a/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
@@ -9,8 +9,7 @@ namespace SharpCompress.Archives.Zip;
 internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
 {
    private readonly bool closeStream;
-    private readonly Stream? stream;
-    private readonly bool isDirectory;
+    private readonly Stream stream;
    private bool isDisposed;

    internal ZipWritableArchiveEntry(
@@ -28,22 +27,6 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
        Size = size;
        LastModifiedTime = lastModified;
        this.closeStream = closeStream;
-        isDirectory = false;
-    }
-
-    internal ZipWritableArchiveEntry(
-        ZipArchive archive,
-        string directoryPath,
-        DateTime? lastModified
-    )
-        : base(archive, null)
-    {
-        stream = null;
-        Key = directoryPath;
-        Size = 0;
-        LastModifiedTime = lastModified;
-        closeStream = false;
-        isDirectory = true;
    }

    public override long Crc => 0;
@@ -64,28 +47,24 @@ internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry

    public override bool IsEncrypted => false;

-    public override bool IsDirectory => isDirectory;
+    public override bool IsDirectory => false;

    public override bool IsSplitAfter => false;

    internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();

-    Stream IWritableArchiveEntry.Stream => stream ?? Stream.Null;
+    Stream IWritableArchiveEntry.Stream => stream;

    public override Stream OpenEntryStream()
    {
-        if (stream is null)
-        {
-            return Stream.Null;
-        }
        //ensure new stream is at the start, this could be reset
        stream.Seek(0, SeekOrigin.Begin);
-        return SharpCompressStream.Create(stream, leaveOpen: true);
+        return NonDisposingStream.Create(stream);
    }

    internal override void Close()
    {
-        if (closeStream && !isDisposed && stream is not null)
+        if (closeStream && !isDisposed)
        {
            stream.Dispose();
            isDisposed = true;
--- a/src/SharpCompress/AssemblyInfo.cs
+++ b/src/SharpCompress/AssemblyInfo.cs
@@ -1,7 +1,3 @@
 using System;
-using System.Runtime.CompilerServices;

 [assembly: CLSCompliant(true)]
-[assembly: InternalsVisibleTo(
-    "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
-)]
--- a/src/SharpCompress/BufferPool.cs
+++ b/src/SharpCompress/BufferPool.cs
@@ -0,0 +1,33 @@
+using System.Buffers;
+
+namespace SharpCompress;
+
+internal static class BufferPool
+{
+    /// <summary>
+    ///     gets a buffer from the pool
+    /// </summary>
+    /// <param name="bufferSize">size of the buffer</param>
+    /// <returns>the buffer</returns>
+    public static byte[] Rent(int bufferSize)
+    {
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+        return ArrayPool<byte>.Shared.Rent(bufferSize);
+#else
+        return new byte[bufferSize];
+#endif
+    }
+
+    /// <summary>
+    ///     returns a buffer to the pool
+    /// </summary>
+    /// <param name="buffer">the buffer to return</param>
+    public static void Return(byte[] buffer)
+    {
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+        ArrayPool<byte>.Shared.Return(buffer);
+#else
+        // no-op
+#endif
+    }
+}
--- a/src/SharpCompress/Common/Arc/ArcEntry.cs
+++ b/src/SharpCompress/Common/Arc/ArcEntry.cs
@@ -1,60 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.GZip;
-using SharpCompress.Common.Tar;
-
-namespace SharpCompress.Common.Arc
-{
-    public class ArcEntry : Entry
-    {
-        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();
-    }
-}
--- a/src/SharpCompress/Common/Arc/ArcEntryHeader.cs
+++ b/src/SharpCompress/Common/Arc/ArcEntryHeader.cs
@@ -1,76 +0,0 @@
-using System;
-using System.IO;
-using System.Linq;
-using System.Text;
-
-namespace SharpCompress.Common.Arc
-{
-    public class ArcEntryHeader
-    {
-        public ArchiveEncoding 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(ArchiveEncoding archiveEncoding)
-        {
-            this.ArchiveEncoding = archiveEncoding;
-        }
-
-        public ArcEntryHeader? ReadHeader(Stream stream)
-        {
-            byte[] headerBytes = new byte[29];
-            if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
-            {
-                return null;
-            }
-            DataStartPosition = stream.Position;
-            return LoadFrom(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
-            {
-                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;
-        }
-    }
-}
--- a/src/SharpCompress/Common/Arc/ArcFilePart.cs
+++ b/src/SharpCompress/Common/Arc/ArcFilePart.cs
@@ -1,83 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.GZip;
-using SharpCompress.Common.Tar;
-using SharpCompress.Common.Tar.Headers;
-using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Compressors.Lzw;
-using SharpCompress.Compressors.RLE90;
-using SharpCompress.Compressors.Squeezed;
-using SharpCompress.IO;
-
-namespace SharpCompress.Common.Arc
-{
-    public class ArcFilePart : FilePart
-    {
-        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;
-    }
-}
--- a/src/SharpCompress/Common/Arc/ArcVolume.cs
+++ b/src/SharpCompress/Common/Arc/ArcVolume.cs
@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Common.Arc
-{
-    public class ArcVolume : Volume
-    {
-        public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
-    }
-}
--- a/src/SharpCompress/Common/ArchiveEncoding.cs
+++ b/src/SharpCompress/Common/ArchiveEncoding.cs
@@ -8,12 +8,12 @@ public class ArchiveEncoding
    /// <summary>
    /// Default encoding to use when archive format doesn't specify one.
    /// </summary>
-    public Encoding? Default { get; set; }
+    public Encoding Default { get; set; }

    /// <summary>
    /// ArchiveEncoding used by encryption schemes which don't comply with RFC 2898.
    /// </summary>
-    public Encoding? Password { get; set; }
+    public Encoding Password { get; set; }

    /// <summary>
    /// Set this encoding when you want to force it for all encoding operations.
@@ -50,8 +50,6 @@ public class ArchiveEncoding

    public Encoding GetEncoding() => Forced ?? Default ?? Encoding.UTF8;

-    public Encoding GetPasswordEncoding() => Password ?? Encoding.UTF8;
-
    public Func<byte[], int, int, string> GetDecoder() =>
        CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
 }
--- a/src/SharpCompress/Common/ArchiveException.cs
+++ b/src/SharpCompress/Common/ArchiveException.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class ArchiveException : Exception
+{
+    public ArchiveException(string message)
+        : base(message) { }
+}
--- a/src/SharpCompress/Common/ArchiveType.cs
+++ b/src/SharpCompress/Common/ArchiveType.cs
@@ -6,7 +6,5 @@ public enum ArchiveType
    Zip,
    Tar,
    SevenZip,
-    GZip,
-    Arc,
-    Arj,
+    GZip
 }
--- a/src/SharpCompress/Common/Arj/ArjEntry.cs
+++ b/src/SharpCompress/Common/Arj/ArjEntry.cs
@@ -1,58 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arc;
-using SharpCompress.Common.Arj.Headers;
-
-namespace SharpCompress.Common.Arj
-{
-    public class ArjEntry : Entry
-    {
-        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();
-    }
-}
--- a/src/SharpCompress/Common/Arj/ArjFilePart.cs
+++ b/src/SharpCompress/Common/Arj/ArjFilePart.cs
@@ -1,72 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Arj.Headers;
-using SharpCompress.Compressors.Arj;
-using SharpCompress.IO;
-
-namespace SharpCompress.Common.Arj
-{
-    public class ArjFilePart : FilePart
-    {
-        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;
-    }
-}
--- a/src/SharpCompress/Common/Arj/ArjVolume.cs
+++ b/src/SharpCompress/Common/Arj/ArjVolume.cs
@@ -1,36 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Rar;
-using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Common.Arj
-{
-    public class ArjVolume : Volume
-    {
-        public ArjVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
-            : base(stream, readerOptions, index) { }
-
-        public override bool IsFirstVolume
-        {
-            get { return true; }
-        }
-
-        /// <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>();
-        }
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/ArjHeader.cs
+++ b/src/SharpCompress/Common/Arj/Headers/ArjHeader.cs
@@ -1,142 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum ArjHeaderType
-    {
-        MainHeader,
-        LocalHeader,
-    }
-
-    public abstract class ArjHeader
-    {
-        private const int FIRST_HDR_SIZE = 34;
-        private const ushort ARJ_MAGIC = 0xEA60;
-
-        public ArjHeader(ArjHeaderType type)
-        {
-            ArjHeaderType = type;
-        }
-
-        public ArjHeaderType ArjHeaderType { get; }
-        public byte Flags { get; set; }
-        public FileType FileType { get; set; }
-
-        public abstract ArjHeader? Read(Stream reader);
-
-        public byte[] ReadHeader(Stream stream)
-        {
-            // check for magic bytes
-            Span<byte> magic = stackalloc byte[2];
-            if (stream.Read(magic) != 2)
-            {
-                return Array.Empty<byte>();
-            }
-
-            var magicValue = (ushort)(magic[0] | magic[1] << 8);
-            if (magicValue != ARJ_MAGIC)
-            {
-                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;
-        }
-
-        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;
-        }
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.cs
+++ b/src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.cs
@@ -1,161 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public class ArjLocalHeader : ArjHeader
-    {
-        public ArchiveEncoding ArchiveEncoding { get; }
-        public long DataStartPosition { get; protected set; }
-
-        public byte ArchiverVersionNumber { get; set; }
-        public byte MinVersionToExtract { get; set; }
-        public HostOS HostOS { get; set; }
-        public CompressionMethod CompressionMethod { get; set; }
-        public DosDateTime DateTimeModified { get; set; } = new DosDateTime(0);
-        public long CompressedSize { get; set; }
-        public long OriginalSize { get; set; }
-        public long OriginalCrc32 { get; set; }
-        public int FileSpecPosition { get; set; }
-        public int FileAccessMode { get; set; }
-        public byte FirstChapter { get; set; }
-        public byte LastChapter { get; set; }
-        public long ExtendedFilePosition { get; set; }
-        public DosDateTime DateTimeAccessed { get; set; } = new DosDateTime(0);
-        public DosDateTime DateTimeCreated { get; set; } = new DosDateTime(0);
-        public long OriginalSizeEvenForVolumes { get; set; }
-        public string Name { get; set; } = string.Empty;
-        public string Comment { get; set; } = string.Empty;
-
-        private const byte StdHdrSize = 30;
-        private const byte R9HdrSize = 46;
-
-        public ArjLocalHeader(ArchiveEncoding archiveEncoding)
-            : base(ArjHeaderType.LocalHeader)
-        {
-            ArchiveEncoding =
-                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
-        }
-
-        public override ArjHeader? Read(Stream stream)
-        {
-            var body = ReadHeader(stream);
-            if (body.Length > 0)
-            {
-                ReadExtendedHeaders(stream);
-                var header = LoadFrom(body);
-                header.DataStartPosition = stream.Position;
-                return header;
-            }
-            return null;
-        }
-
-        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;
-            }
-
-            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,
-            };
-        }
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/ArjMainHeader.cs
+++ b/src/SharpCompress/Common/Arj/Headers/ArjMainHeader.cs
@@ -1,138 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using SharpCompress.Compressors.Deflate;
-using SharpCompress.Crypto;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public 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)
-        {
-            ArchiveEncoding =
-                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
-        }
-
-        public override ArjHeader? Read(Stream stream)
-        {
-            var body = ReadHeader(stream);
-            ReadExtendedHeaders(stream);
-            return LoadFrom(body);
-        }
-
-        public ArjMainHeader LoadFrom(byte[] headerBytes)
-        {
-            var offset = 1;
-
-            byte ReadByte()
-            {
-                if (offset >= headerBytes.Length)
-                {
-                    throw new EndOfStreamException();
-                }
-                return (byte)(headerBytes[offset++] & 0xFF);
-            }
-
-            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;
-            }
-            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
-                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();
-
-            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;
-        }
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/CompressionMethod.cs
+++ b/src/SharpCompress/Common/Arj/Headers/CompressionMethod.cs
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum CompressionMethod
-    {
-        Stored = 0,
-        CompressedMost = 1,
-        Compressed = 2,
-        CompressedFaster = 3,
-        CompressedFastest = 4,
-        NoDataNoCrc = 8,
-        NoData = 9,
-        Unknown,
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/DosDateTime.cs
+++ b/src/SharpCompress/Common/Arj/Headers/DosDateTime.cs
@@ -1,37 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Arj.Headers
-{
-    public class DosDateTime
-    {
-        public DateTime DateTime { get; }
-
-        public DosDateTime(long dosValue)
-        {
-            // 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;
-            }
-        }
-
-        public override string ToString() => DateTime.ToString("yyyy-MM-dd HH:mm:ss");
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/FileType.cs
+++ b/src/SharpCompress/Common/Arj/Headers/FileType.cs
@@ -1,13 +0,0 @@
-namespace SharpCompress.Common.Arj.Headers
-{
-    public enum FileType : byte
-    {
-        Binary = 0,
-        Text7Bit = 1,
-        CommentHeader = 2,
-        Directory = 3,
-        VolumeLabel = 4,
-        ChapterLabel = 5,
-        Unknown = 255,
-    }
-}
--- a/src/SharpCompress/Common/Arj/Headers/HostOS.cs
+++ b/src/SharpCompress/Common/Arj/Headers/HostOS.cs
@@ -1,19 +0,0 @@
-namespace SharpCompress.Common.Arj.Headers
-{
-    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,
-    }
-}
--- a/src/SharpCompress/Common/CompressionType.cs
+++ b/src/SharpCompress/Common/CompressionType.cs
@@ -16,18 +16,5 @@ public enum CompressionType
    Unknown,
    Deflate64,
    Shrink,
-    Lzw,
-    Reduce1,
-    Reduce2,
-    Reduce3,
-    Reduce4,
-    Explode,
-    Squeezed,
-    Packed,
-    Crunched,
-    Squashed,
-    Crushed,
-    Distilled,
-    ZStandard,
-    ArjLZ77,
+    Lzw
 }
--- a/src/SharpCompress/Common/CryptographicException.cs
+++ b/src/SharpCompress/Common/CryptographicException.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class CryptographicException : Exception
+{
+    public CryptographicException(string message)
+        : base(message) { }
+}
--- a/src/SharpCompress/Common/Entry.cs
+++ b/src/SharpCompress/Common/Entry.cs
@@ -14,7 +14,7 @@ public abstract class Entry : IEntry
    /// <summary>
    /// The string key of the file internal to the Archive.
    /// </summary>
-    public abstract string? Key { get; }
+    public abstract string Key { get; }

    /// <summary>
    /// The target of a symlink entry internal to the Archive. Will be null if not a symlink.
@@ -71,11 +71,11 @@ public abstract class Entry : IEntry
    /// </summary>
    public abstract bool IsSplitAfter { get; }

-    public int VolumeIndexFirst => Parts.FirstOrDefault()?.Index ?? 0;
-    public int VolumeIndexLast => Parts.LastOrDefault()?.Index ?? 0;
+    public int VolumeIndexFirst => Parts?.FirstOrDefault()?.Index ?? 0;
+    public int VolumeIndexLast => Parts?.LastOrDefault()?.Index ?? 0;

    /// <inheritdoc/>
-    public override string ToString() => Key ?? "Entry";
+    public override string ToString() => Key;

    internal abstract IEnumerable<FilePart> Parts { get; }

--- a/src/SharpCompress/Common/EntryStream.cs
+++ b/src/SharpCompress/Common/EntryStream.cs
@@ -1,35 +1,11 @@
 using System;
 using System.IO;
-using System.IO.Compression;
-using System.Threading;
-using System.Threading.Tasks;
-using SharpCompress.IO;
 using SharpCompress.Readers;

 namespace SharpCompress.Common;

-public class EntryStream : Stream, IStreamStack
+public 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 +15,6 @@ public class EntryStream : Stream, IStreamStack
    {
        _reader = reader;
        _stream = stream;
-#if DEBUG_STREAMS
-        this.DebugConstruct(typeof(EntryStream));
-#endif
    }

    /// <summary>
@@ -53,78 +26,20 @@ public class EntryStream : Stream, IStreamStack
        _completed = true;
    }

-    /// <summary>
-    /// Asynchronously skip the rest of the entry stream.
-    /// </summary>
-    public async Task SkipEntryAsync(CancellationToken cancellationToken = default)
-    {
-        await this.SkipAsync(cancellationToken).ConfigureAwait(false);
-        _completed = true;
-    }
-
    protected override void Dispose(bool disposing)
    {
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
        if (!(_completed || _reader.Cancelled))
        {
            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)
-            {
-                deflateStream.Flush(); //Deflate over reads. Knock it back
-            }
-            else if (ss.BaseStream() 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();
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask DisposeAsync()
-    {
        if (_isDisposed)
        {
            return;
        }
        _isDisposed = true;
-        if (!(_completed || _reader.Cancelled))
-        {
-            await SkipEntryAsync().ConfigureAwait(false);
-        }
-
-        //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)
-            {
-                await deflateStream.FlushAsync().ConfigureAwait(false);
-            }
-            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
-            {
-                await lzmaStream.FlushAsync().ConfigureAwait(false);
-            }
-        }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(EntryStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-        await _stream.DisposeAsync().ConfigureAwait(false);
+        base.Dispose(disposing);
+        _stream.Dispose();
    }
-#endif

    public override bool CanRead => true;

@@ -134,13 +49,11 @@ public class EntryStream : Stream, IStreamStack

    public override void Flush() { }

-    public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask;
-
    public override long Length => _stream.Length;

    public override long Position
    {
-        get => _stream.Position; //throw new NotSupportedException();
+        get => throw new NotSupportedException();
        set => throw new NotSupportedException();
    }

@@ -154,38 +67,6 @@ public class EntryStream : Stream, IStreamStack
        return read;
    }

-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        var read = await _stream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (read <= 0)
-        {
-            _completed = true;
-        }
-        return read;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var read = await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-        if (read <= 0)
-        {
-            _completed = true;
-        }
-        return read;
-    }
-#endif
-
    public override int ReadByte()
    {
        var value = _stream.ReadByte();
@@ -202,11 +83,4 @@ public class EntryStream : Stream, IStreamStack

    public override void Write(byte[] buffer, int offset, int count) =>
        throw new NotSupportedException();
-
-    public override Task WriteAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    ) => throw new NotSupportedException();
 }
--- a/src/SharpCompress/Common/ExtractionException.cs
+++ b/src/SharpCompress/Common/ExtractionException.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class ExtractionException : Exception
+{
+    public ExtractionException(string message)
+        : base(message) { }
+
+    public ExtractionException(string message, Exception inner)
+        : base(message, inner) { }
+}
--- a/src/SharpCompress/Common/ExtractionMethods.cs
+++ b/src/SharpCompress/Common/ExtractionMethods.cs
@@ -1,22 +1,10 @@
 using System;
 using System.IO;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;

 namespace SharpCompress.Common;

 internal static class ExtractionMethods
 {
-    /// <summary>
-    /// Gets the appropriate StringComparison for path checks based on the file system.
-    /// Windows uses case-insensitive file systems, while Unix-like systems use case-sensitive file systems.
-    /// </summary>
-    private static StringComparison PathComparison =>
-        RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-            ? StringComparison.OrdinalIgnoreCase
-            : StringComparison.Ordinal;
-
    /// <summary>
    /// Extract to specific directory, retaining filename
    /// </summary>
@@ -48,17 +36,15 @@ internal static 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);
+        var file = Path.GetFileName(entry.Key);
        if (options.ExtractFullPath)
        {
-            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
-                .NotNull("Directory is null");
+            var folder = Path.GetDirectoryName(entry.Key)!;
            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));

            if (!Directory.Exists(destdir))
            {
-                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
+                if (!destdir.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
                {
                    throw new ExtractionException(
                        "Entry is trying to create a directory outside of the destination directory."
@@ -78,7 +64,12 @@ internal static class ExtractionMethods
        {
            destinationFileName = Path.GetFullPath(destinationFileName);

-            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
+            if (
+                !destinationFileName.StartsWith(
+                    fullDestinationDirectoryPath,
+                    StringComparison.Ordinal
+                )
+            )
            {
                throw new ExtractionException(
                    "Entry is trying to write a file outside of the destination directory."
@@ -123,110 +114,4 @@ internal static class ExtractionMethods
            entry.PreserveExtractionOptions(destinationFileName, options);
        }
    }
-
-    public static async Task WriteEntryToDirectoryAsync(
-        IEntry entry,
-        string destinationDirectory,
-        ExtractionOptions? options,
-        Func<string, ExtractionOptions?, Task> writeAsync,
-        CancellationToken cancellationToken = default
-    )
-    {
-        string destinationFileName;
-        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
-
-        //check for trailing slash.
-        if (
-            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
-            != Path.DirectorySeparatorChar
-        )
-        {
-            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
-        }
-
-        if (!Directory.Exists(fullDestinationDirectoryPath))
-        {
-            throw new ExtractionException(
-                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
-            );
-        }
-
-        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)
-        {
-            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
-                .NotNull("Directory is null");
-            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
-
-            if (!Directory.Exists(destdir))
-            {
-                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
-                {
-                    throw new ExtractionException(
-                        "Entry is trying to create a directory outside of the destination directory."
-                    );
-                }
-
-                Directory.CreateDirectory(destdir);
-            }
-            destinationFileName = Path.Combine(destdir, file);
-        }
-        else
-        {
-            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
-        }
-
-        if (!entry.IsDirectory)
-        {
-            destinationFileName = Path.GetFullPath(destinationFileName);
-
-            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
-            {
-                throw new ExtractionException(
-                    "Entry is trying to write a file outside of the destination directory."
-                );
-            }
-            await writeAsync(destinationFileName, options).ConfigureAwait(false);
-        }
-        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
-        {
-            Directory.CreateDirectory(destinationFileName);
-        }
-    }
-
-    public static async Task WriteEntryToFileAsync(
-        IEntry entry,
-        string destinationFileName,
-        ExtractionOptions? options,
-        Func<string, FileMode, Task> openAndWriteAsync,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (entry.LinkTarget != null)
-        {
-            if (options?.WriteSymbolicLink is null)
-            {
-                throw new ExtractionException(
-                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
-                );
-            }
-            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
-        }
-        else
-        {
-            var fm = FileMode.Create;
-            options ??= new ExtractionOptions() { Overwrite = true };
-
-            if (!options.Overwrite)
-            {
-                fm = FileMode.CreateNew;
-            }
-
-            await openAndWriteAsync(destinationFileName, fm).ConfigureAwait(false);
-            entry.PreserveExtractionOptions(destinationFileName, options);
-        }
-    }
 }
--- a/src/SharpCompress/Common/FilePart.cs
+++ b/src/SharpCompress/Common/FilePart.cs
@@ -8,10 +8,10 @@ public abstract class FilePart

    internal ArchiveEncoding ArchiveEncoding { get; }

-    internal abstract string? FilePartName { get; }
+    internal abstract string FilePartName { get; }
    public int Index { get; set; }

-    internal abstract Stream? GetCompressedStream();
+    internal abstract Stream GetCompressedStream();
    internal abstract Stream? GetRawStream();
    internal bool Skipped { get; set; }
 }
--- a/src/SharpCompress/Common/GZip/GZipEntry.cs
+++ b/src/SharpCompress/Common/GZip/GZipEntry.cs
@@ -6,23 +6,23 @@ namespace SharpCompress.Common.GZip;

 public class GZipEntry : Entry
 {
-    private readonly GZipFilePart? _filePart;
+    private readonly GZipFilePart _filePart;

-    internal GZipEntry(GZipFilePart? filePart) => _filePart = filePart;
+    internal GZipEntry(GZipFilePart filePart) => _filePart = filePart;

    public override CompressionType CompressionType => CompressionType.GZip;

-    public override long Crc => _filePart?.Crc ?? 0;
+    public override long Crc => _filePart.Crc ?? 0;

-    public override string? Key => _filePart?.FilePartName;
+    public override string Key => _filePart.FilePartName;

    public override string? LinkTarget => null;

    public override long CompressedSize => 0;

-    public override long Size => _filePart?.UncompressedSize ?? 0;
+    public override long Size => _filePart.UncompressedSize ?? 0;

-    public override DateTime? LastModifiedTime => _filePart?.DateModified;
+    public override DateTime? LastModifiedTime => _filePart.DateModified;

    public override DateTime? CreatedTime => null;

@@ -36,7 +36,7 @@ public class GZipEntry : Entry

    public override bool IsSplitAfter => false;

-    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+    internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();

    internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
    {
--- a/src/SharpCompress/Common/GZip/GZipFilePart.cs
+++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs
@@ -24,14 +24,8 @@ internal sealed class GZipFilePart : FilePart
            stream.Position = stream.Length - 8;
            ReadTrailer();
            stream.Position = position;
-            EntryStartPosition = position;
-        }
-        else
-        {
-            // For non-seekable streams, we can't read the trailer or track position.
-            // Set to 0 since the stream will be read sequentially from its current position.
-            EntryStartPosition = 0;
        }
+        EntryStartPosition = stream.Position;
    }

    internal long EntryStartPosition { get; }
@@ -40,7 +34,7 @@ internal sealed class GZipFilePart : FilePart
    internal uint? Crc { get; private set; }
    internal uint? UncompressedSize { get; private set; }

-    internal override string? FilePartName => _name;
+    internal override string FilePartName => _name!;

    internal override Stream GetCompressedStream() =>
        new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
--- a/src/SharpCompress/Common/GZip/GZipVolume.cs
+++ b/src/SharpCompress/Common/GZip/GZipVolume.cs
@@ -5,7 +5,7 @@ namespace SharpCompress.Common.GZip;

 public class GZipVolume : Volume
 {
-    public GZipVolume(Stream stream, ReaderOptions? options, int index)
+    public GZipVolume(Stream stream, ReaderOptions options, int index = 0)
        : base(stream, options, index) { }

    public GZipVolume(FileInfo fileInfo, ReaderOptions options)
--- a/src/SharpCompress/Common/IEntry.cs
+++ b/src/SharpCompress/Common/IEntry.cs
@@ -9,7 +9,7 @@ public interface IEntry
    long CompressedSize { get; }
    long Crc { get; }
    DateTime? CreatedTime { get; }
-    string? Key { get; }
+    string Key { get; }
    string? LinkTarget { get; }
    bool IsDirectory { get; }
    bool IsEncrypted { get; }
--- a/src/SharpCompress/Common/IVolume.cs
+++ b/src/SharpCompress/Common/IVolume.cs
@@ -6,5 +6,5 @@ public interface IVolume : IDisposable
 {
    int Index { get; }

-    string? FileName { get; }
+    string FileName { get; }
 }
--- a/src/SharpCompress/Common/IncompleteArchiveException.cs
+++ b/src/SharpCompress/Common/IncompleteArchiveException.cs
@@ -0,0 +1,7 @@
+namespace SharpCompress.Common;
+
+public class IncompleteArchiveException : ArchiveException
+{
+    public IncompleteArchiveException(string message)
+        : base(message) { }
+}
--- a/src/SharpCompress/Common/InvalidFormatException.cs
+++ b/src/SharpCompress/Common/InvalidFormatException.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class InvalidFormatException : ExtractionException
+{
+    public InvalidFormatException(string message)
+        : base(message) { }
+
+    public InvalidFormatException(string message, Exception inner)
+        : base(message, inner) { }
+}
--- a/src/SharpCompress/Common/MultiVolumeExtractionException.cs
+++ b/src/SharpCompress/Common/MultiVolumeExtractionException.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class MultiVolumeExtractionException : ExtractionException
+{
+    public MultiVolumeExtractionException(string message)
+        : base(message) { }
+
+    public MultiVolumeExtractionException(string message, Exception inner)
+        : base(message, inner) { }
+}
--- a/src/SharpCompress/Common/MultipartStreamRequiredException.cs
+++ b/src/SharpCompress/Common/MultipartStreamRequiredException.cs
@@ -0,0 +1,7 @@
+namespace SharpCompress.Common;
+
+public class MultipartStreamRequiredException : ExtractionException
+{
+    public MultipartStreamRequiredException(string message)
+        : base(message) { }
+}
--- a/src/SharpCompress/Common/Rar/CryptKey5.cs
+++ b/src/SharpCompress/Common/Rar/CryptKey5.cs
@@ -17,7 +17,7 @@ internal class CryptKey5 : ICryptKey
    private byte[] _pswCheck = { };
    private byte[] _hashKey = { };

-    public CryptKey5(string? password, Rar5CryptoInfo rar5CryptoInfo)
+    public CryptKey5(string password, Rar5CryptoInfo rar5CryptoInfo)
    {
        _password = password ?? "";
        _cryptoInfo = rar5CryptoInfo;
--- a/src/SharpCompress/Common/Rar/Headers/ArchiveCryptHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/ArchiveCryptHeader.cs
@@ -1,5 +1,8 @@
 #nullable disable

+using System;
+using System.Security.Cryptography;
+using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Rar.Headers;
--- a/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
@@ -1,6 +1,9 @@
+#nullable disable
+
 using System;
 using System.IO;
 using System.Linq;
+using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.IO;
 #if !Rar2017_64bit
@@ -15,7 +18,7 @@ namespace SharpCompress.Common.Rar.Headers;

 internal class FileHeader : RarHeader
 {
-    private byte[]? _hash;
+    private byte[] _hash;

    public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
        : base(header, reader, headerType) { }
@@ -118,6 +121,7 @@ internal class FileHeader : RarHeader
            switch (type)
            {
                case FHEXTRA_CRYPT: // file encryption
+
                    {
                        Rar5CryptoInfo = new Rar5CryptoInfo(reader, true);

@@ -128,6 +132,7 @@ internal class FileHeader : RarHeader
                    }
                    break;
                case FHEXTRA_HASH:
+
                    {
                        const uint FHEXTRA_HASH_BLAKE2 = 0x0;
                        //                        const uint HASH_BLAKE2 = 0x03;
@@ -141,6 +146,7 @@ internal class FileHeader : RarHeader
                    }
                    break;
                case FHEXTRA_HTIME: // file time
+
                    {
                        var flags = reader.ReadRarVIntUInt16();
                        var isWindowsTime = (flags & 1) == 0;
@@ -165,6 +171,7 @@ internal class FileHeader : RarHeader
                //                        }
                //                        break;
                case FHEXTRA_REDIR: // file system redirection
+
                    {
                        RedirType = reader.ReadRarVIntByte();
                        RedirFlags = reader.ReadRarVIntByte();
@@ -277,6 +284,7 @@ internal class FileHeader : RarHeader
        switch (HeaderCode)
        {
            case HeaderCodeV.RAR4_FILE_HEADER:
+
                {
                    if (HasFlag(FileFlagsV4.UNICODE))
                    {
@@ -303,6 +311,7 @@ internal class FileHeader : RarHeader
                }
                break;
            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+
                {
                    var datasize = HeaderSize - newLhdSize - nameSize;
                    if (HasFlag(FileFlagsV4.SALT))
@@ -316,10 +325,6 @@ internal class FileHeader : RarHeader

                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
                    {
-                        if (SubData is null)
-                        {
-                            throw new InvalidFormatException();
-                        }
                        RecoverySectors =
                            SubData[8]
                            + (SubData[9] << 8)
@@ -341,16 +346,12 @@ internal class FileHeader : RarHeader
            if (RemainingHeaderBytes(reader) >= 2)
            {
                var extendedFlags = reader.ReadUInt16();
-                if (FileLastModifiedTime is not null)
-                {
-                    FileLastModifiedTime = ProcessExtendedTimeV4(
-                        extendedFlags,
-                        FileLastModifiedTime,
-                        reader,
-                        0
-                    );
-                }
-
+                FileLastModifiedTime = ProcessExtendedTimeV4(
+                    extendedFlags,
+                    FileLastModifiedTime,
+                    reader,
+                    0
+                );
                FileCreatedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
                FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
                FileArchivedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
@@ -382,7 +383,7 @@ internal class FileHeader : RarHeader
            var dosTime = reader.ReadUInt32();
            time = Utility.DosDateToDateTime(dosTime);
        }
-        if ((rmode & 4) == 0 && time is not null)
+        if ((rmode & 4) == 0)
        {
            time = time.Value.AddSeconds(1);
        }
@@ -395,11 +396,7 @@ internal class FileHeader : RarHeader
        }

        //10^-7 to 10^-3
-        if (time is not null)
-        {
-            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
-        }
-        return null;
+        return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
    }

    private static string ConvertPathV4(string path)
@@ -415,13 +412,13 @@ internal class FileHeader : RarHeader
        return path;
    }

-    public override string ToString() => FileName ?? "FileHeader";
+    public override string ToString() => FileName;

    private ushort Flags { get; set; }

    private bool HasFlag(ushort flag) => (Flags & flag) == flag;

-    internal byte[]? FileCrc
+    internal byte[] FileCrc
    {
        get => _hash;
        private set => _hash = value;
@@ -450,22 +447,22 @@ internal class FileHeader : RarHeader
    public bool IsRedir => RedirType != 0;
    public byte RedirFlags { get; private set; }
    public bool IsRedirDirectory => (RedirFlags & RedirFlagV5.DIRECTORY) != 0;
-    public string? RedirTargetName { get; private set; }
+    public string RedirTargetName { get; private set; }

    // unused for UnpackV1 implementation (limitation)
    internal size_t WindowSize { get; private set; }

-    internal byte[]? R4Salt { get; private set; }
-    internal Rar5CryptoInfo? Rar5CryptoInfo { get; private set; }
+    internal byte[] R4Salt { get; private set; }
+    internal Rar5CryptoInfo Rar5CryptoInfo { get; private set; }
    private byte HostOs { get; set; }
    internal uint FileAttributes { get; private set; }
    internal long CompressedSize { get; private set; }
    internal long UncompressedSize { get; private set; }
-    internal string? FileName { get; private set; }
-    internal byte[]? SubData { get; private set; }
+    internal string FileName { get; private set; }
+    internal byte[] SubData { get; private set; }
    internal int RecoverySectors { get; private set; }
    internal long DataStartPosition { get; set; }
-    public Stream? PackedStream { get; set; }
+    public Stream PackedStream { get; set; }

    public bool IsSplitBefore =>
        IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_BEFORE) : HasFlag(FileFlagsV4.SPLIT_BEFORE);
--- a/src/SharpCompress/Common/Rar/Headers/Flags.cs
+++ b/src/SharpCompress/Common/Rar/Headers/Flags.cs
@@ -13,7 +13,7 @@ public enum HeaderType : byte
    Sign,
    NewSub,
    EndArchive,
-    Crypt,
+    Crypt
 }

 internal static class HeaderCodeV
--- a/src/SharpCompress/Common/Rar/Headers/RarHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/RarHeader.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Rar.Headers;
@@ -20,7 +21,7 @@ internal class RarHeader : IRarHeader
        {
            return new RarHeader(reader, isRar5, archiveEncoding);
        }
-        catch (InvalidFormatException)
+        catch (EndOfStreamException)
        {
            return null;
        }
--- a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
+++ b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 using SharpCompress.Readers;

@@ -96,11 +98,13 @@ public class RarHeaderFactory
                switch (StreamingMode)
                {
                    case StreamingMode.Seekable:
+
                        {
                            reader.BaseStream.Position += ph.DataSize;
                        }
                        break;
                    case StreamingMode.Streaming:
+
                        {
                            reader.BaseStream.Skip(ph.DataSize);
                        }
@@ -142,12 +146,14 @@ public class RarHeaderFactory
                switch (StreamingMode)
                {
                    case StreamingMode.Seekable:
+
                        {
                            fh.DataStartPosition = reader.BaseStream.Position;
                            reader.BaseStream.Position += fh.CompressedSize;
                        }
                        break;
                    case StreamingMode.Streaming:
+
                        {
                            var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
                            if (fh.R4Salt is null && fh.Rar5CryptoInfo is null)
@@ -158,15 +164,10 @@ public class RarHeaderFactory
                            {
                                fh.PackedStream = new RarCryptoWrapper(
                                    ms,
+                                    fh.R4Salt is null ? fh.Rar5CryptoInfo.Salt : fh.R4Salt,
                                    fh.R4Salt is null
-                                        ? fh.Rar5CryptoInfo.NotNull().Salt
-                                        : fh.R4Salt,
-                                    fh.R4Salt is null
-                                        ? new CryptKey5(
-                                            Options.Password,
-                                            fh.Rar5CryptoInfo.NotNull()
-                                        )
-                                        : new CryptKey3(Options.Password)
+                                        ? new CryptKey5(Options.Password!, fh.Rar5CryptoInfo)
+                                        : new CryptKey3(Options.Password!)
                                );
                            }
                        }
@@ -203,12 +204,14 @@ public class RarHeaderFactory
        switch (StreamingMode)
        {
            case StreamingMode.Seekable:
+
                {
                    fh.DataStartPosition = reader.BaseStream.Position;
                    reader.BaseStream.Position += fh.CompressedSize;
                }
                break;
            case StreamingMode.Streaming:
+
                {
                    //skip the data because it's useless?
                    reader.BaseStream.Skip(fh.CompressedSize);
--- a/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
@@ -70,11 +70,11 @@ internal sealed class RarCryptoWrapper : Stream

    protected override void Dispose(bool disposing)
    {
-        if (disposing)
+        if (_rijndael != null)
        {
            _rijndael.Dispose();
+            _rijndael = null!;
        }
-
        base.Dispose(disposing);
    }
 }
--- a/src/SharpCompress/Common/Rar/RarEntry.cs
+++ b/src/SharpCompress/Common/Rar/RarEntry.cs
@@ -20,12 +20,12 @@ public abstract class RarEntry : Entry
    /// <summary>
    /// The File's 32 bit CRC Hash
    /// </summary>
-    public override long Crc => BitConverter.ToUInt32(FileHeader.FileCrc.NotNull(), 0);
+    public override long Crc => BitConverter.ToUInt32(FileHeader.FileCrc, 0);

    /// <summary>
    /// The path of the file internal to the Rar Archive.
    /// </summary>
-    public override string? Key => FileHeader.FileName;
+    public override string Key => FileHeader.FileName;

    public override string? LinkTarget => null;

@@ -68,7 +68,7 @@ public abstract class RarEntry : Entry

    public bool IsRedir => FileHeader.IsRedir;

-    public string? RedirTargetName => FileHeader.RedirTargetName;
+    public string RedirTargetName => FileHeader.RedirTargetName;

    public override string ToString() =>
        string.Format(
--- a/src/SharpCompress/Common/Rar/RarVolume.cs
+++ b/src/SharpCompress/Common/Rar/RarVolume.cs
@@ -15,14 +15,17 @@ namespace SharpCompress.Common.Rar;
 public abstract class RarVolume : Volume
 {
    private readonly RarHeaderFactory _headerFactory;
-    private int _maxCompressionAlgorithm;
+    internal int _maxCompressionAlgorithm;

-    internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options, int index)
+    internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options, int index = 0)
        : base(stream, options, index) => _headerFactory = new RarHeaderFactory(mode, options);

-    private ArchiveHeader? ArchiveHeader { get; set; }
+#nullable disable
+    internal ArchiveHeader ArchiveHeader { get; private set; }

-    private StreamingMode Mode => _headerFactory.StreamingMode;
+#nullable enable
+
+    internal StreamingMode Mode => _headerFactory.StreamingMode;

    internal abstract IEnumerable<RarFilePart> ReadFileParts();

@@ -36,16 +39,19 @@ public abstract class RarVolume : Volume
            switch (header.HeaderType)
            {
                case HeaderType.Mark:
+
                    {
                        lastMarkHeader = (MarkHeader)header;
                    }
                    break;
                case HeaderType.Archive:
+
                    {
                        ArchiveHeader = (ArchiveHeader)header;
                    }
                    break;
                case HeaderType.File:
+
                    {
                        var fh = (FileHeader)header;
                        if (_maxCompressionAlgorithm < fh.CompressionAlgorithm)
@@ -57,12 +63,14 @@ public abstract class RarVolume : Volume
                    }
                    break;
                case HeaderType.Service:
+
                    {
                        var fh = (FileHeader)header;
                        if (fh.FileName == "CMT")
                        {
+                            var part = CreateFilePart(lastMarkHeader!, fh);
                            var buffer = new byte[fh.CompressedSize];
-                            fh.PackedStream.NotNull().ReadFully(buffer);
+                            part.GetCompressedStream().Read(buffer, 0, buffer.Length);
                            Comment = Encoding.UTF8.GetString(buffer, 0, buffer.Length - 1);
                        }
                    }
@@ -97,7 +105,7 @@ public abstract class RarVolume : Volume
        get
        {
            EnsureArchiveHeaderLoaded();
-            return ArchiveHeader?.IsFirstVolume ?? false;
+            return ArchiveHeader.IsFirstVolume;
        }
    }

@@ -109,7 +117,7 @@ public abstract class RarVolume : Volume
        get
        {
            EnsureArchiveHeaderLoaded();
-            return ArchiveHeader?.IsVolume ?? false;
+            return ArchiveHeader.IsVolume;
        }
    }

@@ -122,7 +130,7 @@ public abstract class RarVolume : Volume
        get
        {
            EnsureArchiveHeaderLoaded();
-            return ArchiveHeader?.IsSolid ?? false;
+            return ArchiveHeader.IsSolid;
        }
    }

--- a/src/SharpCompress/Common/ReaderCancelledException.cs
+++ b/src/SharpCompress/Common/ReaderCancelledException.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace SharpCompress.Common;
+
+public class ReaderCancelledException : Exception
+{
+    public ReaderCancelledException(string message)
+        : base(message) { }
+
+    public ReaderCancelledException(string message, Exception inner)
+        : base(message, inner) { }
+}
--- a/src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs
@@ -35,7 +35,7 @@ internal class ArchiveDatabase
        _packSizes.Clear();
        _packCrCs.Clear();
        _folders.Clear();
-        _numUnpackStreamsVector = null;
+        _numUnpackStreamsVector = null!;
        _files.Clear();

        _packStreamStartPositions.Clear();
--- a/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
@@ -784,7 +784,7 @@ internal class ArchiveReader
                        );
                        break;
                    default:
-                        throw new InvalidFormatException();
+                        throw new InvalidOperationException();
                }
            }
        }
@@ -843,7 +843,7 @@ internal class ArchiveReader
                outStream.ReadExact(data, 0, data.Length);
                if (outStream.ReadByte() >= 0)
                {
-                    throw new InvalidFormatException("Decoded stream is longer than expected.");
+                    throw new InvalidOperationException("Decoded stream is longer than expected.");
                }
                dataVector.Add(data);

@@ -854,7 +854,7 @@ internal class ArchiveReader
                        != folder._unpackCrc
                    )
                    {
-                        throw new InvalidFormatException(
+                        throw new InvalidOperationException(
                            "Decoded stream does not match expected CRC."
                        );
                    }
@@ -996,11 +996,6 @@ internal class ArchiveReader
                            numFiles,
                            delegate(int i, uint? attr)
                            {
-                                // Keep the original attribute value because it could potentially get
-                                // modified in the logic that follows. Some callers of the library may
-                                // find the original value useful.
-                                db._files[i].ExtendedAttrib = attr;
-
                                // Some third party implementations established an unofficial extension
                                // of the 7z archive format by placing posix file attributes in the high
                                // bits of the windows file attributes. This makes use of the fact that
@@ -1225,46 +1220,23 @@ internal class ArchiveReader

    #region Public Methods

-    public void Open(Stream stream, bool lookForHeader)
+    public void Open(Stream stream)
    {
        Close();

        _streamOrigin = stream.Position;
        _streamEnding = stream.Length;

-        var canScan = lookForHeader ? 0x80000 - 20 : 0;
-        while (true)
+        // TODO: Check Signature!
+        _header = new byte[0x20];
+        for (var offset = 0; offset < 0x20; )
        {
-            // TODO: Check Signature!
-            _header = new byte[0x20];
-            for (var offset = 0; offset < 0x20; )
+            var delta = stream.Read(_header, offset, 0x20 - offset);
+            if (delta == 0)
            {
-                var delta = stream.Read(_header, offset, 0x20 - offset);
-                if (delta == 0)
-                {
-                    throw new EndOfStreamException();
-                }
-
-                offset += delta;
+                throw new EndOfStreamException();
            }
-
-            if (
-                !lookForHeader
-                || _header
-                    .AsSpan(0, length: 6)
-                    .SequenceEqual<byte>([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])
-            )
-            {
-                break;
-            }
-
-            if (canScan == 0)
-            {
-                throw new InvalidFormatException("Unable to find 7z signature");
-            }
-
-            canScan--;
-            stream.Position = ++_streamOrigin;
+            offset += delta;
        }

        _stream = stream;
@@ -1463,7 +1435,7 @@ internal class ArchiveReader
 #if DEBUG
            Log.WriteLine(_db._files[index].Name);
 #endif
-            if (_db._files[index].Crc.HasValue)
+            if (_db._files[index].CrcDefined)
            {
                _stream = new CrcCheckStream(_db._files[index].Crc.Value);
            }
--- a/src/SharpCompress/Common/SevenZip/CFileItem.cs
+++ b/src/SharpCompress/Common/SevenZip/CFileItem.cs
@@ -8,13 +8,18 @@ internal class CFileItem
 {
    public long Size { get; internal set; }
    public uint? Attrib { get; internal set; }
-    public uint? ExtendedAttrib { get; internal set; }
    public uint? Crc { get; internal set; }
    public string Name { get; internal set; }

    public bool HasStream { get; internal set; }
    public bool IsDir { get; internal set; }

+    public bool CrcDefined => Crc != null;
+
+    public bool AttribDefined => Attrib != null;
+
+    public void SetAttrib(uint attrib) => Attrib = attrib;
+
    public DateTime? CTime { get; internal set; }
    public DateTime? ATime { get; internal set; }
    public DateTime? MTime { get; internal set; }
--- a/src/SharpCompress/Common/SevenZip/SevenZipEntry.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipEntry.cs
@@ -13,7 +13,7 @@ public class SevenZipEntry : Entry

    public override long Crc => FilePart.Header.Crc ?? 0;

-    public override string? Key => FilePart.Header.Name;
+    public override string Key => FilePart.Header.Name;

    public override string? LinkTarget => null;

@@ -38,8 +38,5 @@ public class SevenZipEntry : Entry
    public override int? Attrib =>
        FilePart.Header.Attrib.HasValue ? (int?)FilePart.Header.Attrib.Value : null;

-    public int? ExtendedAttrib =>
-        FilePart.Header.ExtendedAttrib.HasValue ? (int?)FilePart.Header.ExtendedAttrib.Value : null;
-
    internal override IEnumerable<FilePart> Parts => FilePart.AsEnumerable<FilePart>();
 }
--- a/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Linq;
 using SharpCompress.IO;
@@ -40,7 +41,7 @@ internal class SevenZipFilePart : FilePart
    {
        if (!Header.HasStream)
        {
-            return Stream.Null;
+            return null!;
        }
        var folderStream = _database.GetFolderStream(_stream, Folder!, _database.PasswordProvider);

@@ -67,31 +68,39 @@ internal class SevenZipFilePart : FilePart
        }
    }

-    private const uint K_COPY = 0x0;
    private const uint K_LZMA2 = 0x21;
    private const uint K_LZMA = 0x030101;
    private const uint K_PPMD = 0x030401;
    private const uint K_B_ZIP2 = 0x040202;

-    private CompressionType GetCompression()
+    internal CompressionType GetCompression()
    {
        if (Header.IsDir)
-        {
            return CompressionType.None;
-        }

-        var coder = Folder.NotNull()._coders.First();
-        return coder._methodId._id switch
+        var coder = Folder!._coders.First();
+        switch (coder._methodId._id)
        {
-            K_COPY => CompressionType.None,
-            K_LZMA or K_LZMA2 => CompressionType.LZMA,
-            K_PPMD => CompressionType.PPMd,
-            K_B_ZIP2 => CompressionType.BZip2,
-            _ => throw new InvalidFormatException(),
-        };
+            case K_LZMA:
+            case K_LZMA2:
+            {
+                return CompressionType.LZMA;
+            }
+            case K_PPMD:
+            {
+                return CompressionType.PPMd;
+            }
+            case K_B_ZIP2:
+            {
+                return CompressionType.BZip2;
+            }
+            default:
+                throw new NotImplementedException();
+        }
    }

    internal bool IsEncrypted =>
-        !Header.IsDir
-        && Folder?._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
+        Header.IsDir
+            ? false
+            : Folder!._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
 }
--- a/src/SharpCompress/Common/SharpCompressException.cs
+++ b/src/SharpCompress/Common/SharpCompressException.cs
@@ -1,48 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class SharpCompressException : Exception
-{
-    public SharpCompressException() { }
-
-    public SharpCompressException(string message)
-        : base(message) { }
-
-    public SharpCompressException(string message, Exception inner)
-        : base(message, inner) { }
-}
-
-public class ArchiveException(string message) : SharpCompressException(message);
-
-public class IncompleteArchiveException(string message) : ArchiveException(message);
-
-public class CryptographicException(string message) : SharpCompressException(message);
-
-public class ReaderCancelledException(string message) : SharpCompressException(message);
-
-public class ExtractionException : SharpCompressException
-{
-    public ExtractionException() { }
-
-    public ExtractionException(string message)
-        : base(message) { }
-
-    public ExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}
-
-public class MultipartStreamRequiredException(string message) : ExtractionException(message);
-
-public class MultiVolumeExtractionException(string message) : ExtractionException(message);
-
-public class InvalidFormatException : ExtractionException
-{
-    public InvalidFormatException() { }
-
-    public InvalidFormatException(string message)
-        : base(message) { }
-
-    public InvalidFormatException(string message, Exception inner)
-        : base(message, inner) { }
-}
--- a/src/SharpCompress/Common/Tar/Headers/EntryType.cs
+++ b/src/SharpCompress/Common/Tar/Headers/EntryType.cs
@@ -14,5 +14,5 @@ internal enum EntryType : byte
    LongName = (byte)'L',
    SparseFile = (byte)'S',
    VolumeHeader = (byte)'V',
-    GlobalExtendedHeader = (byte)'g',
+    GlobalExtendedHeader = (byte)'g'
 }
--- a/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
+++ b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
@@ -1,3 +1,5 @@
+#nullable disable
+
 using System;
 using System.Buffers.Binary;
 using System.IO;
@@ -11,8 +13,8 @@ internal sealed class TarHeader

    public TarHeader(ArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding;

-    internal string? Name { get; set; }
-    internal string? LinkName { get; set; }
+    internal string Name { get; set; }
+    internal string LinkName { get; set; }

    internal long Mode { get; set; }
    internal long UserId { get; set; }
@@ -20,15 +22,11 @@ internal sealed class TarHeader
    internal long Size { get; set; }
    internal DateTime LastModifiedTime { get; set; }
    internal EntryType EntryType { get; set; }
-    internal Stream? PackedStream { get; set; }
+    internal Stream PackedStream { get; set; }
    internal ArchiveEncoding ArchiveEncoding { get; }

    internal const int BLOCK_SIZE = 512;

-    // Maximum size for long name/link headers to prevent memory exhaustion attacks
-    // This is generous enough for most real-world scenarios (32KB)
-    private const int MAX_LONG_NAME_SIZE = 32768;
-
    internal void Write(Stream output)
    {
        var buffer = new byte[BLOCK_SIZE];
@@ -38,9 +36,7 @@ internal sealed class TarHeader
        WriteOctalBytes(0, buffer, 116, 8); // group ID

        //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
-        var nameByteCount = ArchiveEncoding
-            .GetEncoding()
-            .GetByteCount(Name.NotNull("Name is null"));
+        var nameByteCount = ArchiveEncoding.GetEncoding().GetByteCount(Name);
        if (nameByteCount > 100)
        {
            // Set mock filename and filetype to indicate the next block is the actual name of the file
@@ -50,7 +46,7 @@ internal sealed class TarHeader
        }
        else
        {
-            WriteStringBytes(ArchiveEncoding.Encode(Name.NotNull("Name is null")), buffer, 100);
+            WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
            WriteOctalBytes(Size, buffer, 124, 12);
            var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
            WriteOctalBytes(time, buffer, 136, 12);
@@ -81,7 +77,7 @@ internal sealed class TarHeader
            //
            // and then infinite recursion is occured in WriteLongFilenameHeader because truncated.Length is 102.
            Name = ArchiveEncoding.Decode(
-                ArchiveEncoding.Encode(Name.NotNull("Name is null")),
+                ArchiveEncoding.Encode(Name),
                0,
                100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1)
            );
@@ -91,7 +87,7 @@ internal sealed class TarHeader

    private void WriteLongFilenameHeader(Stream output)
    {
-        var nameBytes = ArchiveEncoding.Encode(Name.NotNull("Name is null"));
+        var nameBytes = ArchiveEncoding.Encode(Name);
        output.Write(nameBytes, 0, nameBytes.Length);

        // pad to multiple of BlockSize bytes, and make sure a terminating null is added
@@ -105,100 +101,63 @@ internal sealed class TarHeader

    internal bool Read(BinaryReader reader)
    {
-        string? longName = null;
-        string? longLinkName = null;
-        var hasLongValue = true;
-        byte[] buffer;
-        EntryType entryType;
-
-        do
-        {
-            buffer = ReadBlock(reader);
-
-            if (buffer.Length == 0)
-            {
-                return false;
-            }
-
-            entryType = ReadEntryType(buffer);
-
-            // LongName and LongLink headers can follow each other and need
-            // to apply to the header that follows them.
-            if (entryType == EntryType.LongName)
-            {
-                longName = ReadLongName(reader, buffer);
-                continue;
-            }
-            else if (entryType == EntryType.LongLink)
-            {
-                longLinkName = ReadLongName(reader, buffer);
-                continue;
-            }
-
-            hasLongValue = false;
-        } while (hasLongValue);
-
-        // Check header checksum
-        if (!checkChecksum(buffer))
+        var buffer = ReadBlock(reader);
+        if (buffer.Length == 0)
        {
            return false;
        }

-        Name = longName ?? ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
-        EntryType = entryType;
-        Size = ReadSize(buffer);
-
        // for symlinks, additionally read the linkname
-        if (entryType == EntryType.SymLink || entryType == EntryType.HardLink)
+        if (ReadEntryType(buffer) == EntryType.SymLink)
        {
-            LinkName = longLinkName ?? ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
+            LinkName = ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
        }

-        Mode = ReadAsciiInt64Base8(buffer, 100, 7);
+        if (ReadEntryType(buffer) == EntryType.LongName)
+        {
+            Name = ReadLongName(reader, buffer);
+            buffer = ReadBlock(reader);
+        }
+        else
+        {
+            Name = ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
+        }

-        if (entryType == EntryType.Directory)
+        EntryType = ReadEntryType(buffer);
+        Size = ReadSize(buffer);
+
+        Mode = ReadAsciiInt64Base8(buffer, 100, 7);
+        if (EntryType == EntryType.Directory)
        {
            Mode |= 0b1_000_000_000;
        }

        UserId = ReadAsciiInt64Base8oldGnu(buffer, 108, 7);
        GroupId = ReadAsciiInt64Base8oldGnu(buffer, 116, 7);
-
        var unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
-
        LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();
+
        Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();

        if (!string.IsNullOrEmpty(Magic) && "ustar".Equals(Magic))
        {
-            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157).TrimNulls();
-
+            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157);
+            namePrefix = namePrefix.TrimNulls();
            if (!string.IsNullOrEmpty(namePrefix))
            {
                Name = namePrefix + "/" + Name;
            }
        }
-
-        if (entryType != EntryType.LongName && Name.Length == 0)
+        if (EntryType != EntryType.LongName && Name.Length == 0)
        {
            return false;
        }
-
        return true;
    }

    private string ReadLongName(BinaryReader reader, byte[] buffer)
    {
        var size = ReadSize(buffer);
-
-        // Validate size to prevent memory exhaustion from malformed headers
-        if (size < 0 || size > MAX_LONG_NAME_SIZE)
-        {
-            throw new InvalidFormatException(
-                $"Long name size {size} is invalid or exceeds maximum allowed size of {MAX_LONG_NAME_SIZE} bytes"
-            );
-        }
-
        var nameLength = (int)size;
        var nameBytes = reader.ReadBytes(nameLength);
        var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);
@@ -229,7 +188,7 @@ internal sealed class TarHeader

        if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
        {
-            throw new InvalidFormatException("Buffer is invalid size");
+            throw new InvalidOperationException("Buffer is invalid size");
        }
        return buffer;
    }
@@ -327,45 +286,9 @@ internal sealed class TarHeader
        (byte)' ',
        (byte)' ',
        (byte)' ',
-        (byte)' ',
+        (byte)' '
    };

-    internal static bool checkChecksum(byte[] buf)
-    {
-        const int eightSpacesChksum = 256;
-        var buffer = new Span<byte>(buf).Slice(0, 512);
-        int posix_sum = eightSpacesChksum;
-        int sun_sum = eightSpacesChksum;
-
-        foreach (byte b in buffer)
-        {
-            posix_sum += b;
-            sun_sum += unchecked((sbyte)b);
-        }
-
-        // Special case, empty file header
-        if (posix_sum == eightSpacesChksum)
-        {
-            return true;
-        }
-
-        // Remove current checksum from calculation
-        foreach (byte b in buffer.Slice(148, 8))
-        {
-            posix_sum -= b;
-            sun_sum -= unchecked((sbyte)b);
-        }
-
-        // Read and compare checksum for header
-        var crc = ReadAsciiInt64Base8(buf, 148, 7);
-        if (crc != posix_sum && crc != sun_sum)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
    internal static int RecalculateChecksum(byte[] buf)
    {
        // Set default value for checksum. That is 8 spaces.
@@ -400,5 +323,5 @@ internal sealed class TarHeader

    public long? DataStartPosition { get; set; }

-    public string? Magic { get; set; }
+    public string Magic { get; set; }
 }
--- a/src/SharpCompress/Common/Tar/TarEntry.cs
+++ b/src/SharpCompress/Common/Tar/TarEntry.cs
@@ -1,3 +1,5 @@
+#nullable disable
+
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -8,9 +10,9 @@ namespace SharpCompress.Common.Tar;

 public class TarEntry : Entry
 {
-    private readonly TarFilePart? _filePart;
+    private readonly TarFilePart _filePart;

-    internal TarEntry(TarFilePart? filePart, CompressionType type)
+    internal TarEntry(TarFilePart filePart, CompressionType type)
    {
        _filePart = filePart;
        CompressionType = type;
@@ -20,15 +22,15 @@ public class TarEntry : Entry

    public override long Crc => 0;

-    public override string? Key => _filePart?.Header.Name;
+    public override string Key => _filePart.Header.Name;

-    public override string? LinkTarget => _filePart?.Header.LinkName;
+    public override string LinkTarget => _filePart.Header.LinkName;

-    public override long CompressedSize => _filePart?.Header.Size ?? 0;
+    public override long CompressedSize => _filePart.Header.Size;

-    public override long Size => _filePart?.Header.Size ?? 0;
+    public override long Size => _filePart.Header.Size;

-    public override DateTime? LastModifiedTime => _filePart?.Header.LastModifiedTime;
+    public override DateTime? LastModifiedTime => _filePart.Header.LastModifiedTime;

    public override DateTime? CreatedTime => null;

@@ -38,17 +40,17 @@ public class TarEntry : Entry

    public override bool IsEncrypted => false;

-    public override bool IsDirectory => _filePart?.Header.EntryType == EntryType.Directory;
+    public override bool IsDirectory => _filePart.Header.EntryType == EntryType.Directory;

    public override bool IsSplitAfter => false;

-    public long Mode => _filePart?.Header.Mode ?? 0;
+    public long Mode => _filePart.Header.Mode;

-    public long UserID => _filePart?.Header.UserId ?? 0;
+    public long UserID => _filePart.Header.UserId;

-    public long GroupId => _filePart?.Header.GroupId ?? 0;
+    public long GroupId => _filePart.Header.GroupId;

-    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+    internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();

    internal static IEnumerable<TarEntry> GetEntries(
        StreamingMode mode,
@@ -57,17 +59,17 @@ public class TarEntry : Entry
        ArchiveEncoding archiveEncoding
    )
    {
-        foreach (var header in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
+        foreach (var h in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
        {
-            if (header != null)
+            if (h != null)
            {
                if (mode == StreamingMode.Seekable)
                {
-                    yield return new TarEntry(new TarFilePart(header, stream), compressionType);
+                    yield return new TarEntry(new TarFilePart(h, stream), compressionType);
                }
                else
                {
-                    yield return new TarEntry(new TarFilePart(header, null), compressionType);
+                    yield return new TarEntry(new TarFilePart(h, null), compressionType);
                }
            }
            else
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Hathcock	f298ad3322	more reverts	2024-03-29 16:05:20 +00:00
Adam Hathcock	69872dd9e7	split files	2024-03-29 16:00:05 +00:00
Adam Hathcock	92174f49ae	revert naming changes	2024-03-29 15:53:11 +00:00
Adam Hathcock	c39a155c8f	Merge branch 'master' into async-2 # Conflicts: # src/SharpCompress/Writers/Zip/ZipWriter.cs	2024-03-29 15:27:43 +00:00
Adam Hathcock	e5944cf72c	add writer support for async	2024-03-12 15:40:29 +00:00