try a new agent config

Handle vendor-specific and malformed ZIP extra fields safely

.config/dotnet-tools.json

@@ -3,10 +3,11 @@
   "isRoot": true,
   "tools": {
     "csharpier": {
-      "version": "0.27.3",
+      "version": "1.1.2",
       "commands": [
-        "dotnet-csharpier"
-      ]
+        "csharpier"
+      ],
+      "rollForward": false
     }
   }
 }

.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 = warning
+dotnet_analyzer_diagnostic.severity = silent
 
 ##########################################
 # File Header (Uncomment to support file headers)
@@ -269,6 +269,8 @@ 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
@@ -286,6 +288,7 @@ 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
@@ -303,13 +306,12 @@ dotnet_diagnostic.CS1998.severity = error
 dotnet_diagnostic.CS8602.severity = error
 dotnet_diagnostic.CS8604.severity = error
 dotnet_diagnostic.CS8618.severity = error
-dotnet_diagnostic.CS0618.severity = error
+dotnet_diagnostic.CS0618.severity = suggestion
 dotnet_diagnostic.CS1998.severity = error
 dotnet_diagnostic.CS4014.severity = error
 dotnet_diagnostic.CS8600.severity = error
 dotnet_diagnostic.CS8603.severity = error
 dotnet_diagnostic.CS8625.severity = error
-dotnet_diagnostic.CS8981.severity = suggestion
 
 dotnet_diagnostic.BL0005.severity = suggestion
 
@@ -318,7 +320,7 @@ dotnet_diagnostic.MVC1000.severity = suggestion
 dotnet_diagnostic.RZ10012.severity = error
 
 dotnet_diagnostic.IDE0004.severity = error # redundant cast
-dotnet_diagnostic.IDE0005.severity = error
+dotnet_diagnostic.IDE0005.severity = suggestion
 dotnet_diagnostic.IDE0007.severity = error # Use var
 dotnet_diagnostic.IDE0011.severity = error # Use braces on if statements
 dotnet_diagnostic.IDE0010.severity = silent # populate switch
@@ -329,7 +331,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
+dotnet_diagnostic.IDE0028.severity = silent # expression body for accessors
 dotnet_diagnostic.IDE0032.severity = suggestion # Use auto property
 dotnet_diagnostic.IDE0033.severity = error # prefer tuple name
 dotnet_diagnostic.IDE0037.severity = suggestion # simplify anonymous type
@@ -337,7 +339,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 # paratemeter name
+dotnet_diagnostic.IDE0047.severity = suggestion # parameter name
 dotnet_diagnostic.IDE0051.severity = error # unused field
 dotnet_diagnostic.IDE0052.severity = error # unused member
 dotnet_diagnostic.IDE0053.severity = suggestion # lambda not needed
@@ -351,11 +353,20 @@ 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 = error # namespace folder structure
+dotnet_diagnostic.IDE0130.severity = suggestion # 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

.github/COPILOT_AGENT_README.md

@@ -0,0 +1,13 @@
+# 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/workflows/dotnetcore.yml: CI runs on PRs touching the solution, source, or tests to validate changes
+- AGENTS.yml: general information for this project
+
+Maintainers can adjust the allowed paths or disable the agent by editing or removing .copilot-agent.yml.
+
+Notes:
+- Do not change any other files in the repository.
+- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Tests test project.

.github/agents/copilot-agent.yml

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

.github/dependabot.yml

@@ -1,6 +1,13 @@
 version: 2
 updates:
-  - package-ecosystem: "github-actions" # search for actions - there are other options available
-    directory: "/" # search in .github/workflows under root `/`
+  - package-ecosystem: "github-actions"
+    directory: "/" 
     schedule:
-      interval: "weekly" # check for action update every week
+      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"

.github/workflows/dotnetcore.yml

@@ -14,8 +14,8 @@ jobs:
         os: [windows-latest, ubuntu-latest]
 
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-dotnet@v4
+    - uses: actions/checkout@v5
+    - uses: actions/setup-dotnet@v5
       with:
         dotnet-version: 8.0.x
     - run: dotnet run --project build/build.csproj

AGENTS.md

@@ -0,0 +1,64 @@
+---
+description: 'Guidelines for building C# applications'
+applyTo: '**/*.cs'
+---
+
+# C# Development
+
+## C# Instructions
+- Always use the latest version C#, currently C# 13 features.
+- Write clear and concise comments for each function.
+
+## 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.
+
+## 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 all code formatting to ensure consistent style across the project.
+- Install CSharpier globally: `dotnet tool install -g csharpier`
+- Format files with: `dotnet csharpier format .`
+- Configure your IDE to format on save using CSharpier.
+- CSharpier configuration can be customized via `.csharpierrc` file in the project root.
+- Trust CSharpier's opinionated formatting decisions to maintain consistency.
+
+## Project Setup and Structure
+
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+- Demonstrate how to organize code using feature folders or domain-driven design principles.
+- Show proper separation of concerns with models, services, and data access layers.
+- Explain the Program.cs and configuration system in ASP.NET Core 9 including environment-specific settings.
+
+## 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.
+
+## Testing
+
+- Always include test cases for critical paths of the application.
+- Guide users through creating unit tests.
+- Do not emit "Act", "Arrange" or "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+
+## Performance Optimization
+
+- Guide users on implementing caching strategies (in-memory, distributed, response caching).
+- Explain asynchronous programming patterns and why they matter for API performance.
+- Demonstrate pagination, filtering, and sorting for large data sets.
+- Show how to implement compression and other performance optimizations.
+- Explain how to measure and benchmark API performance.

Directory.Build.props

@@ -10,5 +10,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
     <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
   </PropertyGroup>
 </Project>

Directory.Packages.props

@@ -0,0 +1,20 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="Bullseye" Version="6.0.0" />
+    <PackageVersion Include="AwesomeAssertions" Version="9.2.1" />
+    <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.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
+  </ItemGroup>
+</Project>

FORMATS.md

@@ -11,10 +11,11 @@
 | Archive Format         | Compression Format(s)                             | Compress/Decompress | Archive API     | Reader API | Writer API    |
 | ---------------------- | ------------------------------------------------- | ------------------- | --------------- | ---------- | ------------- |
 | Rar                    | Rar                                               | Decompress (1)      | RarArchive      | RarReader  | N/A           |
-| Zip (2)                | None, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd | Both                | ZipArchive      | ZipReader  | ZipWriter     |
+| Zip (2)                | None, Shrink, Reduce, Implode, 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    |
@@ -41,6 +42,7 @@ 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
 

NuGet.config

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

README.md

@@ -1,12 +1,12 @@
 # SharpCompress
 
-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.
+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 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).
 
 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%20Documentation-RobiniaDocs-43bc00?logo=readme&logoColor=white)](https://www.robiniadocs.com/d/sharpcompress/api/SharpCompress.html)
+[![Static Badge](https://img.shields.io/badge/API%20Docs-DNDocs-190088?logo=readme&logoColor=white)](https://dndocs.com/d/sharpcompress/api/index.html)
 
 ## Need Help?
 
@@ -20,10 +20,12 @@ 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 propriatory format and the compression is closed source. Use Tar/LZip for LZMA
+RAR is not recommended as it's a proprietary 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!
@@ -40,6 +42,7 @@ 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
 

SharpCompress.sln

@@ -17,8 +17,14 @@ 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
 	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
@@ -37,6 +43,10 @@ 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
@@ -44,5 +54,6 @@ 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

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">Named</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Positional</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">True</s:Boolean>
+	<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_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">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_CALLS_CHAIN/@EntryValue">True</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_EXPRESSION/@EntryValue">False</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">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">False</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">True</s:Boolean>
+	<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_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">True</s:Boolean>
+	<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_WHILE_ON_NEW_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">False</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,18 +67,22 @@
 	<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_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_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">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/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/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>
@@ -118,6 +122,7 @@
 	<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>
@@ -127,6 +132,7 @@
 	<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>

USAGE.md

@@ -27,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 wrapped 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 wrapper to prevent the stream being disposed.  The change in 0.21 simplified a lot even though the usage is a bit more convoluted.
 
 ## Samples
 
@@ -71,18 +71,34 @@ using (var archive = ZipArchive.Create())
 memoryStream.Position = 0;
 ```
 
-### Extract all files from a Rar file to a directory using RarArchive
+### 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
 
 ```C#
 using (var archive = RarArchive.Open("Test.rar"))
 {
     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
     {
-        entry.WriteToDirectory("D:\\temp", new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        });
+        Console.WriteLine($"{entry.Key}: {entry.Size} bytes");
     }
 }
 ```

build/Program.cs

@@ -15,7 +15,7 @@ const string Publish = "publish";
 
 Target(
     Clean,
-    ForEach("**/bin", "**/obj"),
+    ["**/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, DependsOn(Format), () => Run("dotnet", "restore"));
+Target(Restore, [Format], () => Run("dotnet", "restore"));
 
 Target(
     Build,
-    DependsOn(Restore),
+    [Restore],
     () =>
     {
         Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release --no-restore");
@@ -60,8 +60,8 @@ Target(
 
 Target(
     Test,
-    DependsOn(Build),
-    ForEach("net8.0", "net462"),
+    [Build],
+    ["net8.0", "net48"],
     framework =>
     {
         IEnumerable<string> GetFiles(string d)
@@ -69,7 +69,7 @@ Target(
             return Glob.Files(".", d);
         }
 
-        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net462")
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net48")
         {
             return;
         }
@@ -83,13 +83,13 @@ Target(
 
 Target(
     Publish,
-    DependsOn(Test),
+    [Test],
     () =>
     {
         Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
     }
 );
 
-Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
+Target("default", [Publish], () => Console.WriteLine("Done!"));
 
 await RunTargetsAndExitAsync(args);

build/build.csproj

@@ -1,14 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
-
   <ItemGroup>
-    <PackageReference Include="Bullseye" Version="4.2.1" />
-    <PackageReference Include="Glob" Version="1.1.9" />
-    <PackageReference Include="SimpleExec" Version="11.0.0" />
+    <PackageReference Include="Bullseye" />
+    <PackageReference Include="Glob" />
+    <PackageReference Include="SimpleExec" />
   </ItemGroup>
-
 </Project>

build/packages.lock.json

@@ -0,0 +1,25 @@
+{
+  "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=="
+      }
+    }
+  }
+}

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
 

src/SharpCompress/Archives/AbstractArchive.cs

@@ -12,39 +12,35 @@ 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 readonly LazyReadOnlyCollection<TVolume> _lazyVolumes;
+    private readonly LazyReadOnlyCollection<TEntry> _lazyEntries;
+    private bool _disposed;
+    private readonly SourceStream? _sourceStream;
 
     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; }
 
-    private bool disposed;
-    protected SourceStream SrcStream;
-
-    internal AbstractArchive(ArchiveType type, SourceStream srcStream)
+    internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
     {
         Type = type;
-        ReaderOptions = srcStream.ReaderOptions;
-        SrcStream = srcStream;
-        lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
-        lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+        ReaderOptions = sourceStream.ReaderOptions;
+        _sourceStream = sourceStream;
+        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(_sourceStream));
+        _lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
     }
 
-#nullable disable
     internal AbstractArchive(ArchiveType type)
     {
         Type = type;
-        lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
-        lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+        ReaderOptions = new();
+        _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) =>
@@ -57,7 +53,7 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtra
     {
         if (!stream.CanSeek || !stream.CanRead)
         {
-            throw new ArgumentException("Archive streams must be Readable and Seekable");
+            throw new ArchiveException("Archive streams must be Readable and Seekable");
         }
         return stream;
     }
@@ -65,12 +61,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.
@@ -84,29 +80,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 srcStream);
+    protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
     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());
-            SrcStream?.Dispose();
+            _lazyVolumes.ForEach(v => v.Dispose());
+            _lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+            _sourceStream?.Dispose();
 
-            disposed = true;
+            _disposed = true;
         }
     }
 
     void IArchiveExtractionListener.EnsureEntriesLoaded()
     {
-        lazyEntries.EnsureFullyLoaded();
-        lazyVolumes.EnsureFullyLoaded();
+        _lazyEntries.EnsureFullyLoaded();
+        _lazyVolumes.EnsureFullyLoaded();
     }
 
     void IExtractionListener.FireCompressedBytesRead(
@@ -148,6 +144,12 @@ 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();
     }

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -41,8 +41,8 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
     internal AbstractWritableArchive(ArchiveType type)
         : base(type) { }
 
-    internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
-        : base(type, srcStream) { }
+    internal AbstractWritableArchive(ArchiveType type, SourceStream sourceStream)
+        : base(type, sourceStream) { }
 
     public override ICollection<TEntry> Entries
     {
@@ -120,6 +120,10 @@ 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] == '\\')
             {
@@ -147,7 +151,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
     {
         if (!source.CanRead || !source.CanSeek)
         {
-            throw new ArgumentException(
+            throw new ArchiveException(
                 "Streams must be readable and seekable to use the Writing Archive API"
             );
         }

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Factories;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
@@ -19,7 +20,7 @@ public static class ArchiveFactory
     public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
         readerOptions ??= new ReaderOptions();
-
+        stream = new SharpCompressStream(stream, bufferSize: readerOptions.BufferSize);
         return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
@@ -44,7 +45,7 @@ public static class ArchiveFactory
     /// <param name="options"></param>
     public static IArchive Open(string filePath, ReaderOptions? options = null)
     {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        filePath.NotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), options);
     }
 
@@ -67,7 +68,7 @@ public static class ArchiveFactory
     /// <param name="options"></param>
     public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
     {
-        fileInfos.CheckNotNull(nameof(fileInfos));
+        fileInfos.NotNull(nameof(fileInfos));
         var filesArray = fileInfos.ToArray();
         if (filesArray.Length == 0)
         {
@@ -80,7 +81,7 @@ public static class ArchiveFactory
             return Open(fileInfo, options);
         }
 
-        fileInfo.CheckNotNull(nameof(fileInfo));
+        fileInfo.NotNull(nameof(fileInfo));
         options ??= new ReaderOptions { LeaveStreamOpen = false };
 
         return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
@@ -93,7 +94,7 @@ public static class ArchiveFactory
     /// <param name="options"></param>
     public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
     {
-        streams.CheckNotNull(nameof(streams));
+        streams.NotNull(nameof(streams));
         var streamsArray = streams.ToArray();
         if (streamsArray.Length == 0)
         {
@@ -106,7 +107,7 @@ public static class ArchiveFactory
             return Open(firstStream, options);
         }
 
-        firstStream.CheckNotNull(nameof(firstStream));
+        firstStream.NotNull(nameof(firstStream));
         options ??= new ReaderOptions();
 
         return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
@@ -122,16 +123,13 @@ public static class ArchiveFactory
     )
     {
         using var archive = Open(sourceArchive);
-        foreach (var entry in archive.Entries)
-        {
-            entry.WriteToDirectory(destinationDirectory, options);
-        }
+        archive.WriteToDirectory(destinationDirectory, options);
     }
 
     private static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
-        finfo.CheckNotNull(nameof(finfo));
+        finfo.NotNull(nameof(finfo));
         using Stream stream = finfo.OpenRead();
         return FindFactory<T>(stream);
     }
@@ -139,7 +137,7 @@ public static class ArchiveFactory
     private static T FindFactory<T>(Stream stream)
         where T : IFactory
     {
-        stream.CheckNotNull(nameof(stream));
+        stream.NotNull(nameof(stream));
         if (!stream.CanRead || !stream.CanSeek)
         {
             throw new ArgumentException("Stream should be readable and seekable");
@@ -168,17 +166,25 @@ public static class ArchiveFactory
         );
     }
 
-    public static bool IsArchive(string filePath, out ArchiveType? type)
+    public static bool IsArchive(
+        string filePath,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        filePath.NotNullOrEmpty(nameof(filePath));
         using Stream s = File.OpenRead(filePath);
-        return IsArchive(s, out type);
+        return IsArchive(s, out type, bufferSize);
     }
 
-    public static bool IsArchive(Stream stream, out ArchiveType? type)
+    public static bool IsArchive(
+        Stream stream,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         type = null;
-        stream.CheckNotNull(nameof(stream));
+        stream.NotNull(nameof(stream));
 
         if (!stream.CanRead || !stream.CanSeek)
         {
@@ -189,9 +195,10 @@ public static class ArchiveFactory
 
         foreach (var factory in Factory.Factories)
         {
+            var isArchive = factory.IsArchive(stream);
             stream.Position = startPosition;
 
-            if (factory.IsArchive(stream, null))
+            if (isArchive)
             {
                 type = factory.KnownArchiveType;
                 return true;
@@ -208,7 +215,7 @@ public static class ArchiveFactory
     /// <returns></returns>
     public static IEnumerable<string> GetFileParts(string part1)
     {
-        part1.CheckNotNullOrEmpty(nameof(part1));
+        part1.NotNullOrEmpty(nameof(part1));
         return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
     }
 
@@ -219,7 +226,7 @@ public static class ArchiveFactory
     /// <returns></returns>
     public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
     {
-        part1.CheckNotNull(nameof(part1));
+        part1.NotNull(nameof(part1));
         yield return part1;
 
         foreach (var factory in Factory.Factories.OfType<IFactory>())
@@ -239,4 +246,6 @@ public static class ArchiveFactory
             }
         }
     }
+
+    public static IArchiveFactory AutoFactory { get; } = new AutoArchiveFactory();
 }

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -0,0 +1,30 @@
+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);
+}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -21,7 +21,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        filePath.NotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -32,7 +32,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.CheckNotNull(nameof(fileInfo));
+        fileInfo.NotNull(nameof(fileInfo));
         return new GZipArchive(
             new SourceStream(
                 fileInfo,
@@ -52,7 +52,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.CheckNotNull(nameof(fileInfos));
+        fileInfos.NotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new GZipArchive(
             new SourceStream(
@@ -70,7 +70,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.CheckNotNull(nameof(streams));
+        streams.NotNull(nameof(streams));
         var strms = streams.ToArray();
         return new GZipArchive(
             new SourceStream(
@@ -88,9 +88,15 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <param name="readerOptions"></param>
     public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.CheckNotNull(nameof(stream));
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new GZipArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
         );
     }
 
@@ -99,16 +105,14 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
-    /// <param name="srcStream"></param>
-    /// <param name="options"></param>
-    internal GZipArchive(SourceStream srcStream)
-        : base(ArchiveType.Tar, srcStream) { }
+    /// <param name="sourceStream"></param>
+    private GZipArchive(SourceStream sourceStream)
+        : base(ArchiveType.GZip, sourceStream) { }
 
-    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
+    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream sourceStream)
     {
-        srcStream.LoadAllParts();
-        var idx = 0;
-        return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, idx++));
+        sourceStream.LoadAllParts();
+        return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0));
     }
 
     public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
@@ -164,7 +168,7 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
         if (Entries.Any())
         {
-            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
         }
         return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
     }
@@ -178,13 +182,17 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
         if (Entries.Count > 1)
         {
-            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            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();
-            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+            writer.Write(
+                entry.Key.NotNull("Entry Key is null"),
+                entryStream,
+                entry.LastModifiedTime
+            );
         }
     }
 

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -6,7 +6,7 @@ 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()
@@ -17,7 +17,7 @@ public class GZipArchiveEntry : GZipEntry, IArchiveEntry
         {
             part.GetRawStream().Position = part.EntryStartPosition;
         }
-        return Parts.Single().GetCompressedStream();
+        return Parts.Single().GetCompressedStream().NotNull();
     }
 
     #region IArchiveEntry Members

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -32,7 +30,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;
 
@@ -60,7 +58,7 @@ internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArch
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -17,19 +17,15 @@ public static class IArchiveEntryExtensions
         streamListener.EnsureEntriesLoaded();
         streamListener.FireEntryExtractionBegin(archiveEntry);
         streamListener.FireFilePartExtractionBegin(
-            archiveEntry.Key,
+            archiveEntry.Key ?? "Key",
             archiveEntry.Size,
             archiveEntry.CompressedSize
         );
         var entryStream = archiveEntry.OpenEntryStream();
-        if (entryStream is null)
-        {
-            return;
-        }
         using (entryStream)
         {
             using Stream s = new ListeningStream(streamListener, entryStream);
-            s.TransferTo(streamToWriteTo);
+            s.CopyTo(streamToWriteTo);
         }
         streamListener.FireEntryExtractionEnd(archiveEntry);
     }

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,10 +19,8 @@ public static class IArchiveExtensions
         ExtractionOptions? options = null
     )
     {
-        foreach (var entry in archive.Entries.Where(x => !x.IsDirectory))
-        {
-            entry.WriteToDirectory(destinationDirectory, options);
-        }
+        using var reader = archive.ExtractAllEntries();
+        reader.WriteAllToDirectory(destinationDirectory, options);
     }
 
     /// <summary>
@@ -47,27 +45,37 @@ public static class IArchiveExtensions
         var seenDirectories = new HashSet<string>();
 
         // Extract
-        var entries = archive.ExtractAllEntries();
-        while (entries.MoveToNextEntry())
+        foreach (var entry in archive.Entries)
         {
             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
-            var path = Path.Combine(destination, entry.Key);
-            if (Path.GetDirectoryName(path) is { } directory && seenDirectories.Add(path))
+            // 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)
             {
-                Directory.CreateDirectory(directory);
+                if (!Directory.Exists(directory) && !seenDirectories.Contains(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                    seenDirectories.Add(directory);
+                }
             }
 
             // Write file
             using var fs = File.OpenWrite(path);
-            entries.WriteEntryTo(fs);
+            entry.WriteTo(fs);
 
             // Update progress
             bytesRead += entry.Size;

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Rar;
@@ -13,7 +14,7 @@ namespace SharpCompress.Archives.Rar;
 /// </summary>
 internal class FileInfoRarArchiveVolume : RarVolume
 {
-    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index = 0)
+    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index)
         : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options), index)
     {
         FileInfo = fileInfo;

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -14,6 +14,7 @@ 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());
@@ -21,39 +22,61 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
-    /// <param name="srcStream"></param>
-    /// <param name="options"></param>
-    internal RarArchive(SourceStream srcStream)
-        : base(ArchiveType.Rar, srcStream) { }
+    /// <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();
+        }
+    }
 
     protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
         RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
 
-    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream srcStream)
+    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
     {
-        SrcStream.LoadAllParts(); //request all streams
-        var streams = SrcStream.Streams.ToArray();
-        var idx = 0;
+        sourceStream.LoadAllParts(); //request all streams
+        var streams = sourceStream.Streams.ToArray();
+        var i = 0;
         if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
         {
-            SrcStream.IsVolumes = true;
+            sourceStream.IsVolumes = true;
             streams[1].Position = 0;
-            SrcStream.Position = 0;
+            sourceStream.Position = 0;
 
-            return srcStream.Streams.Select(a => new StreamRarArchiveVolume(
+            return sourceStream.Streams.Select(a => new StreamRarArchiveVolume(
                 a,
                 ReaderOptions,
-                idx++
+                i++
             ));
         }
-        else //split mode or single file
-        {
-            return new StreamRarArchiveVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
-        }
+
+        //split mode or single file
+        return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).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);
@@ -72,7 +95,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="options"></param>
     public static RarArchive Open(string filePath, ReaderOptions? options = null)
     {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        filePath.NotNullOrEmpty(nameof(filePath));
         var fileInfo = new FileInfo(filePath);
         return new RarArchive(
             new SourceStream(
@@ -90,7 +113,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="options"></param>
     public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
     {
-        fileInfo.CheckNotNull(nameof(fileInfo));
+        fileInfo.NotNull(nameof(fileInfo));
         return new RarArchive(
             new SourceStream(
                 fileInfo,
@@ -107,8 +130,14 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="options"></param>
     public static RarArchive Open(Stream stream, ReaderOptions? options = null)
     {
-        stream.CheckNotNull(nameof(stream));
-        return new RarArchive(new SourceStream(stream, i => null, options ?? new ReaderOptions()));
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
     }
 
     /// <summary>
@@ -121,7 +150,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.CheckNotNull(nameof(fileInfos));
+        fileInfos.NotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new RarArchive(
             new SourceStream(
@@ -139,7 +168,7 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     /// <param name="readerOptions"></param>
     public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.CheckNotNull(nameof(streams));
+        streams.NotNull(nameof(streams));
         var strms = streams.ToArray();
         return new RarArchive(
             new SourceStream(

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -42,7 +42,7 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
         {
             CheckIncomplete();
             return BitConverter.ToUInt32(
-                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc,
+                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc.NotNull(),
                 0
             );
         }

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)
     {
-        this.stream = stream;
-        this.password = password;
+        _stream = stream;
+        _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;

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 = 0)
+    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index)
         : base(StreamingMode.Seekable, stream, options, index) { }
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -14,16 +12,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.CheckNotNullOrEmpty("filePath");
+        filePath.NotNullOrEmpty("filePath");
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -32,9 +30,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.CheckNotNull("fileInfo");
+        fileInfo.NotNull("fileInfo");
         return new SevenZipArchive(
             new SourceStream(
                 fileInfo,
@@ -51,10 +49,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.CheckNotNull(nameof(fileInfos));
+        fileInfos.NotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new SevenZipArchive(
             new SourceStream(
@@ -72,10 +70,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.CheckNotNull(nameof(streams));
+        streams.NotNull(nameof(streams));
         var strms = streams.ToArray();
         return new SevenZipArchive(
             new SourceStream(
@@ -91,27 +89,31 @@ 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.CheckNotNull("stream");
+        stream.NotNull("stream");
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new SevenZipArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
         );
     }
 
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
-    /// <param name="srcStream"></param>
-    /// <param name="options"></param>
-    internal SevenZipArchive(SourceStream srcStream)
-        : base(ArchiveType.SevenZip, srcStream) { }
+    /// <param name="sourceStream"></param>
+    private SevenZipArchive(SourceStream sourceStream)
+        : base(ArchiveType.SevenZip, sourceStream) { }
 
-    protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream srcStream)
+    protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream sourceStream)
     {
-        SrcStream.LoadAllParts(); //request all streams
-        var idx = 0;
-        return new SevenZipVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
+        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
+        return new SevenZipVolume(sourceStream, ReaderOptions, 0).AsEnumerable(); //simple single volume or split, multivolume not supported
     }
 
     public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
@@ -135,13 +137,17 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
     {
         var stream = volumes.Single().Stream;
         LoadFactory(stream);
-        var entries = new SevenZipArchiveEntry[database._files.Count];
-        for (var i = 0; i < database._files.Count; i++)
+        if (_database is null)
         {
-            var file = database._files[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];
             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))
@@ -159,12 +165,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);
-            database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
+            reader.Open(stream, lookForHeader: ReaderOptions.LookForHeader);
+            _database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
         }
     }
 
@@ -180,46 +186,43 @@ 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).Count() > 1;
+        Entries
+            .Where(x => !x.IsDirectory)
+            .GroupBy(x => x.FilePart.Folder)
+            .Any(folder => folder.Count() > 1);
 
-    public override long TotalSize
-    {
-        get
-        {
-            var i = Entries.Count;
-            return database._packSizes.Aggregate(0L, (total, packSize) => total + packSize);
-        }
-    }
+    public override long TotalSize =>
+        _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;
 
     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))
             {
@@ -229,37 +232,42 @@ 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, currentItem.Size));
+            CreateEntryStream(
+                new ReadOnlySubStream(
+                    _currentStream.NotNull("currentStream is not null"),
+                    _currentItem?.Size ?? 0
+                )
+            );
     }
 
     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;
     }
 }

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -22,7 +22,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        filePath.NotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -33,7 +33,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.CheckNotNull(nameof(fileInfo));
+        fileInfo.NotNull(nameof(fileInfo));
         return new TarArchive(
             new SourceStream(
                 fileInfo,
@@ -53,7 +53,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.CheckNotNull(nameof(fileInfos));
+        fileInfos.NotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new TarArchive(
             new SourceStream(
@@ -71,7 +71,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.CheckNotNull(nameof(streams));
+        streams.NotNull(nameof(streams));
         var strms = streams.ToArray();
         return new TarArchive(
             new SourceStream(
@@ -89,7 +89,13 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     /// <param name="readerOptions"></param>
     public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.CheckNotNull(nameof(stream));
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new TarArchive(
             new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
         );
@@ -114,7 +120,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;
@@ -123,22 +129,20 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         return false;
     }
 
-    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
+    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
     {
-        SrcStream.LoadAllParts(); //request all streams
-        var idx = 0;
-        return new TarVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
+        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
+        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable(); //simple single volume or split, multivolume not supported
     }
 
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
-    /// <param name="srcStream"></param>
-    /// <param name="options"></param>
-    internal TarArchive(SourceStream srcStream)
-        : base(ArchiveType.Tar, srcStream) { }
+    /// <param name="sourceStream"></param>
+    private TarArchive(SourceStream sourceStream)
+        : base(ArchiveType.Tar, sourceStream) { }
 
-    internal TarArchive()
+    private TarArchive()
         : base(ArchiveType.Tar) { }
 
     protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
@@ -174,7 +178,7 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                         using (var entryStream = entry.OpenEntryStream())
                         {
                             using var memoryStream = new MemoryStream();
-                            entryStream.TransferTo(memoryStream);
+                            entryStream.CopyTo(memoryStream);
                             memoryStream.Position = 0;
                             var bytes = memoryStream.ToArray();
 
@@ -192,6 +196,10 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
                     );
                 }
             }
+            else
+            {
+                throw new IncompleteArchiveException("Failed to read TAR header");
+            }
         }
     }
 
@@ -225,7 +233,12 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
             using var entryStream = entry.OpenEntryStream();
-            writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
+            writer.Write(
+                entry.Key.NotNull("Entry Key is null"),
+                entryStream,
+                entry.LastModifiedTime,
+                entry.Size
+            );
         }
     }
 

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -7,10 +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();
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -60,7 +58,7 @@ internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiv
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
     }
 
     internal override void Close()

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -16,10 +16,7 @@ namespace SharpCompress.Archives.Zip;
 
 public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
-#nullable disable
-    private readonly SeekableZipHeaderFactory headerFactory;
-
-#nullable enable
+    private readonly SeekableZipHeaderFactory? headerFactory;
 
     /// <summary>
     /// Gets or sets the compression level applied to files added to the archive,
@@ -30,13 +27,13 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
-    /// <param name="srcStream"></param>
+    /// <param name="sourceStream"></param>
     /// <param name="options"></param>
-    internal ZipArchive(SourceStream srcStream)
-        : base(ArchiveType.Zip, srcStream) =>
+    internal ZipArchive(SourceStream sourceStream)
+        : base(ArchiveType.Zip, sourceStream) =>
         headerFactory = new SeekableZipHeaderFactory(
-            srcStream.ReaderOptions.Password,
-            srcStream.ReaderOptions.ArchiveEncoding
+            sourceStream.ReaderOptions.Password,
+            sourceStream.ReaderOptions.ArchiveEncoding
         );
 
     /// <summary>
@@ -46,7 +43,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        filePath.NotNullOrEmpty(nameof(filePath));
         return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
     }
 
@@ -57,7 +54,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
     {
-        fileInfo.CheckNotNull(nameof(fileInfo));
+        fileInfo.NotNull(nameof(fileInfo));
         return new ZipArchive(
             new SourceStream(
                 fileInfo,
@@ -77,7 +74,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         ReaderOptions? readerOptions = null
     )
     {
-        fileInfos.CheckNotNull(nameof(fileInfos));
+        fileInfos.NotNull(nameof(fileInfos));
         var files = fileInfos.ToArray();
         return new ZipArchive(
             new SourceStream(
@@ -95,7 +92,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
     {
-        streams.CheckNotNull(nameof(streams));
+        streams.NotNull(nameof(streams));
         var strms = streams.ToArray();
         return new ZipArchive(
             new SourceStream(
@@ -113,30 +110,52 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     /// <param name="readerOptions"></param>
     public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        stream.CheckNotNull(nameof(stream));
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
         return new ZipArchive(
             new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
         );
     }
 
-    public static bool IsZipFile(string filePath, string? password = null) =>
-        IsZipFile(new FileInfo(filePath), password);
+    public static bool IsZipFile(
+        string filePath,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => IsZipFile(new FileInfo(filePath), password, bufferSize);
 
-    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+    public static bool IsZipFile(
+        FileInfo fileInfo,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         if (!fileInfo.Exists)
         {
             return false;
         }
         using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password);
+        return IsZipFile(stream, password, bufferSize);
     }
 
-    public static bool IsZipFile(Stream stream, string? password = null)
+    public static bool IsZipFile(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
         try
         {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
             var header = headerFactory
                 .ReadStreamHeader(stream)
                 .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
@@ -156,11 +175,20 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
-    public static bool IsZipMulti(Stream stream, string? password = null)
+    public static bool IsZipMulti(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
     {
         var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
         try
         {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
             var header = headerFactory
                 .ReadStreamHeader(stream)
                 .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
@@ -189,21 +217,21 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
     }
 
-    protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream srcStream)
+    protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
     {
-        SrcStream.LoadAllParts(); //request all streams
-        SrcStream.Position = 0;
+        stream.LoadAllParts(); //request all streams
+        stream.Position = 0;
 
-        var streams = SrcStream.Streams.ToList();
+        var streams = stream.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);
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
             streams[1].Position -= 4;
             if (isZip)
             {
-                SrcStream.IsVolumes = true;
+                stream.IsVolumes = true;
 
                 var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
                 streams.RemoveAt(0);
@@ -215,7 +243,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         }
 
         //split mode or single file
-        return new ZipVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
+        return new ZipVolume(stream, ReaderOptions, idx++).AsEnumerable();
     }
 
     internal ZipArchive()
@@ -224,14 +252,13 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
     {
         var vols = volumes.ToArray();
-        foreach (var h in headerFactory.ReadSeekableHeader(vols.Last().Stream))
+        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
         {
             if (h != null)
             {
                 switch (h.ZipHeaderType)
                 {
                     case ZipHeaderType.DirectoryEntry:
-
                         {
                             var deh = (DirectoryEntryHeader)h;
                             Stream s;
@@ -254,14 +281,14 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 
                             yield return new ZipArchiveEntry(
                                 this,
-                                new SeekableZipFilePart(headerFactory, deh, s)
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
                             );
                         }
                         break;
                     case ZipHeaderType.DirectoryEnd:
                     {
                         var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                        volumes.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                        vols.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
                         yield break;
                     }
                 }
@@ -282,7 +309,11 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
             using var entryStream = entry.OpenEntryStream();
-            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+            writer.Write(
+                entry.Key.NotNull("Entry Key is null"),
+                entryStream,
+                entry.LastModifiedTime
+            );
         }
     }
 
@@ -299,7 +330,7 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
-        stream.Position = 0;
+        ((IStreamStack)stream).StackSeek(0);
         return ZipReader.Open(stream, ReaderOptions, Entries);
     }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -9,7 +9,7 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
     internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
         : base(part) => Archive = archive;
 
-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
     #region IArchiveEntry Members
 
@@ -18,6 +18,4 @@ public class ZipArchiveEntry : ZipEntry, IArchiveEntry
     public bool IsComplete => true;
 
     #endregion
-
-    public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
 }

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

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

src/SharpCompress/AssemblyInfo.cs

@@ -1,3 +1,7 @@
 using System;
+using System.Runtime.CompilerServices;
 
 [assembly: CLSCompliant(true)]
+[assembly: InternalsVisibleTo(
+    "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
+)]

src/SharpCompress/BufferPool.cs

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

src/SharpCompress/Common/Arc/ArcEntry.cs

@@ -0,0 +1,60 @@
+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();
+    }
+}

src/SharpCompress/Common/Arc/ArcEntryHeader.cs

@@ -0,0 +1,76 @@
+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.RLE90,
+                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;
+        }
+    }
+}

src/SharpCompress/Common/Arc/ArcFilePart.cs

@@ -0,0 +1,75 @@
+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.RLE90:
+                        compressedStream = new RunLength90Stream(
+                            _stream,
+                            (int)Header.CompressedSize
+                        );
+                        break;
+                    case CompressionType.Squeezed:
+                        compressedStream = new SqueezeStream(_stream, (int)Header.CompressedSize);
+                        break;
+                    case CompressionType.Crunched:
+                        compressedStream = new ArcLzwStream(
+                            _stream,
+                            (int)Header.CompressedSize,
+                            true
+                        );
+                        break;
+                    default:
+                        throw new NotSupportedException(
+                            "CompressionMethod: " + Header.CompressionMethod
+                        );
+                }
+                return compressedStream;
+            }
+            return _stream.NotNull();
+        }
+
+        internal override Stream? GetRawStream() => _stream;
+    }
+}

src/SharpCompress/Common/Arc/ArcVolume.cs

@@ -0,0 +1,16 @@
+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) { }
+    }
+}

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,6 +50,8 @@ 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));
 }

src/SharpCompress/Common/ArchiveException.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ArchiveException : Exception
-{
-    public ArchiveException(string message)
-        : base(message) { }
-}

src/SharpCompress/Common/ArchiveType.cs

@@ -6,5 +6,6 @@ public enum ArchiveType
     Zip,
     Tar,
     SevenZip,
-    GZip
+    GZip,
+    Arc,
 }

src/SharpCompress/Common/CompressionType.cs

@@ -16,5 +16,17 @@ public enum CompressionType
     Unknown,
     Deflate64,
     Shrink,
-    Lzw
+    Lzw,
+    Reduce1,
+    Reduce2,
+    Reduce3,
+    Reduce4,
+    Explode,
+    Squeezed,
+    RLE90,
+    Crunched,
+    Squashed,
+    Crushed,
+    Distilled,
+    ZStandard,
 }

src/SharpCompress/Common/CryptographicException.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class CryptographicException : Exception
-{
-    public CryptographicException(string message)
-        : base(message) { }
-}

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;
+    public override string ToString() => Key ?? "Entry";
 
     internal abstract IEnumerable<FilePart> Parts { get; }
 

src/SharpCompress/Common/EntryStream.cs

@@ -1,11 +1,33 @@
 using System;
 using System.IO;
+using System.IO.Compression;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
-public class EntryStream : Stream
+public class EntryStream : Stream, IStreamStack
 {
+#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;
@@ -15,6 +37,9 @@ public class EntryStream : Stream
     {
         _reader = reader;
         _stream = stream;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(EntryStream));
+#endif
     }
 
     /// <summary>
@@ -32,11 +57,28 @@ public class EntryStream : Stream
         {
             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 (_isDisposed)
         {
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(EntryStream));
+#endif
         base.Dispose(disposing);
         _stream.Dispose();
     }
@@ -53,7 +95,7 @@ public class EntryStream : Stream
 
     public override long Position
     {
-        get => throw new NotSupportedException();
+        get => _stream.Position; //throw new NotSupportedException();
         set => throw new NotSupportedException();
     }
 

src/SharpCompress/Common/ExtractionException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ExtractionException : Exception
-{
-    public ExtractionException(string message)
-        : base(message) { }
-
-    public ExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/ExtractionMethods.cs

@@ -36,10 +36,12 @@ internal static class ExtractionMethods
 
         options ??= new ExtractionOptions() { Overwrite = true };
 
-        var file = Path.GetFileName(entry.Key);
+        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)!;
+            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))

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; }
 }

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.AsEnumerable<FilePart>();
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 
     internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
     {

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -34,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);

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 = 0)
+    public GZipVolume(Stream stream, ReaderOptions? options, int index)
         : base(stream, options, index) { }
 
     public GZipVolume(FileInfo fileInfo, ReaderOptions options)

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; }

src/SharpCompress/Common/IVolume.cs

@@ -6,5 +6,5 @@ public interface IVolume : IDisposable
 {
     int Index { get; }
 
-    string FileName { get; }
+    string? FileName { get; }
 }

src/SharpCompress/Common/IncompleteArchiveException.cs

@@ -1,7 +0,0 @@
-namespace SharpCompress.Common;
-
-public class IncompleteArchiveException : ArchiveException
-{
-    public IncompleteArchiveException(string message)
-        : base(message) { }
-}

src/SharpCompress/Common/InvalidFormatException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class InvalidFormatException : ExtractionException
-{
-    public InvalidFormatException(string message)
-        : base(message) { }
-
-    public InvalidFormatException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/MultiVolumeExtractionException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class MultiVolumeExtractionException : ExtractionException
-{
-    public MultiVolumeExtractionException(string message)
-        : base(message) { }
-
-    public MultiVolumeExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}

src/SharpCompress/Common/MultipartStreamRequiredException.cs

@@ -1,7 +0,0 @@
-namespace SharpCompress.Common;
-
-public class MultipartStreamRequiredException : ExtractionException
-{
-    public MultipartStreamRequiredException(string message)
-        : base(message) { }
-}

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;

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

@@ -1,8 +1,5 @@
 #nullable disable
 
-using System;
-using System.Security.Cryptography;
-using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;

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

@@ -1,9 +1,6 @@
-#nullable disable
-
 using System;
 using System.IO;
 using System.Linq;
-using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.IO;
 #if !Rar2017_64bit
@@ -18,7 +15,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) { }
@@ -121,7 +118,6 @@ internal class FileHeader : RarHeader
             switch (type)
             {
                 case FHEXTRA_CRYPT: // file encryption
-
                     {
                         Rar5CryptoInfo = new Rar5CryptoInfo(reader, true);
 
@@ -132,7 +128,6 @@ internal class FileHeader : RarHeader
                     }
                     break;
                 case FHEXTRA_HASH:
-
                     {
                         const uint FHEXTRA_HASH_BLAKE2 = 0x0;
                         //                        const uint HASH_BLAKE2 = 0x03;
@@ -146,7 +141,6 @@ internal class FileHeader : RarHeader
                     }
                     break;
                 case FHEXTRA_HTIME: // file time
-
                     {
                         var flags = reader.ReadRarVIntUInt16();
                         var isWindowsTime = (flags & 1) == 0;
@@ -171,7 +165,6 @@ internal class FileHeader : RarHeader
                 //                        }
                 //                        break;
                 case FHEXTRA_REDIR: // file system redirection
-
                     {
                         RedirType = reader.ReadRarVIntByte();
                         RedirFlags = reader.ReadRarVIntByte();
@@ -284,7 +277,6 @@ internal class FileHeader : RarHeader
         switch (HeaderCode)
         {
             case HeaderCodeV.RAR4_FILE_HEADER:
-
                 {
                     if (HasFlag(FileFlagsV4.UNICODE))
                     {
@@ -311,7 +303,6 @@ internal class FileHeader : RarHeader
                 }
                 break;
             case HeaderCodeV.RAR4_NEW_SUB_HEADER:
-
                 {
                     var datasize = HeaderSize - newLhdSize - nameSize;
                     if (HasFlag(FileFlagsV4.SALT))
@@ -325,6 +316,10 @@ internal class FileHeader : RarHeader
 
                     if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
                     {
+                        if (SubData is null)
+                        {
+                            throw new InvalidFormatException();
+                        }
                         RecoverySectors =
                             SubData[8]
                             + (SubData[9] << 8)
@@ -346,12 +341,16 @@ internal class FileHeader : RarHeader
             if (RemainingHeaderBytes(reader) >= 2)
             {
                 var extendedFlags = reader.ReadUInt16();
-                FileLastModifiedTime = ProcessExtendedTimeV4(
-                    extendedFlags,
-                    FileLastModifiedTime,
-                    reader,
-                    0
-                );
+                if (FileLastModifiedTime is not null)
+                {
+                    FileLastModifiedTime = ProcessExtendedTimeV4(
+                        extendedFlags,
+                        FileLastModifiedTime,
+                        reader,
+                        0
+                    );
+                }
+
                 FileCreatedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
                 FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
                 FileArchivedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
@@ -383,7 +382,7 @@ internal class FileHeader : RarHeader
             var dosTime = reader.ReadUInt32();
             time = Utility.DosDateToDateTime(dosTime);
         }
-        if ((rmode & 4) == 0)
+        if ((rmode & 4) == 0 && time is not null)
         {
             time = time.Value.AddSeconds(1);
         }
@@ -396,7 +395,11 @@ internal class FileHeader : RarHeader
         }
 
         //10^-7 to 10^-3
-        return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
+        if (time is not null)
+        {
+            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
+        }
+        return null;
     }
 
     private static string ConvertPathV4(string path)
@@ -412,13 +415,13 @@ internal class FileHeader : RarHeader
         return path;
     }
 
-    public override string ToString() => FileName;
+    public override string ToString() => FileName ?? "FileHeader";
 
     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;
@@ -447,22 +450,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);

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

@@ -13,7 +13,7 @@ public enum HeaderType : byte
     Sign,
     NewSub,
     EndArchive,
-    Crypt
+    Crypt,
 }
 
 internal static class HeaderCodeV

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

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
@@ -21,7 +20,7 @@ internal class RarHeader : IRarHeader
         {
             return new RarHeader(reader, isRar5, archiveEncoding);
         }
-        catch (EndOfStreamException)
+        catch (InvalidFormatException)
         {
             return null;
         }

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

@@ -1,7 +1,5 @@
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -98,13 +96,11 @@ public class RarHeaderFactory
                 switch (StreamingMode)
                 {
                     case StreamingMode.Seekable:
-
                         {
                             reader.BaseStream.Position += ph.DataSize;
                         }
                         break;
                     case StreamingMode.Streaming:
-
                         {
                             reader.BaseStream.Skip(ph.DataSize);
                         }
@@ -146,14 +142,12 @@ 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)
@@ -164,10 +158,15 @@ public class RarHeaderFactory
                             {
                                 fh.PackedStream = new RarCryptoWrapper(
                                     ms,
-                                    fh.R4Salt is null ? fh.Rar5CryptoInfo.Salt : fh.R4Salt,
                                     fh.R4Salt is null
-                                        ? new CryptKey5(Options.Password!, fh.Rar5CryptoInfo)
-                                        : new CryptKey3(Options.Password!)
+                                        ? fh.Rar5CryptoInfo.NotNull().Salt
+                                        : fh.R4Salt,
+                                    fh.R4Salt is null
+                                        ? new CryptKey5(
+                                            Options.Password,
+                                            fh.Rar5CryptoInfo.NotNull()
+                                        )
+                                        : new CryptKey3(Options.Password)
                                 );
                             }
                         }
@@ -204,14 +203,12 @@ 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);

src/SharpCompress/Common/Rar/RarCryptoWrapper.cs

@@ -70,11 +70,11 @@ internal sealed class RarCryptoWrapper : Stream
 
     protected override void Dispose(bool disposing)
     {
-        if (_rijndael != null)
+        if (disposing)
         {
             _rijndael.Dispose();
-            _rijndael = null!;
         }
+
         base.Dispose(disposing);
     }
 }

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, 0);
+    public override long Crc => BitConverter.ToUInt32(FileHeader.FileCrc.NotNull(), 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(

src/SharpCompress/Common/Rar/RarVolume.cs

@@ -15,17 +15,14 @@ namespace SharpCompress.Common.Rar;
 public abstract class RarVolume : Volume
 {
     private readonly RarHeaderFactory _headerFactory;
-    internal int _maxCompressionAlgorithm;
+    private int _maxCompressionAlgorithm;
 
-    internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options, int index = 0)
+    internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options, int index)
         : base(stream, options, index) => _headerFactory = new RarHeaderFactory(mode, options);
 
-#nullable disable
-    internal ArchiveHeader ArchiveHeader { get; private set; }
+    private ArchiveHeader? ArchiveHeader { get; set; }
 
-#nullable enable
-
-    internal StreamingMode Mode => _headerFactory.StreamingMode;
+    private StreamingMode Mode => _headerFactory.StreamingMode;
 
     internal abstract IEnumerable<RarFilePart> ReadFileParts();
 
@@ -39,19 +36,16 @@ 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)
@@ -63,14 +57,12 @@ 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];
-                            part.GetCompressedStream().Read(buffer, 0, buffer.Length);
+                            fh.PackedStream.NotNull().ReadFully(buffer);
                             Comment = Encoding.UTF8.GetString(buffer, 0, buffer.Length - 1);
                         }
                     }
@@ -105,7 +97,7 @@ public abstract class RarVolume : Volume
         get
         {
             EnsureArchiveHeaderLoaded();
-            return ArchiveHeader.IsFirstVolume;
+            return ArchiveHeader?.IsFirstVolume ?? false;
         }
     }
 
@@ -117,7 +109,7 @@ public abstract class RarVolume : Volume
         get
         {
             EnsureArchiveHeaderLoaded();
-            return ArchiveHeader.IsVolume;
+            return ArchiveHeader?.IsVolume ?? false;
         }
     }
 
@@ -130,7 +122,7 @@ public abstract class RarVolume : Volume
         get
         {
             EnsureArchiveHeaderLoaded();
-            return ArchiveHeader.IsSolid;
+            return ArchiveHeader?.IsSolid ?? false;
         }
     }
 

src/SharpCompress/Common/ReaderCancelledException.cs

@@ -1,12 +0,0 @@
-using System;
-
-namespace SharpCompress.Common;
-
-public class ReaderCancelledException : Exception
-{
-    public ReaderCancelledException(string message)
-        : base(message) { }
-
-    public ReaderCancelledException(string message, Exception inner)
-        : base(message, inner) { }
-}

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();

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -784,7 +784,7 @@ internal class ArchiveReader
                         );
                         break;
                     default:
-                        throw new InvalidOperationException();
+                        throw new InvalidFormatException();
                 }
             }
         }
@@ -843,7 +843,7 @@ internal class ArchiveReader
                 outStream.ReadExact(data, 0, data.Length);
                 if (outStream.ReadByte() >= 0)
                 {
-                    throw new InvalidOperationException("Decoded stream is longer than expected.");
+                    throw new InvalidFormatException("Decoded stream is longer than expected.");
                 }
                 dataVector.Add(data);
 
@@ -854,7 +854,7 @@ internal class ArchiveReader
                         != folder._unpackCrc
                     )
                     {
-                        throw new InvalidOperationException(
+                        throw new InvalidFormatException(
                             "Decoded stream does not match expected CRC."
                         );
                     }
@@ -996,6 +996,11 @@ 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
@@ -1220,23 +1225,46 @@ internal class ArchiveReader
 
     #region Public Methods
 
-    public void Open(Stream stream)
+    public void Open(Stream stream, bool lookForHeader)
     {
         Close();
 
         _streamOrigin = stream.Position;
         _streamEnding = stream.Length;
 
-        // TODO: Check Signature!
-        _header = new byte[0x20];
-        for (var offset = 0; offset < 0x20; )
+        var canScan = lookForHeader ? 0x80000 - 20 : 0;
+        while (true)
         {
-            var delta = stream.Read(_header, offset, 0x20 - offset);
-            if (delta == 0)
+            // TODO: Check Signature!
+            _header = new byte[0x20];
+            for (var offset = 0; offset < 0x20; )
             {
-                throw new EndOfStreamException();
+                var delta = stream.Read(_header, offset, 0x20 - offset);
+                if (delta == 0)
+                {
+                    throw new EndOfStreamException();
+                }
+
+                offset += delta;
             }
-            offset += delta;
+
+            if (
+                !lookForHeader
+                || _header
+                    .AsSpan(0, length: 6)
+                    .SequenceEqual<byte>([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])
+            )
+            {
+                break;
+            }
+
+            if (canScan == 0)
+            {
+                throw new InvalidFormatException("Unable to find 7z signature");
+            }
+
+            canScan--;
+            stream.Position = ++_streamOrigin;
         }
 
         _stream = stream;
@@ -1435,7 +1463,7 @@ internal class ArchiveReader
 #if DEBUG
             Log.WriteLine(_db._files[index].Name);
 #endif
-            if (_db._files[index].CrcDefined)
+            if (_db._files[index].Crc.HasValue)
             {
                 _stream = new CrcCheckStream(_db._files[index].Crc.Value);
             }

src/SharpCompress/Common/SevenZip/CFileItem.cs

@@ -8,18 +8,13 @@ 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; }

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,5 +38,8 @@ 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>();
 }

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -1,4 +1,3 @@
-using System;
 using System.IO;
 using System.Linq;
 using SharpCompress.IO;
@@ -41,7 +40,7 @@ internal class SevenZipFilePart : FilePart
     {
         if (!Header.HasStream)
         {
-            return null!;
+            return Stream.Null;
         }
         var folderStream = _database.GetFolderStream(_stream, Folder!, _database.PasswordProvider);
 
@@ -73,34 +72,24 @@ internal class SevenZipFilePart : FilePart
     private const uint K_PPMD = 0x030401;
     private const uint K_B_ZIP2 = 0x040202;
 
-    internal CompressionType GetCompression()
+    private CompressionType GetCompression()
     {
         if (Header.IsDir)
-            return CompressionType.None;
-
-        var coder = Folder!._coders.First();
-        switch (coder._methodId._id)
         {
-            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();
+            return CompressionType.None;
         }
+
+        var coder = Folder.NotNull()._coders.First();
+        return coder._methodId._id switch
+        {
+            K_LZMA or K_LZMA2 => CompressionType.LZMA,
+            K_PPMD => CompressionType.PPMd,
+            K_B_ZIP2 => CompressionType.BZip2,
+            _ => throw new InvalidFormatException(),
+        };
     }
 
     internal bool IsEncrypted =>
-        Header.IsDir
-            ? false
-            : Folder!._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
+        !Header.IsDir
+        && Folder?._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
 }

src/SharpCompress/Common/SharpCompressException.cs

@@ -0,0 +1,48 @@
+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) { }
+}

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',
 }

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

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Buffers.Binary;
 using System.IO;
@@ -13,8 +11,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; }
@@ -22,7 +20,7 @@ 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;
@@ -36,7 +34,9 @@ internal sealed class TarHeader
         WriteOctalBytes(0, buffer, 116, 8); // group ID
 
         //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
-        var nameByteCount = ArchiveEncoding.GetEncoding().GetByteCount(Name);
+        var nameByteCount = ArchiveEncoding
+            .GetEncoding()
+            .GetByteCount(Name.NotNull("Name is null"));
         if (nameByteCount > 100)
         {
             // Set mock filename and filetype to indicate the next block is the actual name of the file
@@ -46,7 +46,7 @@ internal sealed class TarHeader
         }
         else
         {
-            WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
+            WriteStringBytes(ArchiveEncoding.Encode(Name.NotNull("Name is null")), buffer, 100);
             WriteOctalBytes(Size, buffer, 124, 12);
             var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
             WriteOctalBytes(time, buffer, 136, 12);
@@ -77,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),
+                ArchiveEncoding.Encode(Name.NotNull("Name is null")),
                 0,
                 100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1)
             );
@@ -87,7 +87,7 @@ internal sealed class TarHeader
 
     private void WriteLongFilenameHeader(Stream output)
     {
-        var nameBytes = ArchiveEncoding.Encode(Name);
+        var nameBytes = ArchiveEncoding.Encode(Name.NotNull("Name is null"));
         output.Write(nameBytes, 0, nameBytes.Length);
 
         // pad to multiple of BlockSize bytes, and make sure a terminating null is added
@@ -101,57 +101,85 @@ internal sealed class TarHeader
 
     internal bool Read(BinaryReader reader)
     {
-        var buffer = ReadBlock(reader);
-        if (buffer.Length == 0)
+        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))
         {
             return false;
         }
 
-        // for symlinks, additionally read the linkname
-        if (ReadEntryType(buffer) == EntryType.SymLink)
-        {
-            LinkName = ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
-        }
-
-        if (ReadEntryType(buffer) == EntryType.LongName)
-        {
-            Name = ReadLongName(reader, buffer);
-            buffer = ReadBlock(reader);
-        }
-        else
-        {
-            Name = ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
-        }
-
-        EntryType = ReadEntryType(buffer);
+        Name = longName ?? ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
+        EntryType = entryType;
         Size = ReadSize(buffer);
 
+        // for symlinks, additionally read the linkname
+        if (entryType == EntryType.SymLink || entryType == EntryType.HardLink)
+        {
+            LinkName = longLinkName ?? ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
+        }
+
         Mode = ReadAsciiInt64Base8(buffer, 100, 7);
-        if (EntryType == EntryType.Directory)
+
+        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();
 
+        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);
-            namePrefix = namePrefix.TrimNulls();
+            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157).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;
     }
 
@@ -188,7 +216,7 @@ internal sealed class TarHeader
 
         if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
         {
-            throw new InvalidOperationException("Buffer is invalid size");
+            throw new InvalidFormatException("Buffer is invalid size");
         }
         return buffer;
     }
@@ -286,9 +314,45 @@ 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.
@@ -323,5 +387,5 @@ internal sealed class TarHeader
 
     public long? DataStartPosition { get; set; }
 
-    public string Magic { get; set; }
+    public string? Magic { get; set; }
 }

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -10,9 +8,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;
@@ -22,15 +20,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;
+    public override long CompressedSize => _filePart?.Header.Size ?? 0;
 
-    public override long Size => _filePart.Header.Size;
+    public override long Size => _filePart?.Header.Size ?? 0;
 
-    public override DateTime? LastModifiedTime => _filePart.Header.LastModifiedTime;
+    public override DateTime? LastModifiedTime => _filePart?.Header.LastModifiedTime;
 
     public override DateTime? CreatedTime => null;
 
@@ -40,17 +38,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;
+    public long Mode => _filePart?.Header.Mode ?? 0;
 
-    public long UserID => _filePart.Header.UserId;
+    public long UserID => _filePart?.Header.UserId ?? 0;
 
-    public long GroupId => _filePart.Header.GroupId;
+    public long GroupId => _filePart?.Header.GroupId ?? 0;
 
-    internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 
     internal static IEnumerable<TarEntry> GetEntries(
         StreamingMode mode,
@@ -59,17 +57,17 @@ public class TarEntry : Entry
         ArchiveEncoding archiveEncoding
     )
     {
-        foreach (var h in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
+        foreach (var header in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
         {
-            if (h != null)
+            if (header != null)
             {
                 if (mode == StreamingMode.Seekable)
                 {
-                    yield return new TarEntry(new TarFilePart(h, stream), compressionType);
+                    yield return new TarEntry(new TarFilePart(header, stream), compressionType);
                 }
                 else
                 {
-                    yield return new TarEntry(new TarFilePart(h, null), compressionType);
+                    yield return new TarEntry(new TarFilePart(header, null), compressionType);
                 }
             }
             else

src/SharpCompress/Common/Tar/TarFilePart.cs

@@ -5,9 +5,9 @@ namespace SharpCompress.Common.Tar;
 
 internal sealed class TarFilePart : FilePart
 {
-    private readonly Stream _seekableStream;
+    private readonly Stream? _seekableStream;
 
-    internal TarFilePart(TarHeader header, Stream seekableStream)
+    internal TarFilePart(TarHeader header, Stream? seekableStream)
         : base(header.ArchiveEncoding)
     {
         _seekableStream = seekableStream;
@@ -16,16 +16,16 @@ internal sealed class TarFilePart : FilePart
 
     internal TarHeader Header { get; }
 
-    internal override string FilePartName => Header.Name;
+    internal override string? FilePartName => Header?.Name;
 
     internal override Stream GetCompressedStream()
     {
         if (_seekableStream != null)
         {
-            _seekableStream.Position = Header.DataStartPosition!.Value;
+            _seekableStream.Position = Header.DataStartPosition ?? 0;
             return new TarReadOnlySubStream(_seekableStream, Header.Size);
         }
-        return Header.PackedStream;
+        return Header.PackedStream.NotNull();
     }
 
     internal override Stream? GetRawStream() => null;

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -28,7 +28,6 @@ internal static class TarHeaderFactory
                 switch (mode)
                 {
                     case StreamingMode.Seekable:
-
                         {
                             header.DataStartPosition = reader.BaseStream.Position;
 
@@ -37,7 +36,6 @@ internal static class TarHeaderFactory
                         }
                         break;
                     case StreamingMode.Streaming:
-
                         {
                             header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
                         }

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -4,13 +4,38 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar;
 
-internal class TarReadOnlySubStream : NonDisposingStream
+internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+
+    Stream IStreamStack.BaseStream() => base.Stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private bool _isDisposed;
     private long _amountRead;
 
     public TarReadOnlySubStream(Stream stream, long bytesToRead)
-        : base(stream, throwOnDispose: false) => BytesLeftToRead = bytesToRead;
+        : base(stream, leaveOpen: true, throwOnDispose: false)
+    {
+        BytesLeftToRead = bytesToRead;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(TarReadOnlySubStream));
+#endif
+    }
 
     protected override void Dispose(bool disposing)
     {
@@ -20,7 +45,9 @@ internal class TarReadOnlySubStream : NonDisposingStream
         }
 
         _isDisposed = true;
-
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(TarReadOnlySubStream));
+#endif
         if (disposing)
         {
             // Ensure we read all remaining blocks for this entry.

src/SharpCompress/Common/Volume.cs

@@ -7,16 +7,22 @@ namespace SharpCompress.Common;
 
 public abstract class Volume : IVolume
 {
+    private readonly Stream _baseStream;
     private readonly Stream _actualStream;
 
-    internal Volume(Stream stream, ReaderOptions readerOptions, int index = 0)
+    internal Volume(Stream stream, ReaderOptions? readerOptions, int index = 0)
     {
         Index = index;
-        ReaderOptions = readerOptions;
-        if (readerOptions.LeaveStreamOpen)
+        ReaderOptions = readerOptions ?? new ReaderOptions();
+        _baseStream = stream;
+        if (ReaderOptions.LeaveStreamOpen)
         {
-            stream = NonDisposingStream.Create(stream);
+            stream = SharpCompressStream.Create(stream, leaveOpen: true);
         }
+
+        if (stream is IStreamStack ss)
+            ss.SetBuffer(ReaderOptions.BufferSize, true);
+
         _actualStream = stream;
     }
 
@@ -32,7 +38,7 @@ public abstract class Volume : IVolume
 
     public virtual int Index { get; internal set; }
 
-    public string FileName => (_actualStream as FileStream)?.Name!;
+    public string? FileName => (_baseStream as FileStream)?.Name;
 
     /// <summary>
     /// RarArchive is part of a multi-part archive.

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

@@ -123,11 +123,7 @@ internal class DirectoryEntryHeader : ZipFileEntry
 
     public long RelativeOffsetOfEntryHeader { get; set; }
 
-    public uint ExternalFileAttributes { get; set; }
-
     public ushort InternalFileAttributes { get; set; }
 
     public ushort DiskNumberStart { get; set; }
-
-    public string? Comment { get; private set; }
 }

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

@@ -13,5 +13,5 @@ internal enum HeaderFlags : ushort
     EnhancedDeflate = 16,
 
     //Bit 11: Language encoding flag
-    Efs = 2048
+    Efs = 2048,
 }

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

@@ -14,7 +14,7 @@ internal enum ExtraDataType : ushort
     // -Info-ZIP Unicode Path Extra Field
     UnicodePathExtraField = 0x7075,
     Zip64ExtendedInformationExtraField = 0x0001,
-    UnixTimeExtraField = 0x5455
+    UnixTimeExtraField = 0x5455,
 }
 
 internal class ExtraData
@@ -166,10 +166,10 @@ internal sealed class UnixTimeExtraField : ExtraData
                 return Tuple.Create<DateTime?, DateTime?, DateTime?>(null, null, null);
             }
 
-            var flags = DataBytes[0];
-            var isModifiedTimeSpecified = (flags & 0x01) == 1;
-            var isLastAccessTimeSpecified = (flags & 0x02) == 1;
-            var isCreationTimeSpecified = (flags & 0x04) == 1;
+            var flags = (RecordedTimeFlag)DataBytes[0];
+            var isModifiedTimeSpecified = flags.HasFlag(RecordedTimeFlag.LastModified);
+            var isLastAccessTimeSpecified = flags.HasFlag(RecordedTimeFlag.LastAccessed);
+            var isCreationTimeSpecified = flags.HasFlag(RecordedTimeFlag.Created);
             var currentIndex = 1;
             DateTime? modifiedTime = null;
             DateTime? lastAccessTime = null;
@@ -189,7 +189,7 @@ internal sealed class UnixTimeExtraField : ExtraData
             {
                 if (currentIndex + 4 > DataBytes.Length)
                 {
-                    throw new ArchiveException("Invalid UnicodeExtraTime field");
+                    return Tuple.Create<DateTime?, DateTime?, DateTime?>(null, null, null);
                 }
 
                 var lastAccessEpochTime = BinaryPrimitives.ReadInt32LittleEndian(
@@ -206,7 +206,7 @@ internal sealed class UnixTimeExtraField : ExtraData
             {
                 if (currentIndex + 4 > DataBytes.Length)
                 {
-                    throw new ArchiveException("Invalid UnicodeExtraTime field");
+                    return Tuple.Create<DateTime?, DateTime?, DateTime?>(null, null, null);
                 }
 
                 var creationTimeEpochTime = BinaryPrimitives.ReadInt32LittleEndian(
@@ -222,6 +222,15 @@ internal sealed class UnixTimeExtraField : ExtraData
             return Tuple.Create(modifiedTime, lastAccessTime, creationTime);
         }
     }
+
+    [Flags]
+    private enum RecordedTimeFlag
+    {
+        None = 0,
+        LastModified = 1,
+        LastAccessed = 2,
+        Created = 4,
+    }
 }
 
 internal static class LocalEntryHeaderExtraFactory
@@ -229,11 +238,14 @@ internal static class LocalEntryHeaderExtraFactory
     internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extraData) =>
         type switch
         {
-            ExtraDataType.UnicodePathExtraField
-                => new ExtraUnicodePathExtraField(type, length, extraData),
-            ExtraDataType.Zip64ExtendedInformationExtraField
-                => new Zip64ExtendedInformationExtraField(type, length, extraData),
+            ExtraDataType.UnicodePathExtraField => new ExtraUnicodePathExtraField(
+                type,
+                length,
+                extraData
+            ),
+            ExtraDataType.Zip64ExtendedInformationExtraField =>
+                new Zip64ExtendedInformationExtraField(type, length, extraData),
             ExtraDataType.UnixTimeExtraField => new UnixTimeExtraField(type, length, extraData),
-            _ => new ExtraData(type, length, extraData)
+            _ => new ExtraData(type, length, extraData),
         };
 }

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

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
@@ -20,21 +18,21 @@ internal abstract class ZipFileEntry : ZipHeader
     {
         get
         {
-            if (Name.EndsWith('/'))
+            if (Name?.EndsWith('/') ?? false)
             {
                 return true;
             }
 
             //.NET Framework 4.5 : System.IO.Compression::CreateFromDirectory() probably writes backslashes to headers
-            return CompressedSize == 0 && UncompressedSize == 0 && Name.EndsWith('\\');
+            return CompressedSize == 0 && UncompressedSize == 0 && (Name?.EndsWith('\\') ?? false);
         }
     }
 
-    internal Stream PackedStream { get; set; }
+    internal Stream? PackedStream { get; set; }
 
     internal ArchiveEncoding ArchiveEncoding { get; }
 
-    internal string Name { get; set; }
+    internal string? Name { get; set; }
 
     internal HeaderFlags Flags { get; set; }
 
@@ -48,7 +46,7 @@ internal abstract class ZipFileEntry : ZipHeader
 
     internal List<ExtraData> Extra { get; set; }
 
-    public string Password { get; set; }
+    public string? Password { get; set; }
 
     internal PkwareTraditionalEncryptionData ComposeEncryptionData(Stream archiveStream)
     {
@@ -65,7 +63,7 @@ internal abstract class ZipFileEntry : ZipHeader
         return encryptionData;
     }
 
-    internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
+    internal WinzipAesEncryptionData? WinzipAesEncryptionData { get; set; }
 
     /// <summary>
     /// The last modified date as read from the Local or Central Directory header.
@@ -93,8 +91,15 @@ internal abstract class ZipFileEntry : ZipHeader
 
     protected void LoadExtra(byte[] extra)
     {
-        for (var i = 0; i < extra.Length - 4; )
+        for (var i = 0; i < extra.Length; )
         {
+            // Ensure we have at least a header (2-byte ID + 2-byte length)
+            if (i + 4 > extra.Length)
+            {
+                // Incomplete header — stop parsing extras
+                break;
+            }
+
             var type = (ExtraDataType)BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i));
             if (!Enum.IsDefined(typeof(ExtraDataType), type))
             {
@@ -108,7 +113,17 @@ internal abstract class ZipFileEntry : ZipHeader
             if (length > extra.Length)
             {
                 // bad extras block
-                return;
+                break; // allow processing optional other blocks
+            }
+            // Some ZIP files contain vendor-specific or malformed extra fields where the declared
+            // data length extends beyond the remaining buffer. This adjustment ensures that
+            // we only read data within bounds (i + 4 + length <= extra.Length)
+            // The example here is: 41 43 18 00 41 52 43 30 46 EB FF FF 51 29 03 C6 03 00 00 00 00 00 00 00 00
+            // No existing zip utility uses 0x4341 ('AC')
+            if (i + 4 + length > extra.Length)
+            {
+                // incomplete or corrupt field
+                break; // allow processing optional other blocks
             }
 
             var data = new byte[length];
@@ -119,7 +134,11 @@ internal abstract class ZipFileEntry : ZipHeader
         }
     }
 
-    internal ZipFilePart Part { get; set; }
+    internal ZipFilePart? Part { get; set; }
 
     internal bool IsZip64 => CompressedSize >= uint.MaxValue;
+
+    internal uint ExternalFileAttributes { get; set; }
+
+    internal string? Comment { get; set; }
 }

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

@@ -8,5 +8,5 @@ internal enum ZipHeaderType
     DirectoryEnd,
     Split,
     Zip64DirectoryEnd,
-    Zip64DirectoryEndLocator
+    Zip64DirectoryEndLocator,
 }

src/SharpCompress/Common/Zip/PkwareTraditionalCryptoStream.cs

@@ -1,16 +1,37 @@
 using System;
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
 internal enum CryptoMode
 {
     Encrypt,
-    Decrypt
+    Decrypt,
 }
 
-internal class PkwareTraditionalCryptoStream : Stream
+internal class PkwareTraditionalCryptoStream : Stream, IStreamStack
 {
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { return; }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { return; }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
     private readonly PkwareTraditionalEncryptionData _encryptor;
     private readonly CryptoMode _mode;
     private readonly Stream _stream;
@@ -25,6 +46,10 @@ internal class PkwareTraditionalCryptoStream : Stream
         _encryptor = encryptor;
         _stream = stream;
         _mode = mode;
+
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(PkwareTraditionalCryptoStream));
+#endif
     }
 
     public override bool CanRead => (_mode == CryptoMode.Decrypt);
@@ -100,6 +125,9 @@ internal class PkwareTraditionalCryptoStream : Stream
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(PkwareTraditionalCryptoStream));
+#endif
         base.Dispose(disposing);
         _stream.Dispose();
     }

src/SharpCompress/Common/Zip/PkwareTraditionalEncryptionData.cs

@@ -103,7 +103,7 @@ internal class PkwareTraditionalEncryptionData
 
     internal byte[] StringToByteArray(string value)
     {
-        var a = _archiveEncoding.Password.GetBytes(value);
+        var a = _archiveEncoding.GetPasswordEncoding().GetBytes(value);
         return a;
     }
 

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -1,6 +1,5 @@
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
-using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
@@ -8,18 +7,13 @@ internal class SeekableZipFilePart : ZipFilePart
 {
     private bool _isLocalHeaderLoaded;
     private readonly SeekableZipHeaderFactory _headerFactory;
-    private readonly DirectoryEntryHeader _directoryEntryHeader;
 
     internal SeekableZipFilePart(
         SeekableZipHeaderFactory headerFactory,
         DirectoryEntryHeader header,
         Stream stream
     )
-        : base(header, stream)
-    {
-        _headerFactory = headerFactory;
-        _directoryEntryHeader = header;
-    }
+        : base(header, stream) => _headerFactory = headerFactory;
 
     internal override Stream GetCompressedStream()
     {
@@ -31,28 +25,12 @@ internal class SeekableZipFilePart : ZipFilePart
         return base.GetCompressedStream();
     }
 
-    internal string? Comment => ((DirectoryEntryHeader)Header).Comment;
-
-    private void LoadLocalHeader()
-    {
-        var hasData = Header.HasData;
-        Header = _headerFactory.GetLocalHeader(BaseStream, ((DirectoryEntryHeader)Header));
-        Header.HasData = hasData;
-    }
+    private void LoadLocalHeader() =>
+        Header = _headerFactory.GetLocalHeader(BaseStream, (DirectoryEntryHeader)Header);
 
     protected override Stream CreateBaseStream()
     {
-        BaseStream.Position = Header.DataStartPosition!.Value;
-
-        if (
-            (Header.CompressedSize == 0)
-            && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)
-            && (_directoryEntryHeader?.HasData == true)
-            && (_directoryEntryHeader?.CompressedSize != 0)
-        )
-        {
-            return new ReadOnlySubStream(BaseStream, _directoryEntryHeader!.CompressedSize);
-        }
+        BaseStream.Position = Header.DataStartPosition.NotNull();
 
         return BaseStream;
     }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -149,6 +149,18 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
         {
             throw new InvalidOperationException();
         }
+
+        // populate fields only known from the DirectoryEntryHeader
+        localEntryHeader.HasData = directoryEntryHeader.HasData;
+        localEntryHeader.ExternalFileAttributes = directoryEntryHeader.ExternalFileAttributes;
+        localEntryHeader.Comment = directoryEntryHeader.Comment;
+
+        if (FlagUtility.HasFlag(localEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
+        {
+            localEntryHeader.Crc = directoryEntryHeader.Crc;
+            localEntryHeader.CompressedSize = directoryEntryHeader.CompressedSize;
+            localEntryHeader.UncompressedSize = directoryEntryHeader.UncompressedSize;
+        }
         return localEntryHeader;
     }
 }

src/SharpCompress/Common/Zip/StreamingZipFilePart.cs

@@ -1,5 +1,4 @@
 using System.IO;
-using System.Net.Sockets;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
@@ -13,7 +12,7 @@ internal sealed class StreamingZipFilePart : ZipFilePart
     internal StreamingZipFilePart(ZipFileEntry header, Stream stream)
         : base(header, stream) { }
 
-    protected override Stream CreateBaseStream() => Header.PackedStream;
+    protected override Stream CreateBaseStream() => Header.PackedStream.NotNull();
 
     internal override Stream GetCompressedStream()
     {
@@ -27,12 +26,12 @@ internal sealed class StreamingZipFilePart : ZipFilePart
         );
         if (LeaveStreamOpen)
         {
-            return NonDisposingStream.Create(_decompressionStream);
+            return SharpCompressStream.Create(_decompressionStream, leaveOpen: true);
         }
         return _decompressionStream;
     }
 
-    internal BinaryReader FixStreamedFileLocation(ref RewindableStream rewindableStream)
+    internal BinaryReader FixStreamedFileLocation(ref SharpCompressStream rewindableStream)
     {
         if (Header.IsDirectory)
         {
@@ -50,7 +49,7 @@ internal sealed class StreamingZipFilePart : ZipFilePart
 
             if (_decompressionStream is DeflateStream deflateStream)
             {
-                rewindableStream.Rewind(deflateStream.InputBuffer);
+                ((IStreamStack)rewindableStream).StackSeek(0);
             }
 
             Skipped = true;

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -19,16 +20,24 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
 
     internal IEnumerable<ZipHeader> ReadStreamHeader(Stream stream)
     {
-        RewindableStream rewindableStream;
+        if (stream is not SharpCompressStream) //ensure the stream is already a SharpCompressStream. So the buffer/size will already be set
+        {
+            //the original code wrapped this with RewindableStream. Wrap with SharpCompressStream as we can get the buffer size
+            if (stream is SourceStream src)
+            {
+                stream = new SharpCompressStream(
+                    stream,
+                    src.ReaderOptions.LeaveStreamOpen,
+                    bufferSize: src.ReaderOptions.BufferSize
+                );
+            }
+            else
+            {
+                throw new ArgumentException("Stream must be a SharpCompressStream", nameof(stream));
+            }
+        }
+        SharpCompressStream rewindableStream = (SharpCompressStream)stream;
 
-        if (stream is RewindableStream rs)
-        {
-            rewindableStream = rs;
-        }
-        else
-        {
-            rewindableStream = new RewindableStream(stream);
-        }
         while (true)
         {
             ZipHeader? header;
@@ -36,16 +45,18 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
             uint headerBytes = 0;
             if (
                 _lastEntryHeader != null
-                && (
-                    FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)
-                    || _lastEntryHeader.IsZip64
-                )
+                && FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)
             )
             {
-                reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(
-                    ref rewindableStream
-                );
+                if (_lastEntryHeader.Part is null)
+                {
+                    continue;
+                }
+
+                // removed requirement for FixStreamedFileLocation()
+
                 var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
+
                 var crc = reader.ReadUInt32();
                 if (crc == POST_DATA_DESCRIPTOR)
                 {
@@ -53,12 +64,69 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 }
                 _lastEntryHeader.Crc = crc;
 
+                //attempt 32bit read
+                ulong compSize = reader.ReadUInt32();
+                ulong uncompSize = reader.ReadUInt32();
+                headerBytes = reader.ReadUInt32();
+
+                //check for zip64 sentinel or unexpected header
+                bool isSentinel = compSize == 0xFFFFFFFF || uncompSize == 0xFFFFFFFF;
+                bool isHeader = headerBytes == 0x04034b50 || headerBytes == 0x02014b50;
+
+                if (!isHeader && !isSentinel)
+                {
+                    //reshuffle into 64-bit values
+                    compSize = (uncompSize << 32) | compSize;
+                    uncompSize = ((ulong)headerBytes << 32) | reader.ReadUInt32();
+                    headerBytes = reader.ReadUInt32();
+                }
+                else if (isSentinel)
+                {
+                    //standards-compliant zip64 descriptor
+                    compSize = reader.ReadUInt64();
+                    uncompSize = reader.ReadUInt64();
+                }
+
+                _lastEntryHeader.CompressedSize = (long)compSize;
+                _lastEntryHeader.UncompressedSize = (long)uncompSize;
+
+                if (pos.HasValue)
+                {
+                    _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
+                }
+            }
+            else if (_lastEntryHeader != null && _lastEntryHeader.IsZip64)
+            {
+                if (_lastEntryHeader.Part is null)
+                    continue;
+
+                //reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(
+                //    ref rewindableStream
+                //);
+
+                var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
+
+                headerBytes = reader.ReadUInt32();
+
+                var version = reader.ReadUInt16();
+                var flags = (HeaderFlags)reader.ReadUInt16();
+                var compressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
+                var lastModifiedDate = reader.ReadUInt16();
+                var lastModifiedTime = reader.ReadUInt16();
+
+                var crc = reader.ReadUInt32();
+
+                if (crc == POST_DATA_DESCRIPTOR)
+                {
+                    crc = reader.ReadUInt32();
+                }
+                _lastEntryHeader.Crc = crc;
+
                 // The DataDescriptor can be either 64bit or 32bit
                 var compressed_size = reader.ReadUInt32();
                 var uncompressed_size = reader.ReadUInt32();
 
                 // Check if we have header or 64bit DataDescriptor
-                headerBytes = reader.ReadUInt32();
                 var test_header = !(headerBytes == 0x04034b50 || headerBytes == 0x02014b50);
 
                 var test_64bit = ((long)uncompressed_size << 32) | compressed_size;
@@ -76,6 +144,9 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 if (pos.HasValue)
                 {
                     _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
+
+                    // 4 = First 4 bytes of the entry header (i.e. 50 4B 03 04)
+                    rewindableStream.Position = pos.Value + 4;
                 }
             }
             else
@@ -116,16 +187,11 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
                 } // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
                 else if (local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor))
                 {
-                    var isRecording = rewindableStream.IsRecording;
-                    if (!isRecording)
-                    {
-                        rewindableStream.StartRecording();
-                    }
                     var nextHeaderBytes = reader.ReadUInt32();
+                    ((IStreamStack)rewindableStream).Rewind(sizeof(uint));
 
                     // Check if next data is PostDataDescriptor, streamed file with 0 length
                     header.HasData = !IsHeader(nextHeaderBytes);
-                    rewindableStream.Rewind(!isRecording);
                 }
                 else // We are not streaming and compressed size is 0, we have no data
                 {

src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs

@@ -2,11 +2,32 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Security.Cryptography;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip;
 
-internal class WinzipAesCryptoStream : Stream
+internal class WinzipAesCryptoStream : Stream, IStreamStack
 {
+#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 const int BLOCK_SIZE_IN_BYTES = 16;
     private readonly SymmetricAlgorithm _cipher;
     private readonly byte[] _counter = new byte[BLOCK_SIZE_IN_BYTES];
@@ -27,6 +48,10 @@ internal class WinzipAesCryptoStream : Stream
         _stream = stream;
         _totalBytesLeftToRead = length;
 
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(WinzipAesCryptoStream));
+#endif
+
         _cipher = CreateCipher(winzipAesEncryptionData);
 
         var iv = new byte[BLOCK_SIZE_IN_BYTES];
@@ -64,6 +89,9 @@ internal class WinzipAesCryptoStream : Stream
             return;
         }
         _isDisposed = true;
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(WinzipAesCryptoStream));
+#endif
         if (disposing)
         {
             //read out last 10 auth bytes