Enabling Bzip2 but something else is broken

fixed read only sub stream
More fixes?
2026-02-04 13:34:59 +00:00 · 2021-02-21 18:01:56 +00:00 · 2021-02-21 13:37:58 +00:00 · 2021-02-21 13:21:33 +00:00 · 2021-02-21 12:14:07 +00:00 · 2021-02-21 12:10:17 +00:00
484 changed files with 48823 additions and 62299 deletions
--- a/.config/dotnet-tools.json
+++ b/.config/dotnet-tools.json
@@ -2,10 +2,10 @@
  "version": 1,
  "isRoot": true,
  "tools": {
-    "csharpier": {
-      "version": "0.25.0",
+    "dotnet-format": {
+      "version": "4.1.131201",
      "commands": [
-        "dotnet-csharpier"
+        "dotnet-format"
      ]
    }
  }
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,557 +0,0 @@
-# Version: 2.0.1 (Using https://semver.org/)
-# Updated: 2020-12-11
-# See https://github.com/RehanSaeed/EditorConfig/releases for release notes.
-# See https://github.com/RehanSaeed/EditorConfig for updates to this file.
-# See http://EditorConfig.org for more information about .editorconfig files.
-
-##########################################
-# Common Settings
-##########################################
-
-# This file is the top-most EditorConfig file
-root = true
-
-# All Files
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 4
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-##########################################
-# File Extension Settings
-##########################################
-
-# Visual Studio Solution Files
-[*.sln]
-indent_style = tab
-
-# Visual Studio XML Project Files
-[*.{csproj,vbproj,vcxproj.filters,proj,projitems,shproj}]
-indent_size = 2
-
-# XML Configuration Files
-[*.{xml,config,props,targets,nuspec,resx,ruleset,vsixmanifest,vsct}]
-indent_size = 2
-
-# JSON Files
-[*.{json,json5,webmanifest}]
-indent_size = 2
-
-# YAML Files
-[*.{yml,yaml}]
-indent_size = 2
-
-# Markdown Files
-[*.md]
-trim_trailing_whitespace = false
-
-# Web Files
-[*.{htm,html,js,jsm,ts,tsx,css,sass,scss,less,svg,vue}]
-indent_size = 2
-
-# Batch Files
-[*.{cmd,bat}]
-end_of_line = crlf
-
-# Bash Files
-[*.sh]
-end_of_line = lf
-
-# Makefiles
-[Makefile]
-indent_style = tab
-
-##########################################
-# Default .NET Code Style Severities
-# https://docs.microsoft.com/dotnet/fundamentals/code-analysis/configuration-options#scope
-##########################################
-
-[*.{cs,csx,cake,vb,vbx}]
-# Default Severity for all .NET Code Style rules below
-dotnet_analyzer_diagnostic.severity = warning
-
-##########################################
-# File Header (Uncomment to support file headers)
-# https://docs.microsoft.com/visualstudio/ide/reference/add-file-header
-##########################################
-
-# [*.{cs,csx,cake,vb,vbx}]
-# file_header_template = <copyright file="{fileName}" company="PROJECT-AUTHOR">\n© PROJECT-AUTHOR\n</copyright>
-
-# SA1636: File header copyright text should match
-# Justification: .editorconfig supports file headers. If this is changed to a value other than "none", a stylecop.json file will need to added to the project.
-# dotnet_diagnostic.SA1636.severity = none
-
-##########################################
-# .NET Language Conventions
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions
-##########################################
-
-# .NET Code Style Settings
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#net-code-style-settings
-[*.{cs,csx,cake,vb,vbx}]
-# "this." and "Me." qualifiers
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#this-and-me
-#dotnet_style_qualification_for_field = true:warning
-#dotnet_style_qualification_for_property = true:warning
-#dotnet_style_qualification_for_method = true:warning
-#dotnet_style_qualification_for_event = true:warning
-# Language keywords instead of framework type names for type references
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#language-keywords
-dotnet_style_predefined_type_for_locals_parameters_members = true:warning
-dotnet_style_predefined_type_for_member_access = true:warning
-# Modifier preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#normalize-modifiers
-dotnet_style_require_accessibility_modifiers = always:warning
-csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
-visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:warning
-dotnet_style_readonly_field = true:warning
-# Parentheses preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parentheses-preferences
-dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning
-dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning
-dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
-dotnet_style_parentheses_in_other_operators = always_for_clarity:suggestion
-# Expression-level preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
-dotnet_style_object_initializer = true:warning
-dotnet_style_collection_initializer = true:warning
-dotnet_style_explicit_tuple_names = true:warning
-dotnet_style_prefer_inferred_tuple_names = true:warning
-dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
-dotnet_style_prefer_auto_properties = true:warning
-dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
-dotnet_style_prefer_conditional_expression_over_assignment = false:suggestion
-dotnet_diagnostic.IDE0045.severity = suggestion
-dotnet_style_prefer_conditional_expression_over_return = false:suggestion
-dotnet_diagnostic.IDE0046.severity = suggestion
-dotnet_style_prefer_compound_assignment = true:warning
-# Null-checking preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#null-checking-preferences
-dotnet_style_coalesce_expression = true:warning
-dotnet_style_null_propagation = true:warning
-# Parameter preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parameter-preferences
-dotnet_code_quality_unused_parameters = all:warning
-# More style options (Undocumented)
-# https://github.com/MicrosoftDocs/visualstudio-docs/issues/3641
-dotnet_style_operator_placement_when_wrapping = end_of_line
-# https://github.com/dotnet/roslyn/pull/40070
-dotnet_style_prefer_simplified_interpolation = true:warning
-
-# C# Code Style Settings
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-code-style-settings
-[*.{cs,csx,cake}]
-# Implicit and explicit types
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#implicit-and-explicit-types
-csharp_style_var_for_built_in_types = true:warning
-csharp_style_var_when_type_is_apparent = true:warning
-csharp_style_var_elsewhere = true:warning
-# Expression-bodied members
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-bodied-members
-csharp_style_expression_bodied_methods = true:warning
-csharp_style_expression_bodied_constructors = true:warning
-csharp_style_expression_bodied_operators = true:warning
-csharp_style_expression_bodied_properties = true:warning
-csharp_style_expression_bodied_indexers = true:warning
-csharp_style_expression_bodied_accessors = true:warning
-csharp_style_expression_bodied_lambdas = true:warning
-csharp_style_expression_bodied_local_functions = true:warning
-# Pattern matching
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#pattern-matching
-csharp_style_pattern_matching_over_is_with_cast_check = true:warning
-csharp_style_pattern_matching_over_as_with_null_check = true:warning
-# Inlined variable declarations
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#inlined-variable-declarations
-csharp_style_inlined_variable_declaration = true:warning
-# Expression-level preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
-csharp_prefer_simple_default_expression = true:warning
-# "Null" checking preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-null-checking-preferences
-csharp_style_throw_expression = true:warning
-csharp_style_conditional_delegate_call = true:warning
-# Code block preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#code-block-preferences
-csharp_prefer_braces = true:warning
-# Unused value preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#unused-value-preferences
-csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
-dotnet_diagnostic.IDE0058.severity = suggestion
-csharp_style_unused_value_assignment_preference = discard_variable:suggestion
-dotnet_diagnostic.IDE0059.severity = suggestion
-# Index and range preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#index-and-range-preferences
-csharp_style_prefer_index_operator = true:warning
-csharp_style_prefer_range_operator = true:warning
-# Miscellaneous preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#miscellaneous-preferences
-csharp_style_deconstructed_variable_declaration = true:warning
-csharp_style_pattern_local_over_anonymous_function = true:warning
-csharp_using_directive_placement = outside_namespace:warning
-csharp_prefer_static_local_function = true:warning
-csharp_prefer_simple_using_statement = true:suggestion
-dotnet_diagnostic.IDE0063.severity = suggestion
-
-##########################################
-# .NET Formatting Conventions
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-code-style-settings-reference#formatting-conventions
-##########################################
-
-# Organize usings
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#organize-using-directives
-dotnet_sort_system_directives_first = true
-# Newline options
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#new-line-options
-csharp_new_line_before_open_brace = all
-csharp_new_line_before_else = true
-csharp_new_line_before_catch = true
-csharp_new_line_before_finally = true
-csharp_new_line_before_members_in_object_initializers = true
-csharp_new_line_before_members_in_anonymous_types = true
-csharp_new_line_between_query_expression_clauses = true
-# Indentation options
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#indentation-options
-csharp_indent_case_contents = true
-csharp_indent_switch_labels = true
-csharp_indent_labels = no_change
-csharp_indent_block_contents = true
-csharp_indent_braces = false
-csharp_indent_case_contents_when_block = false
-# Spacing options
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#spacing-options
-csharp_space_after_cast = false
-csharp_space_after_keywords_in_control_flow_statements = true
-csharp_space_between_parentheses = false
-csharp_space_before_colon_in_inheritance_clause = true
-csharp_space_after_colon_in_inheritance_clause = true
-csharp_space_around_binary_operators = before_and_after
-csharp_space_between_method_declaration_parameter_list_parentheses = false
-csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
-csharp_space_between_method_declaration_name_and_open_parenthesis = false
-csharp_space_between_method_call_parameter_list_parentheses = false
-csharp_space_between_method_call_empty_parameter_list_parentheses = false
-csharp_space_between_method_call_name_and_opening_parenthesis = false
-csharp_space_after_comma = true
-csharp_space_before_comma = false
-csharp_space_after_dot = false
-csharp_space_before_dot = false
-csharp_space_after_semicolon_in_for_statement = true
-csharp_space_before_semicolon_in_for_statement = false
-csharp_space_around_declaration_statements = false
-csharp_space_before_open_square_brackets = false
-csharp_space_between_empty_square_brackets = false
-csharp_space_between_square_brackets = false
-# Wrapping options
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#wrap-options
-csharp_preserve_single_line_statements = false
-csharp_preserve_single_line_blocks = true
-
-csharp_style_namespace_declarations = file_scoped
-
-##########################################
-# .NET Naming Conventions
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-naming-conventions
-##########################################
-
-[*.{cs,csx,cake,vb,vbx}]
-dotnet_diagnostic.CA1000.severity = suggestion
-dotnet_diagnostic.CA1001.severity = error
-dotnet_diagnostic.CA1018.severity = error
-dotnet_diagnostic.CA1036.severity = silent
-dotnet_diagnostic.CA1051.severity = suggestion
-dotnet_diagnostic.CA1068.severity = error
-dotnet_diagnostic.CA1069.severity = error
-dotnet_diagnostic.CA1304.severity = error
-dotnet_diagnostic.CA1305.severity = suggestion
-dotnet_diagnostic.CA1307.severity = suggestion
-dotnet_diagnostic.CA1309.severity = suggestion
-dotnet_diagnostic.CA1310.severity = error
-dotnet_diagnostic.CA1707.severity = suggestion
-dotnet_diagnostic.CA1708.severity = suggestion
-dotnet_diagnostic.CA1711.severity = suggestion
-dotnet_diagnostic.CA1716.severity = suggestion
-dotnet_diagnostic.CA1720.severity = suggestion
-dotnet_diagnostic.CA1725.severity = suggestion
-dotnet_diagnostic.CA1805.severity = suggestion
-dotnet_diagnostic.CA1816.severity = suggestion
-dotnet_diagnostic.CA1822.severity = suggestion
-dotnet_diagnostic.CA1825.severity = error
-dotnet_diagnostic.CA1826.severity = silent
-dotnet_diagnostic.CA1827.severity = error
-dotnet_diagnostic.CA1829.severity = suggestion
-dotnet_diagnostic.CA1834.severity = error
-dotnet_diagnostic.CA1845.severity = suggestion
-dotnet_diagnostic.CA1848.severity = suggestion
-dotnet_diagnostic.CA1852.severity = suggestion
-dotnet_diagnostic.CA2016.severity = suggestion
-dotnet_diagnostic.CA2201.severity = error
-dotnet_diagnostic.CA2206.severity = error
-dotnet_diagnostic.CA2208.severity = error
-dotnet_diagnostic.CA2211.severity = error
-dotnet_diagnostic.CA2249.severity = error
-dotnet_diagnostic.CA2251.severity = error
-dotnet_diagnostic.CA2252.severity = none
-dotnet_diagnostic.CA2254.severity = suggestion
-
-dotnet_diagnostic.CS0169.severity = error
-dotnet_diagnostic.CS0219.severity = error
-dotnet_diagnostic.CS0649.severity = suggestion
-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.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
-
-dotnet_diagnostic.MVC1000.severity = suggestion
-
-dotnet_diagnostic.RZ10012.severity = error
-
-dotnet_diagnostic.IDE0004.severity = error # redundant cast
-dotnet_diagnostic.IDE0005.severity = error
-dotnet_diagnostic.IDE0007.severity = error # Use var
-dotnet_diagnostic.IDE0011.severity = error # Use braces on if statements
-dotnet_diagnostic.IDE0010.severity = silent # populate switch
-dotnet_diagnostic.IDE0017.severity = suggestion # initialization can be simplified
-dotnet_diagnostic.IDE0021.severity = silent # expression body for constructors
-dotnet_diagnostic.IDE0022.severity = silent # expression body for methods
-dotnet_diagnostic.IDE0023.severity = suggestion # use expression body for operators
-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.IDE0032.severity = suggestion # Use auto property
-dotnet_diagnostic.IDE0033.severity = error # prefer tuple name
-dotnet_diagnostic.IDE0037.severity = suggestion # simplify anonymous type
-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.IDE0051.severity = error # unused field
-dotnet_diagnostic.IDE0052.severity = error # unused member
-dotnet_diagnostic.IDE0053.severity = suggestion # lambda not needed
-dotnet_diagnostic.IDE0055.severity = suggestion # Fix formatting
-dotnet_diagnostic.IDE0057.severity = suggestion # substring can be simplified
-dotnet_diagnostic.IDE0060.severity = suggestion # unused parameters
-dotnet_diagnostic.IDE0061.severity = suggestion # local expression body
-dotnet_diagnostic.IDE0062.severity = suggestion # local to static
-dotnet_diagnostic.IDE0063.severity = error # simplify using
-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.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
-
-##########################################
-# Styles
-##########################################
-
-# camel_case_style - Define the camelCase style
-dotnet_naming_style.camel_case_style.capitalization = camel_case
-# pascal_case_style - Define the PascalCase style
-dotnet_naming_style.pascal_case_style.capitalization = pascal_case
-# constant_case - Define the CONSTANT_CASE style
-dotnet_naming_style.constant_case.capitalization = all_upper
-dotnet_naming_style.constant_case.word_separator = _
-# first_upper_style - The first character must start with an upper-case character
-dotnet_naming_style.first_upper_style.capitalization = first_word_upper
-# prefix_interface_with_i_style - Interfaces must be PascalCase and the first character of an interface must be an 'I'
-dotnet_naming_style.prefix_interface_with_i_style.capitalization = pascal_case
-dotnet_naming_style.prefix_interface_with_i_style.required_prefix = I
-# prefix_type_parameters_with_t_style - Generic Type Parameters must be PascalCase and the first character must be a 'T'
-dotnet_naming_style.prefix_type_parameters_with_t_style.capitalization = pascal_case
-dotnet_naming_style.prefix_type_parameters_with_t_style.required_prefix = T
-# disallowed_style - Anything that has this style applied is marked as disallowed
-dotnet_naming_style.disallowed_style.capitalization  = pascal_case
-dotnet_naming_style.disallowed_style.required_prefix = ____RULE_VIOLATION____
-dotnet_naming_style.disallowed_style.required_suffix = ____RULE_VIOLATION____
-# internal_error_style - This style should never occur... if it does, it indicates a bug in file or in the parser using the file
-dotnet_naming_style.internal_error_style.capitalization  = pascal_case
-dotnet_naming_style.internal_error_style.required_prefix = ____INTERNAL_ERROR____
-dotnet_naming_style.internal_error_style.required_suffix = ____INTERNAL_ERROR____
-
-# prefix_interface_with_i_style - Interfaces must be PascalCase and the first character of an interface must be an 'I'
-dotnet_naming_style.underscore_camel_case_style.capitalization = camel_case
-dotnet_naming_style.underscore_camel_case_style.required_prefix = _
-
-##########################################
-# .NET Design Guideline Field Naming Rules
-# Naming rules for fields follow the .NET Framework design guidelines
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/index
-##########################################
-
-# All public/protected/protected_internal constant fields must be constant_case
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/field
-dotnet_naming_symbols.public_protected_constant_fields_group.applicable_accessibilities = public, protected, protected_internal
-dotnet_naming_symbols.public_protected_constant_fields_group.required_modifiers         = const
-dotnet_naming_symbols.public_protected_constant_fields_group.applicable_kinds           = field
-dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.symbols    = public_protected_constant_fields_group
-dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.style      = constant_case
-dotnet_naming_rule.public_protected_constant_fields_must_be_pascal_case_rule.severity   = warning
-
-# All public/protected/protected_internal static readonly fields must be constant_case
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/field
-dotnet_naming_symbols.public_protected_static_readonly_fields_group.applicable_accessibilities = public, protected, protected_internal
-dotnet_naming_symbols.public_protected_static_readonly_fields_group.required_modifiers         = static, readonly
-dotnet_naming_symbols.public_protected_static_readonly_fields_group.applicable_kinds           = field
-dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.symbols    = public_protected_static_readonly_fields_group
-dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.style      = constant_case
-dotnet_naming_rule.public_protected_static_readonly_fields_must_be_pascal_case_rule.severity   = warning
-
-# No other public/protected/protected_internal fields are allowed
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/field
-dotnet_naming_symbols.other_public_protected_fields_group.applicable_accessibilities = public, protected, protected_internal
-dotnet_naming_symbols.other_public_protected_fields_group.applicable_kinds           = field
-dotnet_naming_rule.other_public_protected_fields_disallowed_rule.symbols             = other_public_protected_fields_group
-dotnet_naming_rule.other_public_protected_fields_disallowed_rule.style               = disallowed_style
-dotnet_naming_rule.other_public_protected_fields_disallowed_rule.severity            = error
-
-##########################################
-# StyleCop Field Naming Rules
-# Naming rules for fields follow the StyleCop analyzers
-# This does not override any rules using disallowed_style above
-# https://github.com/DotNetAnalyzers/StyleCopAnalyzers
-##########################################
-
-# All constant fields must be constant_case
-# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1303.md
-dotnet_naming_symbols.stylecop_constant_fields_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected, private
-dotnet_naming_symbols.stylecop_constant_fields_group.required_modifiers         = const
-dotnet_naming_symbols.stylecop_constant_fields_group.applicable_kinds           = field
-dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.symbols    = stylecop_constant_fields_group
-dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.style      = constant_case
-dotnet_naming_rule.stylecop_constant_fields_must_be_pascal_case_rule.severity   = warning
-
-# All static readonly fields must be constant_case
-# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1311.md
-dotnet_naming_symbols.stylecop_static_readonly_fields_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected, private
-dotnet_naming_symbols.stylecop_static_readonly_fields_group.required_modifiers         = static, readonly
-dotnet_naming_symbols.stylecop_static_readonly_fields_group.applicable_kinds           = field
-dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.symbols    = stylecop_static_readonly_fields_group
-dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.style      = constant_case
-dotnet_naming_rule.stylecop_static_readonly_fields_must_be_pascal_case_rule.severity   = warning
-
-# No non-private instance fields are allowed
-# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1401.md
-dotnet_naming_symbols.stylecop_fields_must_be_private_group.applicable_accessibilities = public, internal, protected_internal, protected, private_protected
-dotnet_naming_symbols.stylecop_fields_must_be_private_group.applicable_kinds           = field
-dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.symbols               = stylecop_fields_must_be_private_group
-dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.style                 = disallowed_style
-dotnet_naming_rule.stylecop_instance_fields_must_be_private_rule.severity              = error
-
-# Private fields must be camelCase
-# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1306.md
-dotnet_naming_symbols.stylecop_private_fields_group.applicable_accessibilities = private
-dotnet_naming_symbols.stylecop_private_fields_group.applicable_kinds           = field
-dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.symbols     = stylecop_private_fields_group
-dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.style       = underscore_camel_case_style
-dotnet_naming_rule.stylecop_private_fields_must_be_camel_case_rule.severity    = warning
-
-# Local variables must be camelCase
-# https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1312.md
-dotnet_naming_symbols.stylecop_local_fields_group.applicable_accessibilities = local
-dotnet_naming_symbols.stylecop_local_fields_group.applicable_kinds           = local
-dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.symbols     = stylecop_local_fields_group
-dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.style       = camel_case_style
-dotnet_naming_rule.stylecop_local_fields_must_be_camel_case_rule.severity    = warning
-
-# This rule should never fire.  However, it's included for at least two purposes:
-# First, it helps to understand, reason about, and root-case certain types of issues, such as bugs in .editorconfig parsers.
-# Second, it helps to raise immediate awareness if a new field type is added (as occurred recently in C#).
-dotnet_naming_symbols.sanity_check_uncovered_field_case_group.applicable_accessibilities = *
-dotnet_naming_symbols.sanity_check_uncovered_field_case_group.applicable_kinds           = field
-dotnet_naming_rule.sanity_check_uncovered_field_case_rule.symbols  = sanity_check_uncovered_field_case_group
-dotnet_naming_rule.sanity_check_uncovered_field_case_rule.style    = internal_error_style
-dotnet_naming_rule.sanity_check_uncovered_field_case_rule.severity = error
-
-
-##########################################
-# Other Naming Rules
-##########################################
-
-# All of the following must be PascalCase:
-# - Namespaces
-#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-namespaces
-#   https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1300.md
-# - Classes and Enumerations
-#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces
-#   https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1300.md
-# - Delegates
-#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces#names-of-common-types
-# - Constructors, Properties, Events, Methods
-#   https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-type-members
-dotnet_naming_symbols.element_group.applicable_kinds = namespace, class, enum, struct, delegate, event, method, property
-dotnet_naming_rule.element_rule.symbols              = element_group
-dotnet_naming_rule.element_rule.style                = pascal_case_style
-dotnet_naming_rule.element_rule.severity             = warning
-
-# Interfaces use PascalCase and are prefixed with uppercase 'I'
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces
-dotnet_naming_symbols.interface_group.applicable_kinds = interface
-dotnet_naming_rule.interface_rule.symbols              = interface_group
-dotnet_naming_rule.interface_rule.style                = prefix_interface_with_i_style
-dotnet_naming_rule.interface_rule.severity             = warning
-
-# Generics Type Parameters use PascalCase and are prefixed with uppercase 'T'
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/names-of-classes-structs-and-interfaces
-dotnet_naming_symbols.type_parameter_group.applicable_kinds = type_parameter
-dotnet_naming_rule.type_parameter_rule.symbols              = type_parameter_group
-dotnet_naming_rule.type_parameter_rule.style                = prefix_type_parameters_with_t_style
-dotnet_naming_rule.type_parameter_rule.severity             = warning
-
-# Function parameters use camelCase
-# https://docs.microsoft.com/dotnet/standard/design-guidelines/naming-parameters
-dotnet_naming_symbols.parameters_group.applicable_kinds = parameter
-dotnet_naming_rule.parameters_rule.symbols              = parameters_group
-dotnet_naming_rule.parameters_rule.style                = camel_case_style
-dotnet_naming_rule.parameters_rule.severity             = warning
-
-##########################################
-# License
-##########################################
-# The following applies as to the .editorconfig file ONLY, and is
-# included below for reference, per the requirements of the license
-# corresponding to this .editorconfig file.
-# See: https://github.com/RehanSaeed/EditorConfig
-#
-# MIT License
-#
-# Copyright (c) 2017-2019 Muhammad Rehan Saeed
-# Copyright (c) 2019 Henry Gabryjelski
-#
-# Permission is hereby granted, free of charge, to any
-# person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the
-# Software without restriction, including without limitation
-# the rights to use, copy, modify, merge, publish, distribute,
-# sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject
-# to the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-##########################################
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,6 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "github-actions" # search for actions - there are other options available
-    directory: "/" # search in .github/workflows under root `/`
-    schedule:
-      interval: "weekly" # check for action update every week
--- a/.github/workflows/dotnetcore.yml
+++ b/.github/workflows/dotnetcore.yml
@@ -1,10 +1,5 @@
 name: SharpCompress
-on:
-  push:
-    branches:
-      - 'master'
-  pull_request:
-    types: [ opened, synchronize, reopened, ready_for_review ]
+on: [push, pull_request]

 jobs:
  build:
@@ -14,19 +9,16 @@ jobs:
        os: [windows-latest, ubuntu-latest]

    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-dotnet@v3
+    - uses: actions/checkout@v1
+    - uses: actions/setup-dotnet@v1
      with:
-        dotnet-version: 7.0.x
-    - name: NuGet Caching
-      uses: actions/cache@v3
-      with:
-        path: ~/.nuget/packages
-        key: ${{ runner.os }}-nuget-${{ hashFiles('packages.lock.json', '*/packages.lock.json') }}
-        restore-keys: |
-            ${{ runner.os }}-nuget-
-    - run: dotnet run --project build/build.csproj
-    - uses: actions/upload-artifact@v3
+        dotnet-version: 5.0.101
+    - run: dotnet run -p build/build.csproj
+    - uses: actions/upload-artifact@v2
      with:
        name: ${{ matrix.os }}-sharpcompress.nupkg
        path: artifacts/*
+    - uses: actions/upload-artifact@v2
+      with:
+        name: ${{ matrix.os }}-sharpcompress.snupkg
+        path: artifacts/*
--- a/.gitignore
+++ b/.gitignore
@@ -18,4 +18,3 @@ tools

 .DS_Store
 *.snupkg
-/tests/TestArchives/6d23a38c-f064-4ef1-ad89-b942396f53b9/Scratch
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -1,14 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <LangVersion>latest</LangVersion>
-    <Nullable>enable</Nullable>
-    <AnalysisMode>Recommended</AnalysisMode>
-    <WarningsAsErrors>true</WarningsAsErrors>
-    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
-    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
-    <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
-  </PropertyGroup>
-</Project>
--- a/FORMATS.md
+++ b/FORMATS.md
@@ -19,6 +19,7 @@
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
 | 7Zip (4)               | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate      | Decompress          | SevenZipArchive | N/A        | N/A           |
+| LZip (single file) (5) | LZip (LZMA)                                       | Both                | LZipArchive     | LZipReader | LZipWriter    |

 1. SOLID Rars are only supported in the RarReader API.
 2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading.
--- a/README.md
+++ b/README.md
@@ -5,8 +5,7 @@ SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1, .N
 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)
+[![GitHubActions](https://github.com/adamhathcock/sharpcompress/workflows/SharpCompress/badge.svg)](https://circleci.com/gh/adamhathcock/sharpcompress)

 ## Need Help?

@@ -43,8 +42,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un

 ## Version Log

-* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
-
 ### Version 0.18

 * [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
@@ -185,8 +182,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un

 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott

-XZ BCJ filters support contributed by Louis-Michel Bergeron, on behalf of aDolus Technology Inc. - 2022
-
 7Zip implementation based on: https://code.google.com/p/managed-lzma/

 LICENSE
--- a/SharpCompress.sln
+++ b/SharpCompress.sln
@@ -3,6 +3,8 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.26430.6
 MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F18F1765-4A02-42FD-9BEF-F0E2FCBD9D17}"
+EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3C5BE746-03E5-4895-9988-0B57F162F86C}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0F0901FF-E8D9-426A-B5A2-17C7F47C1529}"
@@ -13,12 +15,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress.Test", "tests
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "build", "build\build.csproj", "{D4D613CB-5E94-47FB-85BE-B8423D20C545}"
 EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB42573-7D22-4490-BA12-1B7FB99CE7FB}"
-	ProjectSection(SolutionItems) = preProject
-		Directory.Build.props = Directory.Build.props
-		global.json = global.json
-	EndProjectSection
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
--- a/USAGE.md
+++ b/USAGE.md
@@ -33,18 +33,6 @@ If using Compression Stream classes directly and you don't want the wrapped stre

 Also, look over the tests for more thorough [examples](https://github.com/adamhathcock/sharpcompress/tree/master/tests/SharpCompress.Test)

-### Create Zip Archive from multiple files
-```C#
-using(var archive = ZipArchive.Create())
-{
-    archive.AddEntry("file01.txt", "C:\\file01.txt");
-    archive.AddEntry("file02.txt", "C:\\file02.txt");
-    ...
-    
-    archive.SaveTo("C:\\temp.zip", CompressionType.Deflate);
-}
-```
-
 ### Create Zip Archive from all files in a directory to a file

 ```C#
@@ -155,4 +143,4 @@ foreach(var entry in tr.Entries)
 {
    Console.WriteLine($"{entry.Key}");
 }
-```
+```
--- a/build/Program.cs
+++ b/build/Program.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
@@ -6,90 +6,78 @@ using GlobExpressions;
 using static Bullseye.Targets;
 using static SimpleExec.Command;

-const string Clean = "clean";
-const string Restore = "restore";
-const string Build = "build";
-const string Test = "test";
-const string Format = "format";
-const string Publish = "publish";
+class Program
+{
+    private const string Clean = "clean";
+    private const string Format = "format";
+    private const string Build = "build";
+    private const string Test = "test";
+    private const string Publish = "publish";

-Target(
-    Clean,
-    ForEach("**/bin", "**/obj"),
-    dir =>
+    static void Main(string[] args)
    {
-        IEnumerable<string> GetDirectories(string d)
-        {
-            return Glob.Directories(".", d);
-        }
-
-        void RemoveDirectory(string d)
-        {
-            if (Directory.Exists(d))
+        Target(Clean,
+            ForEach("**/bin", "**/obj"),
+            dir =>
            {
-                Console.WriteLine(d);
-                Directory.Delete(d, true);
-            }
-        }
+                IEnumerable<string> GetDirectories(string d)
+                {
+                    return Glob.Directories(".", d);
+                }

-        foreach (var d in GetDirectories(dir))
+                void RemoveDirectory(string d)
+                {
+                    if (Directory.Exists(d))
+                    {
+                        Console.WriteLine(d);
+                        Directory.Delete(d, true);
+                    }
+                }
+
+                foreach (var d in GetDirectories(dir))
+                {
+                    RemoveDirectory(d);
+                }
+            });
+
+        Target(Format, () =>
        {
-            RemoveDirectory(d);
-        }
+            Run("dotnet", "tool restore");
+            Run("dotnet", "format --check");
+        });
+
+        Target(Build, DependsOn(Format),
+               framework =>
+               {
+                   if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net46")
+                   {
+                       return;
+                   }
+                   Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release");
+               });
+
+        Target(Test, DependsOn(Build), ForEach("net5.0"),
+               framework =>
+               {
+                   IEnumerable<string> GetFiles(string d)
+                   {
+                       return Glob.Files(".", d);
+                   }
+
+                   foreach (var file in GetFiles("**/*.Test.csproj"))
+                   {
+                       Run("dotnet", $"test {file} -c Release -f {framework}");
+                   }
+               });
+
+        Target(Publish, DependsOn(Test),
+               () =>
+               {
+                   Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
+               });
+
+        Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
+
+        RunTargetsAndExit(args);
    }
-);
-
-Target(
-    Format,
-    () =>
-    {
-        Run("dotnet", "tool restore");
-        Run("dotnet", "csharpier --check .");
-    }
-);
-Target(Restore, DependsOn(Format), () => Run("dotnet", "restore"));
-
-Target(
-    Build,
-    DependsOn(Restore),
-    () =>
-    {
-        Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release --no-restore");
-    }
-);
-
-Target(
-    Test,
-    DependsOn(Build),
-    ForEach("net7.0", "net462"),
-    framework =>
-    {
-        IEnumerable<string> GetFiles(string d)
-        {
-            return Glob.Files(".", d);
-        }
-
-        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net462")
-        {
-            return;
-        }
-
-        foreach (var file in GetFiles("**/*.Test.csproj"))
-        {
-            Run("dotnet", $"test {file} -c Release -f {framework} --no-restore --verbosity=normal");
-        }
-    }
-);
-
-Target(
-    Publish,
-    DependsOn(Test),
-    () =>
-    {
-        Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
-    }
-);
-
-Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
-
-await RunTargetsAndExitAsync(args);
+}
--- a/build/build.csproj
+++ b/build/build.csproj
@@ -2,13 +2,13 @@

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net5.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" Version="3.6.0" />
+    <PackageReference Include="Glob" Version="1.1.8" />
+    <PackageReference Include="SimpleExec" Version="6.4.0" />
  </ItemGroup>

 </Project>
--- a/global.json
+++ b/global.json
@@ -1,6 +1,5 @@
 {
  "sdk": {
-    "version": "7.0.101",
-    "rollForward": "latestFeature"
+    "version": "5.0.101"
  }
-}
+}
--- a/src/SharpCompress/Algorithms/Adler32.cs
+++ b/src/SharpCompress/Algorithms/Adler32.cs
@@ -1,486 +0,0 @@
-// Copyright (c) Six Labors.
-// Licensed under the Apache License, Version 2.0.
-
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1 && !NETFRAMEWORK
-#define SUPPORTS_RUNTIME_INTRINSICS
-#define SUPPORTS_HOTPATH
-#endif
-
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-#if SUPPORTS_RUNTIME_INTRINSICS
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-#endif
-
-#pragma warning disable IDE0007 // Use implicit type
-namespace SharpCompress.Algorithms;
-
-/// <summary>
-/// Calculates the 32 bit Adler checksum of a given buffer according to
-/// RFC 1950. ZLIB Compressed Data Format Specification version 3.3)
-/// </summary>
-internal static class Adler32 // From https://github.com/SixLabors/ImageSharp/blob/main/src/ImageSharp/Compression/Zlib/Adler32.cs
-{
-    /// <summary>
-    /// Global inlining options. Helps temporarily disable inlining for better profiler output.
-    /// </summary>
-    private static class InliningOptions // From https://github.com/SixLabors/ImageSharp/blob/main/src/ImageSharp/Common/Helpers/InliningOptions.cs
-    {
-        /// <summary>
-        /// <see cref="MethodImplOptions.AggressiveInlining"/> regardless of the build conditions.
-        /// </summary>
-        public const MethodImplOptions AlwaysInline = MethodImplOptions.AggressiveInlining;
-#if PROFILING
-        public const MethodImplOptions HotPath = MethodImplOptions.NoInlining;
-        public const MethodImplOptions ShortMethod = MethodImplOptions.NoInlining;
-#else
-#if SUPPORTS_HOTPATH
-        public const MethodImplOptions HotPath = MethodImplOptions.AggressiveOptimization;
-#else
-        public const MethodImplOptions HotPath = MethodImplOptions.AggressiveInlining;
-#endif
-        public const MethodImplOptions ShortMethod = MethodImplOptions.AggressiveInlining;
-#endif
-        public const MethodImplOptions ColdPath = MethodImplOptions.NoInlining;
-    }
-
-#if SUPPORTS_RUNTIME_INTRINSICS
-    /// <summary>
-    /// Provides optimized static methods for trigonometric, logarithmic,
-    /// and other common mathematical functions.
-    /// </summary>
-    private static class Numerics // From https://github.com/SixLabors/ImageSharp/blob/main/src/ImageSharp/Common/Helpers/Numerics.cs
-    {
-        /// <summary>
-        /// Reduces elements of the vector into one sum.
-        /// </summary>
-        /// <param name="accumulator">The accumulator to reduce.</param>
-        /// <returns>The sum of all elements.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int ReduceSum(Vector256<int> accumulator)
-        {
-            // Add upper lane to lower lane.
-            Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper());
-
-            // Add odd to even.
-            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_11_01_01));
-
-            // Add high to low.
-            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10));
-
-            return Sse2.ConvertToInt32(vsum);
-        }
-
-        /// <summary>
-        /// Reduces even elements of the vector into one sum.
-        /// </summary>
-        /// <param name="accumulator">The accumulator to reduce.</param>
-        /// <returns>The sum of even elements.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int EvenReduceSum(Vector256<int> accumulator)
-        {
-            Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper()); // add upper lane to lower lane
-            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10)); // add high to low
-
-            // Vector128<int>.ToScalar() isn't optimized pre-net5.0 https://github.com/dotnet/runtime/pull/37882
-            return Sse2.ConvertToInt32(vsum);
-        }
-    }
-#endif
-
-    /// <summary>
-    /// The default initial seed value of a Adler32 checksum calculation.
-    /// </summary>
-    public const uint SeedValue = 1U;
-
-    // Largest prime smaller than 65536
-    private const uint BASE = 65521;
-
-    // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
-    private const uint NMAX = 5552;
-
-#if SUPPORTS_RUNTIME_INTRINSICS
-    private const int MinBufferSize = 64;
-
-    private const int BlockSize = 1 << 5;
-
-    // The C# compiler emits this as a compile-time constant embedded in the PE file.
-    private static ReadOnlySpan<byte> Tap1Tap2 =>
-        new byte[]
-        {
-            32,
-            31,
-            30,
-            29,
-            28,
-            27,
-            26,
-            25,
-            24,
-            23,
-            22,
-            21,
-            20,
-            19,
-            18,
-            17, // tap1
-            16,
-            15,
-            14,
-            13,
-            12,
-            11,
-            10,
-            9,
-            8,
-            7,
-            6,
-            5,
-            4,
-            3,
-            2,
-            1 // tap2
-        };
-#endif
-
-    /// <summary>
-    /// Calculates the Adler32 checksum with the bytes taken from the span.
-    /// </summary>
-    /// <param name="buffer">The readonly span of bytes.</param>
-    /// <returns>The <see cref="uint"/>.</returns>
-    [MethodImpl(InliningOptions.ShortMethod)]
-    public static uint Calculate(ReadOnlySpan<byte> buffer) => Calculate(SeedValue, buffer);
-
-    /// <summary>
-    /// Calculates the Adler32 checksum with the bytes taken from the span and seed.
-    /// </summary>
-    /// <param name="adler">The input Adler32 value.</param>
-    /// <param name="buffer">The readonly span of bytes.</param>
-    /// <returns>The <see cref="uint"/>.</returns>
-    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
-    public static uint Calculate(uint adler, ReadOnlySpan<byte> buffer)
-    {
-        if (buffer.IsEmpty)
-        {
-            return adler;
-        }
-
-#if SUPPORTS_RUNTIME_INTRINSICS
-        if (Avx2.IsSupported && buffer.Length >= MinBufferSize)
-        {
-            return CalculateAvx2(adler, buffer);
-        }
-
-        if (Ssse3.IsSupported && buffer.Length >= MinBufferSize)
-        {
-            return CalculateSse(adler, buffer);
-        }
-
-        return CalculateScalar(adler, buffer);
-#else
-        return CalculateScalar(adler, buffer);
-#endif
-    }
-
-    // Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
-#if SUPPORTS_RUNTIME_INTRINSICS
-    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
-    private static unsafe uint CalculateSse(uint adler, ReadOnlySpan<byte> buffer)
-    {
-        uint s1 = adler & 0xFFFF;
-        uint s2 = (adler >> 16) & 0xFFFF;
-
-        // Process the data in blocks.
-        uint length = (uint)buffer.Length;
-        uint blocks = length / BlockSize;
-        length -= blocks * BlockSize;
-
-        fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
-        {
-            fixed (byte* tapPtr = &MemoryMarshal.GetReference(Tap1Tap2))
-            {
-                byte* localBufferPtr = bufferPtr;
-
-                // _mm_setr_epi8 on x86
-                Vector128<sbyte> tap1 = Sse2.LoadVector128((sbyte*)tapPtr);
-                Vector128<sbyte> tap2 = Sse2.LoadVector128((sbyte*)(tapPtr + 0x10));
-                Vector128<byte> zero = Vector128<byte>.Zero;
-                var ones = Vector128.Create((short)1);
-
-                while (blocks > 0)
-                {
-                    uint n = NMAX / BlockSize; /* The NMAX constraint. */
-                    if (n > blocks)
-                    {
-                        n = blocks;
-                    }
-
-                    blocks -= n;
-
-                    // Process n blocks of data. At most NMAX data bytes can be
-                    // processed before s2 must be reduced modulo BASE.
-                    Vector128<uint> v_ps = Vector128.CreateScalar(s1 * n);
-                    Vector128<uint> v_s2 = Vector128.CreateScalar(s2);
-                    Vector128<uint> v_s1 = Vector128<uint>.Zero;
-
-                    do
-                    {
-                        // Load 32 input bytes.
-                        Vector128<byte> bytes1 = Sse3.LoadDquVector128(localBufferPtr);
-                        Vector128<byte> bytes2 = Sse3.LoadDquVector128(localBufferPtr + 0x10);
-
-                        // Add previous block byte sum to v_ps.
-                        v_ps = Sse2.Add(v_ps, v_s1);
-
-                        // Horizontally add the bytes for s1, multiply-adds the
-                        // bytes by [ 32, 31, 30, ... ] for s2.
-                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1, zero).AsUInt32());
-                        Vector128<short> mad1 = Ssse3.MultiplyAddAdjacent(bytes1, tap1);
-                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1, ones).AsUInt32());
-
-                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2, zero).AsUInt32());
-                        Vector128<short> mad2 = Ssse3.MultiplyAddAdjacent(bytes2, tap2);
-                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2, ones).AsUInt32());
-
-                        localBufferPtr += BlockSize;
-                    } while (--n > 0);
-
-                    v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5));
-
-                    // Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
-                    const byte S2301 = 0b1011_0001; // A B C D -> B A D C
-                    const byte S1032 = 0b0100_1110; // A B C D -> C D A B
-
-                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S1032));
-
-                    s1 += v_s1.ToScalar();
-
-                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S2301));
-                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S1032));
-
-                    s2 = v_s2.ToScalar();
-
-                    // Reduce.
-                    s1 %= BASE;
-                    s2 %= BASE;
-                }
-
-                if (length > 0)
-                {
-                    HandleLeftOver(localBufferPtr, length, ref s1, ref s2);
-                }
-
-                return s1 | (s2 << 16);
-            }
-        }
-    }
-
-    // Based on: https://github.com/zlib-ng/zlib-ng/blob/develop/arch/x86/adler32_avx2.c
-    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
-    public static unsafe uint CalculateAvx2(uint adler, ReadOnlySpan<byte> buffer)
-    {
-        uint s1 = adler & 0xFFFF;
-        uint s2 = (adler >> 16) & 0xFFFF;
-        uint length = (uint)buffer.Length;
-
-        fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
-        {
-            byte* localBufferPtr = bufferPtr;
-
-            Vector256<byte> zero = Vector256<byte>.Zero;
-            var dot3v = Vector256.Create((short)1);
-            var dot2v = Vector256.Create(
-                32,
-                31,
-                30,
-                29,
-                28,
-                27,
-                26,
-                25,
-                24,
-                23,
-                22,
-                21,
-                20,
-                19,
-                18,
-                17,
-                16,
-                15,
-                14,
-                13,
-                12,
-                11,
-                10,
-                9,
-                8,
-                7,
-                6,
-                5,
-                4,
-                3,
-                2,
-                1
-            );
-
-            // Process n blocks of data. At most NMAX data bytes can be
-            // processed before s2 must be reduced modulo BASE.
-            var vs1 = Vector256.CreateScalar(s1);
-            var vs2 = Vector256.CreateScalar(s2);
-
-            while (length >= 32)
-            {
-                int k = length < NMAX ? (int)length : (int)NMAX;
-                k -= k % 32;
-                length -= (uint)k;
-
-                Vector256<uint> vs10 = vs1;
-                Vector256<uint> vs3 = Vector256<uint>.Zero;
-
-                while (k >= 32)
-                {
-                    // Load 32 input bytes.
-                    Vector256<byte> block = Avx.LoadVector256(localBufferPtr);
-
-                    // Sum of abs diff, resulting in 2 x int32's
-                    Vector256<ushort> vs1sad = Avx2.SumAbsoluteDifferences(block, zero);
-
-                    vs1 = Avx2.Add(vs1, vs1sad.AsUInt32());
-                    vs3 = Avx2.Add(vs3, vs10);
-
-                    // sum 32 uint8s to 16 shorts.
-                    Vector256<short> vshortsum2 = Avx2.MultiplyAddAdjacent(block, dot2v);
-
-                    // sum 16 shorts to 8 uint32s.
-                    Vector256<int> vsum2 = Avx2.MultiplyAddAdjacent(vshortsum2, dot3v);
-
-                    vs2 = Avx2.Add(vsum2.AsUInt32(), vs2);
-                    vs10 = vs1;
-
-                    localBufferPtr += BlockSize;
-                    k -= 32;
-                }
-
-                // Defer the multiplication with 32 to outside of the loop.
-                vs3 = Avx2.ShiftLeftLogical(vs3, 5);
-                vs2 = Avx2.Add(vs2, vs3);
-
-                s1 = (uint)Numerics.EvenReduceSum(vs1.AsInt32());
-                s2 = (uint)Numerics.ReduceSum(vs2.AsInt32());
-
-                s1 %= BASE;
-                s2 %= BASE;
-
-                vs1 = Vector256.CreateScalar(s1);
-                vs2 = Vector256.CreateScalar(s2);
-            }
-
-            if (length > 0)
-            {
-                HandleLeftOver(localBufferPtr, length, ref s1, ref s2);
-            }
-
-            return s1 | (s2 << 16);
-        }
-    }
-
-    private static unsafe void HandleLeftOver(
-        byte* localBufferPtr,
-        uint length,
-        ref uint s1,
-        ref uint s2
-    )
-    {
-        if (length >= 16)
-        {
-            s2 += s1 += localBufferPtr[0];
-            s2 += s1 += localBufferPtr[1];
-            s2 += s1 += localBufferPtr[2];
-            s2 += s1 += localBufferPtr[3];
-            s2 += s1 += localBufferPtr[4];
-            s2 += s1 += localBufferPtr[5];
-            s2 += s1 += localBufferPtr[6];
-            s2 += s1 += localBufferPtr[7];
-            s2 += s1 += localBufferPtr[8];
-            s2 += s1 += localBufferPtr[9];
-            s2 += s1 += localBufferPtr[10];
-            s2 += s1 += localBufferPtr[11];
-            s2 += s1 += localBufferPtr[12];
-            s2 += s1 += localBufferPtr[13];
-            s2 += s1 += localBufferPtr[14];
-            s2 += s1 += localBufferPtr[15];
-
-            localBufferPtr += 16;
-            length -= 16;
-        }
-
-        while (length-- > 0)
-        {
-            s2 += s1 += *localBufferPtr++;
-        }
-
-        if (s1 >= BASE)
-        {
-            s1 -= BASE;
-        }
-
-        s2 %= BASE;
-    }
-#endif
-
-    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
-    private static unsafe uint CalculateScalar(uint adler, ReadOnlySpan<byte> buffer)
-    {
-        uint s1 = adler & 0xFFFF;
-        uint s2 = (adler >> 16) & 0xFFFF;
-        uint k;
-
-        fixed (byte* bufferPtr = buffer)
-        {
-            var localBufferPtr = bufferPtr;
-            uint length = (uint)buffer.Length;
-
-            while (length > 0)
-            {
-                k = length < NMAX ? length : NMAX;
-                length -= k;
-
-                while (k >= 16)
-                {
-                    s2 += s1 += localBufferPtr[0];
-                    s2 += s1 += localBufferPtr[1];
-                    s2 += s1 += localBufferPtr[2];
-                    s2 += s1 += localBufferPtr[3];
-                    s2 += s1 += localBufferPtr[4];
-                    s2 += s1 += localBufferPtr[5];
-                    s2 += s1 += localBufferPtr[6];
-                    s2 += s1 += localBufferPtr[7];
-                    s2 += s1 += localBufferPtr[8];
-                    s2 += s1 += localBufferPtr[9];
-                    s2 += s1 += localBufferPtr[10];
-                    s2 += s1 += localBufferPtr[11];
-                    s2 += s1 += localBufferPtr[12];
-                    s2 += s1 += localBufferPtr[13];
-                    s2 += s1 += localBufferPtr[14];
-                    s2 += s1 += localBufferPtr[15];
-
-                    localBufferPtr += 16;
-                    k -= 16;
-                }
-
-                while (k-- > 0)
-                {
-                    s2 += s1 += *localBufferPtr++;
-                }
-
-                s1 %= BASE;
-                s2 %= BASE;
-            }
-
-            return (s2 << 16) | s1;
-        }
-    }
-}
--- a/src/SharpCompress/Algorithms/Alder32.cs
+++ b/src/SharpCompress/Algorithms/Alder32.cs
@@ -0,0 +1,285 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the GNU Affero General Public License, Version 3.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1
+using System.Runtime.Intrinsics;
+using System.Runtime.Intrinsics.X86;
+#endif
+
+namespace SharpCompress.Algorithms
+{
+    /// <summary>
+    /// Calculates the 32 bit Adler checksum of a given buffer according to
+    /// RFC 1950. ZLIB Compressed Data Format Specification version 3.3)
+    /// </summary>
+    internal static class Adler32
+    {
+        /// <summary>
+        /// The default initial seed value of a Adler32 checksum calculation.
+        /// </summary>
+        public const uint SeedValue = 1U;
+
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1
+        private const int MinBufferSize = 64;
+#endif
+
+        // Largest prime smaller than 65536
+        private const uint BASE = 65521;
+
+        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+        private const uint NMAX = 5552;
+
+        /// <summary>
+        /// Calculates the Adler32 checksum with the bytes taken from the span.
+        /// </summary>
+        /// <param name="buffer">The readonly span of bytes.</param>
+        /// <returns>The <see cref="uint"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint Calculate(ReadOnlySpan<byte> buffer)
+        {
+            return Calculate(SeedValue, buffer);
+        }
+
+        /// <summary>
+        /// Calculates the Adler32 checksum with the bytes taken from the span and seed.
+        /// </summary>
+        /// <param name="adler">The input Adler32 value.</param>
+        /// <param name="buffer">The readonly span of bytes.</param>
+        /// <returns>The <see cref="uint"/>.</returns>
+        public static uint Calculate(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            if (buffer.IsEmpty)
+            {
+                return SeedValue;
+            }
+
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1
+            if (Sse3.IsSupported && buffer.Length >= MinBufferSize)
+            {
+                return CalculateSse(adler, buffer);
+            }
+
+            return CalculateScalar(adler, buffer);
+#else
+            return CalculateScalar(adler, buffer);
+#endif
+        }
+
+        // Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
+#if !NETSTANDARD2_0 && !NETSTANDARD2_1
+        private static unsafe uint CalculateSse(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            uint s1 = adler & 0xFFFF;
+            uint s2 = (adler >> 16) & 0xFFFF;
+
+            // Process the data in blocks.
+            const int BLOCK_SIZE = 1 << 5;
+
+            uint length = (uint)buffer.Length;
+            uint blocks = length / BLOCK_SIZE;
+            length -= blocks * BLOCK_SIZE;
+
+            int index = 0;
+            fixed (byte* bufferPtr = &buffer[0])
+            {
+                index += (int)blocks * BLOCK_SIZE;
+                var localBufferPtr = bufferPtr;
+
+                // _mm_setr_epi8 on x86
+                var tap1 = Vector128.Create(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17);
+                var tap2 = Vector128.Create(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
+                Vector128<byte> zero = Vector128<byte>.Zero;
+                var ones = Vector128.Create((short)1);
+
+                while (blocks > 0)
+                {
+                    uint n = NMAX / BLOCK_SIZE;  /* The NMAX constraint. */
+                    if (n > blocks)
+                    {
+                        n = blocks;
+                    }
+
+                    blocks -= n;
+
+                    // Process n blocks of data. At most NMAX data bytes can be
+                    // processed before s2 must be reduced modulo BASE.
+                    Vector128<int> v_ps = Vector128.CreateScalar(s1 * n).AsInt32();
+                    Vector128<int> v_s2 = Vector128.CreateScalar(s2).AsInt32();
+                    Vector128<int> v_s1 = Vector128<int>.Zero;
+
+                    do
+                    {
+                        // Load 32 input bytes.
+                        Vector128<byte> bytes1 = Sse3.LoadDquVector128(localBufferPtr);
+                        Vector128<byte> bytes2 = Sse3.LoadDquVector128(localBufferPtr + 16);
+
+                        // Add previous block byte sum to v_ps.
+                        v_ps = Sse2.Add(v_ps, v_s1);
+
+                        // Horizontally add the bytes for s1, multiply-adds the
+                        // bytes by [ 32, 31, 30, ... ] for s2.
+                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1, zero).AsInt32());
+                        Vector128<short> mad1 = Ssse3.MultiplyAddAdjacent(bytes1, tap1);
+                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1, ones));
+
+                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2, zero).AsInt32());
+                        Vector128<short> mad2 = Ssse3.MultiplyAddAdjacent(bytes2, tap2);
+                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2, ones));
+
+                        localBufferPtr += BLOCK_SIZE;
+                    }
+                    while (--n > 0);
+
+                    v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5));
+
+                    // Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
+                    const byte S2301 = 0b1011_0001;  // A B C D -> B A D C
+                    const byte S1032 = 0b0100_1110;  // A B C D -> C D A B
+
+                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S2301));
+                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S1032));
+
+                    s1 += (uint)v_s1.ToScalar();
+
+                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S2301));
+                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S1032));
+
+                    s2 = (uint)v_s2.ToScalar();
+
+                    // Reduce.
+                    s1 %= BASE;
+                    s2 %= BASE;
+                }
+            }
+
+            ref byte bufferRef = ref MemoryMarshal.GetReference(buffer);
+
+            if (length > 0)
+            {
+                if (length >= 16)
+                {
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    length -= 16;
+                }
+
+                while (length-- > 0)
+                {
+                    s2 += s1 += Unsafe.Add(ref bufferRef, index++);
+                }
+
+                if (s1 >= BASE)
+                {
+                    s1 -= BASE;
+                }
+
+                s2 %= BASE;
+            }
+
+            return s1 | (s2 << 16);
+        }
+#endif
+
+        private static uint CalculateScalar(uint adler, ReadOnlySpan<byte> buffer)
+        {
+            uint s1 = adler & 0xFFFF;
+            uint s2 = (adler >> 16) & 0xFFFF;
+            uint k;
+
+            ref byte bufferRef = ref MemoryMarshal.GetReference<byte>(buffer);
+            uint length = (uint)buffer.Length;
+            int index = 0;
+
+            while (length > 0)
+            {
+                k = length < NMAX ? length : NMAX;
+                length -= k;
+
+                while (k >= 16)
+                {
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    s1 += Unsafe.Add(ref bufferRef, index++);
+                    s2 += s1;
+                    k -= 16;
+                }
+
+                if (k != 0)
+                {
+                    do
+                    {
+                        s1 += Unsafe.Add(ref bufferRef, index++);
+                        s2 += s1;
+                    }
+                    while (--k != 0);
+                }
+
+                s1 %= BASE;
+                s2 %= BASE;
+            }
+
+            return (s2 << 16) | s1;
+        }
+    }
+}
--- a/src/SharpCompress/Archives/AbstractArchive.cs
+++ b/src/SharpCompress/Archives/AbstractArchive.cs
@@ -1,173 +1,149 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
-using SharpCompress.IO;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives;
-
-public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
-    where TEntry : IArchiveEntry
-    where TVolume : IVolume
+namespace SharpCompress.Archives
 {
-    private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
-    private readonly LazyReadOnlyCollection<TEntry> lazyEntries;
-
-    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
-    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
-
-    public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
-    public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
-
-    protected ReaderOptions ReaderOptions { get; }
-
-    private bool disposed;
-    protected SourceStream SrcStream;
-
-    internal AbstractArchive(ArchiveType type, SourceStream srcStream)
+    public abstract class AbstractArchive<TEntry, TVolume> : IArchive
+        where TEntry : IArchiveEntry
+        where TVolume : IVolume
    {
-        Type = type;
-        ReaderOptions = srcStream.ReaderOptions;
-        SrcStream = srcStream;
-        lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
-        lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
-    }
+        private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
+        private readonly LazyReadOnlyCollection<TEntry> lazyEntries;

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

-#nullable enable
+        private bool disposed;

-    public ArchiveType Type { get; }
-
-    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
-        EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-
-    void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) =>
-        EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-
-    private static Stream CheckStreams(Stream stream)
-    {
-        if (!stream.CanSeek || !stream.CanRead)
+        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions, CancellationToken cancellationToken)
        {
-            throw new ArgumentException("Archive streams must be Readable and Seekable");
+            Type = type;
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("File does not exist: " + fileInfo.FullName);
+            }
+            ReaderOptions = readerOptions;
+            readerOptions.LeaveStreamOpen = false;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo, cancellationToken));
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes, cancellationToken));
        }
-        return stream;
-    }

-    /// <summary>
-    /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
-    /// </summary>
-    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;
+        protected abstract IAsyncEnumerable<TVolume> LoadVolumes(FileInfo file, CancellationToken cancellationToken);

-    /// <summary>
-    /// The total size of the files compressed in the archive.
-    /// </summary>
-    public virtual long TotalSize =>
-        Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize);
-
-    /// <summary>
-    /// The total size of the files as uncompressed in the archive.
-    /// </summary>
-    public virtual long TotalUncompressSize =>
-        Entries.Aggregate(0L, (total, cf) => total + cf.Size);
-
-    protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream srcStream);
-    protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
-
-    IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
-
-    IEnumerable<IVolume> IArchive.Volumes => lazyVolumes.Cast<IVolume>();
-
-    public virtual void Dispose()
-    {
-        if (!disposed)
+        internal AbstractArchive(ArchiveType type, IAsyncEnumerable<Stream> streams, ReaderOptions readerOptions, CancellationToken cancellationToken)
        {
-            lazyVolumes.ForEach(v => v.Dispose());
-            lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
-            SrcStream?.Dispose();
-
-            disposed = true;
+            Type = type;
+            ReaderOptions = readerOptions;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams), cancellationToken));
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes, cancellationToken));
        }
-    }

-    void IArchiveExtractionListener.EnsureEntriesLoaded()
-    {
-        lazyEntries.EnsureFullyLoaded();
-        lazyVolumes.EnsureFullyLoaded();
-    }
-
-    void IExtractionListener.FireCompressedBytesRead(
-        long currentPartCompressedBytes,
-        long compressedReadBytes
-    ) =>
-        CompressedBytesRead?.Invoke(
-            this,
-            new CompressedBytesReadEventArgs(
-                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
-                compressedBytesRead: compressedReadBytes
-            )
-        );
-
-    void IExtractionListener.FireFilePartExtractionBegin(
-        string name,
-        long size,
-        long compressedSize
-    ) =>
-        FilePartExtractionBegin?.Invoke(
-            this,
-            new FilePartExtractionBeginEventArgs(
-                compressedSize: compressedSize,
-                size: size,
-                name: name
-            )
-        );
-
-    /// <summary>
-    /// Use this method to extract all entries in an archive in order.
-    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
-    /// extracted sequentially for the best performance.
-    ///
-    /// This method will load all entry information from the archive.
-    ///
-    /// WARNING: this will reuse the underlying stream for the archive.  Errors may
-    /// occur if this is used at the same time as other extraction methods on this instance.
-    /// </summary>
-    /// <returns></returns>
-    public IReader ExtractAllEntries()
-    {
-        ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-        return CreateReaderForSolidExtraction();
-    }
-
-    protected abstract IReader CreateReaderForSolidExtraction();
-
-    /// <summary>
-    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-    /// </summary>
-    public virtual bool IsSolid => false;
-
-    /// <summary>
-    /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
-    /// </summary>
-    public bool IsComplete
-    {
-        get
+        internal AbstractArchive(ArchiveType type)
        {
-            ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-            return Entries.All(x => x.IsComplete);
+            Type = type;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>( AsyncEnumerable.Empty<TVolume>());
+            lazyEntries = new LazyReadOnlyCollection<TEntry>(AsyncEnumerable.Empty<TEntry>());
+        }
+
+        public ArchiveType Type { get; }
+
+        private static Stream CheckStreams(Stream stream)
+        {
+            if (!stream.CanSeek || !stream.CanRead)
+            {
+                throw new ArgumentException("Archive streams must be Readable and Seekable");
+            }
+            return stream;
+        }
+
+        /// <summary>
+        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
+        /// </summary>
+        public virtual IAsyncEnumerable<TEntry> Entries => lazyEntries;
+
+        /// <summary>
+        /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
+        /// </summary>
+        public IAsyncEnumerable<TVolume> Volumes => lazyVolumes;
+
+        /// <summary>
+        /// The total size of the files compressed in the archive.
+        /// </summary>
+        public virtual async ValueTask<long> TotalSizeAsync()
+        {
+            await EnsureEntriesLoaded();
+            return await Entries.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
+        }
+
+        /// <summary>
+        /// The total size of the files as uncompressed in the archive.
+        /// </summary>
+        public virtual async ValueTask<long> TotalUncompressedSizeAsync()
+        {
+            await EnsureEntriesLoaded();
+            return await Entries.AggregateAsync(0L, (total, cf) => total + cf.Size);
+        }
+
+        protected abstract IAsyncEnumerable<TVolume> LoadVolumes(IAsyncEnumerable<Stream> streams, CancellationToken cancellationToken);
+        protected abstract IAsyncEnumerable<TEntry> LoadEntries(IAsyncEnumerable<TVolume> volumes, CancellationToken cancellationToken);
+
+        IAsyncEnumerable<IArchiveEntry> IArchive.Entries => Entries.Select(x => (IArchiveEntry)x);
+
+        IAsyncEnumerable<IVolume> IArchive.Volumes => lazyVolumes.Select(x => (IVolume)x);
+
+        public virtual async ValueTask DisposeAsync()
+        {
+            if (!disposed)
+            {
+                await lazyVolumes.ForEachAsync(async v => await v.DisposeAsync());
+                await lazyEntries.GetLoaded().Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
+                disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Use this method to extract all entries in an archive in order.
+        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
+        /// extracted sequentially for the best performance.
+        ///
+        /// This method will load all entry information from the archive.
+        ///
+        /// WARNING: this will reuse the underlying stream for the archive.  Errors may
+        /// occur if this is used at the same time as other extraction methods on this instance.
+        /// </summary>
+        /// <returns></returns>
+        public async ValueTask<IReader> ExtractAllEntries()
+        {
+            await EnsureEntriesLoaded();
+            return await CreateReaderForSolidExtraction();
+        }
+        
+        public async ValueTask EnsureEntriesLoaded()
+        {
+            await lazyEntries.EnsureFullyLoaded();
+            await lazyVolumes.EnsureFullyLoaded();
+        }
+
+        protected abstract ValueTask<IReader> CreateReaderForSolidExtraction();
+
+        /// <summary>
+        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
+        /// </summary>
+        public virtual ValueTask<bool> IsSolidAsync() => new(false);
+
+        /// <summary>
+        /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
+        /// </summary>
+        public async ValueTask<bool> IsCompleteAsync()
+        {
+            await EnsureEntriesLoaded();
+            return await Entries.AllAsync(x => x.IsComplete);
        }
    }
 }
--- a/src/SharpCompress/Archives/AbstractWritableArchive.cs
+++ b/src/SharpCompress/Archives/AbstractWritableArchive.cs
@@ -1,179 +1,176 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
-using SharpCompress.IO;
+using SharpCompress.Readers;
 using SharpCompress.Writers;

-namespace SharpCompress.Archives;
-
-public abstract class AbstractWritableArchive<TEntry, TVolume>
-    : AbstractArchive<TEntry, TVolume>,
-        IWritableArchive
-    where TEntry : IArchiveEntry
-    where TVolume : IVolume
+namespace SharpCompress.Archives
 {
-    private class RebuildPauseDisposable : IDisposable
+    public abstract class AbstractWritableArchive<TEntry, TVolume> : AbstractArchive<TEntry, TVolume>, IWritableArchive
+        where TEntry : IArchiveEntry
+        where TVolume : IVolume
    {
-        private readonly AbstractWritableArchive<TEntry, TVolume> archive;
-
-        public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume> archive)
+        private class RebuildPauseDisposable : IAsyncDisposable
        {
-            this.archive = archive;
-            archive.pauseRebuilding = true;
-        }
+            private readonly AbstractWritableArchive<TEntry, TVolume> archive;

-        public void Dispose()
-        {
-            archive.pauseRebuilding = false;
-            archive.RebuildModifiedCollection();
-        }
-    }
-
-    private readonly List<TEntry> newEntries = new List<TEntry>();
-    private readonly List<TEntry> removedEntries = new List<TEntry>();
-
-    private readonly List<TEntry> modifiedEntries = new List<TEntry>();
-    private bool hasModifications;
-    private bool pauseRebuilding;
-
-    internal AbstractWritableArchive(ArchiveType type)
-        : base(type) { }
-
-    internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
-        : base(type, srcStream) { }
-
-    public override ICollection<TEntry> Entries
-    {
-        get
-        {
-            if (hasModifications)
+            public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume> archive)
            {
-                return modifiedEntries;
+                this.archive = archive;
+                archive.pauseRebuilding = true;
            }
-            return base.Entries;
-        }
-    }

-    public IDisposable PauseEntryRebuilding() => new RebuildPauseDisposable(this);
-
-    private void RebuildModifiedCollection()
-    {
-        if (pauseRebuilding)
-        {
-            return;
-        }
-        hasModifications = true;
-        newEntries.RemoveAll(v => removedEntries.Contains(v));
-        modifiedEntries.Clear();
-        modifiedEntries.AddRange(OldEntries.Concat(newEntries));
-    }
-
-    private IEnumerable<TEntry> OldEntries => base.Entries.Where(x => !removedEntries.Contains(x));
-
-    public void RemoveEntry(TEntry entry)
-    {
-        if (!removedEntries.Contains(entry))
-        {
-            removedEntries.Add(entry);
-            RebuildModifiedCollection();
-        }
-    }
-
-    void IWritableArchive.RemoveEntry(IArchiveEntry entry) => RemoveEntry((TEntry)entry);
-
-    public TEntry AddEntry(string key, Stream source, long size = 0, DateTime? modified = null) =>
-        AddEntry(key, source, false, size, modified);
-
-    IArchiveEntry IWritableArchive.AddEntry(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size,
-        DateTime? modified
-    ) => AddEntry(key, source, closeStream, size, modified);
-
-    public TEntry AddEntry(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size = 0,
-        DateTime? modified = null
-    )
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (DoesKeyMatchExisting(key))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateEntry(key, source, size, modified, closeStream);
-        newEntries.Add(entry);
-        RebuildModifiedCollection();
-        return entry;
-    }
-
-    private bool DoesKeyMatchExisting(string key)
-    {
-        foreach (var path in Entries.Select(x => x.Key))
-        {
-            var p = path.Replace('/', '\\');
-            if (p.Length > 0 && p[0] == '\\')
+            public async ValueTask DisposeAsync()
            {
-                p = p.Substring(1);
+                archive.pauseRebuilding = false;
+                await archive.RebuildModifiedCollection();
            }
-            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
        }
-        return false;
-    }
+        private readonly List<TEntry> newEntries = new();
+        private readonly List<TEntry> removedEntries = new();

-    public void SaveTo(Stream stream, WriterOptions options)
-    {
-        //reset streams of new entries
-        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        SaveTo(stream, options, OldEntries, newEntries);
-    }
+        private readonly List<TEntry> modifiedEntries = new();
+        private bool hasModifications;
+        private bool pauseRebuilding;

-    protected TEntry CreateEntry(
-        string key,
-        Stream source,
-        long size,
-        DateTime? modified,
-        bool closeStream
-    )
-    {
-        if (!source.CanRead || !source.CanSeek)
+        internal AbstractWritableArchive(ArchiveType type)
+            : base(type)
        {
-            throw new ArgumentException(
-                "Streams must be readable and seekable to use the Writing Archive API"
-            );
        }
-        return CreateEntryInternal(key, source, size, modified, closeStream);
-    }

-    protected abstract TEntry CreateEntryInternal(
-        string key,
-        Stream source,
-        long size,
-        DateTime? modified,
-        bool closeStream
-    );
+        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions,
+                                         CancellationToken cancellationToken)
+            : base(type, stream.AsAsyncEnumerable(), readerFactoryOptions, cancellationToken)
+        {
+        }

-    protected abstract void SaveTo(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TEntry> oldEntries,
-        IEnumerable<TEntry> newEntries
-    );
+        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions,
+                                         CancellationToken cancellationToken)
+            : base(type, fileInfo, readerFactoryOptions, cancellationToken)
+        {
+        }

-    public override void Dispose()
-    {
-        base.Dispose();
-        newEntries.Cast<Entry>().ForEach(x => x.Close());
-        removedEntries.Cast<Entry>().ForEach(x => x.Close());
-        modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
+        public override IAsyncEnumerable<TEntry> Entries
+        {
+            get
+            {
+                if (hasModifications)
+                {
+                    return modifiedEntries.ToAsyncEnumerable();
+                }
+                return base.Entries;
+            }
+        }
+
+        public IAsyncDisposable PauseEntryRebuilding()
+        {
+            return new RebuildPauseDisposable(this);
+        }
+
+        private async ValueTask RebuildModifiedCollection()
+        {
+            if (pauseRebuilding)
+            {
+                return;
+            }
+            hasModifications = true;
+            newEntries.RemoveAll(v => removedEntries.Contains(v));
+            modifiedEntries.Clear();
+            modifiedEntries.AddRange(await OldEntries.Concat(newEntries.ToAsyncEnumerable()).ToListAsync());
+        }
+
+        private IAsyncEnumerable<TEntry> OldEntries { get { return base.Entries.Where(x => !removedEntries.Contains(x)); } }
+
+        public async ValueTask RemoveEntryAsync(TEntry entry)
+        {
+            if (!removedEntries.Contains(entry))
+            {
+                removedEntries.Add(entry);
+                await RebuildModifiedCollection();
+            }
+        }
+
+        ValueTask IWritableArchive.RemoveEntryAsync(IArchiveEntry entry, CancellationToken cancellationToken)
+        {
+            return RemoveEntryAsync((TEntry)entry);
+        }
+
+        public ValueTask<TEntry>  AddEntryAsync(string key, Stream source,
+                                                       long size = 0, DateTime? modified = null, 
+                                                       CancellationToken cancellationToken = default)
+        {
+            return AddEntryAsync(key, source, false, size, modified, cancellationToken);
+        }
+
+        async ValueTask<IArchiveEntry> IWritableArchive.AddEntryAsync(string key, Stream source, bool closeStream, long size, DateTime? modified, CancellationToken cancellationToken)
+        {
+            return await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken);
+        }
+
+        public async ValueTask<TEntry> AddEntryAsync(string key, Stream source, bool closeStream,
+                                    long size = 0, DateTime? modified = null, CancellationToken cancellationToken = default)
+        {
+            if (key.Length > 0 && key[0] is '/' or '\\')
+            {
+                key = key.Substring(1);
+            }
+            if (await DoesKeyMatchExisting(key))
+            {
+                throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+            }
+            var entry = await CreateEntry(key, source, size, modified, closeStream, cancellationToken);
+            newEntries.Add(entry);
+            await RebuildModifiedCollection();
+            return entry;
+        }
+
+        private async ValueTask<bool> DoesKeyMatchExisting(string key)
+        {
+            await foreach (var path in Entries.Select(x => x.Key))
+            {
+                var p = path.Replace('/', '\\');
+                if (p.Length > 0 && p[0] == '\\')
+                {
+                    p = p.Substring(1);
+                }
+                return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+            }
+            return false;
+        }
+
+        public async ValueTask SaveToAsync(Stream stream, WriterOptions options, CancellationToken cancellationToken = default)
+        {
+            //reset streams of new entries
+            newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+            await SaveToAsync(stream, options, OldEntries, newEntries.ToAsyncEnumerable(), cancellationToken);
+        }
+
+        protected ValueTask<TEntry> CreateEntry(string key, Stream source, long size, DateTime? modified,
+                                                bool closeStream, CancellationToken cancellationToken)
+        {
+            if (!source.CanRead || !source.CanSeek)
+            {
+                throw new ArgumentException("Streams must be readable and seekable to use the Writing Archive API");
+            }
+            return CreateEntryInternal(key, source, size, modified, closeStream, cancellationToken);
+        }
+
+        protected abstract ValueTask<TEntry> CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
+                                                      bool closeStream, CancellationToken cancellationToken);
+
+        protected abstract ValueTask SaveToAsync(Stream stream, WriterOptions options, IAsyncEnumerable<TEntry> oldEntries, IAsyncEnumerable<TEntry> newEntries,
+                                                 CancellationToken cancellationToken = default);
+
+        public override async ValueTask DisposeAsync()
+        {
+            await base.DisposeAsync();
+            await newEntries.Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
+            await removedEntries.Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
+            await modifiedEntries.Cast<Entry>().ForEachAsync(async x => await x.CloseAsync());
+        }
    }
 }
--- a/src/SharpCompress/Archives/ArchiveFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveFactory.cs
@@ -1,241 +1,137 @@
-using System;
-using System.Collections.Generic;
+using System;
 using System.IO;
-using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Archives.GZip;
+//using SharpCompress.Archives.Rar;
+//using SharpCompress.Archives.SevenZip;
+using SharpCompress.Archives.Tar;
+using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
-using SharpCompress.Factories;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives;
-
-public static class ArchiveFactory
+namespace SharpCompress.Archives
 {
-    /// <summary>
-    /// Opens an Archive for random access
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    /// <returns></returns>
-    public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    public static class ArchiveFactory
    {
-        readerOptions ??= new ReaderOptions();
-
-        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
-    }
-
-    public static IWritableArchive Create(ArchiveType type)
-    {
-        var factory = Factory.Factories
-            .OfType<IWriteableArchiveFactory>()
-            .FirstOrDefault(item => item.KnownArchiveType == type);
-
-        if (factory != null)
+        /// <summary>
+        /// Opens an Archive for random access
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        /// <returns></returns>
+        public static async ValueTask<IArchive> OpenAsync(Stream stream, ReaderOptions? readerOptions = null, CancellationToken cancellationToken = default)
        {
-            return factory.CreateWriteableArchive();
-        }
-
-        throw new NotSupportedException("Cannot create Archives of type: " + type);
-    }
-
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(string filePath, ReaderOptions? options = null)
-    {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), options);
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
-    {
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
-    }
-
-    /// <summary>
-    /// Constructor with IEnumerable FileInfo objects, multi and split support.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
-    {
-        fileInfos.CheckNotNull(nameof(fileInfos));
-        var filesArray = fileInfos.ToArray();
-        if (filesArray.Length == 0)
-        {
-            throw new InvalidOperationException("No files to open");
-        }
-
-        var fileInfo = filesArray[0];
-        if (filesArray.Length == 1)
-        {
-            return Open(fileInfo, options);
-        }
-
-        fileInfo.CheckNotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
-    }
-
-    /// <summary>
-    /// Constructor with IEnumerable FileInfo objects, multi and split support.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="options"></param>
-    public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
-    {
-        streams.CheckNotNull(nameof(streams));
-        var streamsArray = streams.ToArray();
-        if (streamsArray.Length == 0)
-        {
-            throw new InvalidOperationException("No streams");
-        }
-
-        var firstStream = streamsArray[0];
-        if (streamsArray.Length == 1)
-        {
-            return Open(firstStream, options);
-        }
-
-        firstStream.CheckNotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
-
-        return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
-    }
-
-    /// <summary>
-    /// Extract to specific directory, retaining filename
-    /// </summary>
-    public static void WriteToDirectory(
-        string sourceArchive,
-        string destinationDirectory,
-        ExtractionOptions? options = null
-    )
-    {
-        using var archive = Open(sourceArchive);
-        foreach (var entry in archive.Entries)
-        {
-            entry.WriteToDirectory(destinationDirectory, options);
-        }
-    }
-
-    private static T FindFactory<T>(FileInfo finfo)
-        where T : IFactory
-    {
-        finfo.CheckNotNull(nameof(finfo));
-        using Stream stream = finfo.OpenRead();
-        return FindFactory<T>(stream);
-    }
-
-    private static T FindFactory<T>(Stream stream)
-        where T : IFactory
-    {
-        stream.CheckNotNull(nameof(stream));
-        if (!stream.CanRead || !stream.CanSeek)
-        {
-            throw new ArgumentException("Stream should be readable and seekable");
-        }
-
-        var factories = Factory.Factories.OfType<T>();
-
-        var startPosition = stream.Position;
-
-        foreach (var factory in factories)
-        {
-            stream.Seek(startPosition, SeekOrigin.Begin);
-
-            if (factory.IsArchive(stream))
+            stream.CheckNotNull(nameof(stream));
+            if (!stream.CanRead || !stream.CanSeek)
            {
-                stream.Seek(startPosition, SeekOrigin.Begin);
-
-                return factory;
+                throw new ArgumentException("Stream should be readable and seekable");
            }
-        }
-
-        var extensions = string.Join(", ", factories.Select(item => item.Name));
-
-        throw new InvalidOperationException(
-            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
-        );
-    }
-
-    public static bool IsArchive(string filePath, out ArchiveType? type)
-    {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
-        using Stream s = File.OpenRead(filePath);
-        return IsArchive(s, out type);
-    }
-
-    public static bool IsArchive(Stream stream, out ArchiveType? type)
-    {
-        type = null;
-        stream.CheckNotNull(nameof(stream));
-
-        if (!stream.CanRead || !stream.CanSeek)
-        {
-            throw new ArgumentException("Stream should be readable and seekable");
-        }
-
-        var startPosition = stream.Position;
-
-        foreach (var factory in Factory.Factories)
-        {
-            stream.Position = startPosition;
-
-            if (factory.IsArchive(stream, null))
+            readerOptions ??= new ReaderOptions();
+            if (await ZipArchive.IsZipFileAsync(stream, null, cancellationToken))
            {
-                type = factory.KnownArchiveType;
-                return true;
+                stream.Seek(0, SeekOrigin.Begin);
+                return ZipArchive.Open(stream, readerOptions);
            }
+            stream.Seek(0, SeekOrigin.Begin);
+            /*if (SevenZipArchive.IsSevenZipFile(stream))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return SevenZipArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);  */
+            if (await GZipArchive.IsGZipFileAsync(stream, cancellationToken))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return GZipArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+           /* if (RarArchive.IsRarFile(stream, readerOptions))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return RarArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);  */
+            if (await TarArchive.IsTarFileAsync(stream, cancellationToken))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return TarArchive.Open(stream, readerOptions);
+            }                    
+            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
        }

-        return false;
-    }
-
-    /// <summary>
-    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
-    /// </summary>
-    /// <param name="part1"></param>
-    /// <returns></returns>
-    public static IEnumerable<string> GetFileParts(string part1)
-    {
-        part1.CheckNotNullOrEmpty(nameof(part1));
-        return GetFileParts(new FileInfo(part1)).Select(a => a.FullName);
-    }
-
-    /// <summary>
-    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
-    /// </summary>
-    /// <param name="part1"></param>
-    /// <returns></returns>
-    public static IEnumerable<FileInfo> GetFileParts(FileInfo part1)
-    {
-        part1.CheckNotNull(nameof(part1));
-        yield return part1;
-
-        foreach (var factory in Factory.Factories.OfType<IFactory>())
+        public static IWritableArchive Create(ArchiveType type)
        {
-            var i = 1;
-            var part = factory.GetFilePart(i++, part1);
-
-            if (part != null)
+            return type switch
            {
-                yield return part;
-                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
-                {
-                    yield return part;
-                }
+                ArchiveType.Zip => ZipArchive.Create(),
+                //ArchiveType.Tar => TarArchive.Create(),
+                ArchiveType.GZip => GZipArchive.Create(),
+                _ => throw new NotSupportedException("Cannot create Archives of type: " + type)
+            };
+        }

-                yield break;
+        /// <summary>
+        /// Constructor expects a filepath to an existing file.
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="options"></param>
+        public static ValueTask<IArchive> OpenAsync(string filePath, ReaderOptions? options = null)
+        {
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return OpenAsync(new FileInfo(filePath), options);
+        }
+
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="options"></param>
+        public static async ValueTask<IArchive> OpenAsync(FileInfo fileInfo, ReaderOptions? options = null, CancellationToken cancellationToken = default)
+        {
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+            await using var stream = fileInfo.OpenRead();
+            if (await ZipArchive.IsZipFileAsync(stream, null, cancellationToken))
+            {
+                return ZipArchive.Open(fileInfo, options);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            /*if (SevenZipArchive.IsSevenZipFile(stream))
+            {
+                return SevenZipArchive.Open(fileInfo, options);
+            }
+            stream.Seek(0, SeekOrigin.Begin);     */
+            if (await GZipArchive.IsGZipFileAsync(stream, cancellationToken))
+            {
+                return GZipArchive.Open(fileInfo, options);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            /*if (RarArchive.IsRarFile(stream, options))
+            {
+                return RarArchive.Open(fileInfo, options);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            if (TarArchive.IsTarFile(stream))
+            {
+                return TarArchive.Open(fileInfo, options);
+            }                          */
+            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
+        }
+
+        /// <summary>
+        /// Extract to specific directory, retaining filename
+        /// </summary>
+        public static async ValueTask WriteToDirectory(string sourceArchive, 
+                                                       string destinationDirectory,
+                                                 ExtractionOptions? options = null, 
+                                                 CancellationToken cancellationToken = default)
+        {
+            await using IArchive archive = await OpenAsync(sourceArchive);
+            await foreach (IArchiveEntry entry in archive.Entries.WithCancellation(cancellationToken))
+            {
+                await entry.WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken);
            }
        }
    }
--- a/src/SharpCompress/Archives/ArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveVolumeFactory.cs
@@ -1,30 +0,0 @@
-using System;
-using System.IO;
-using System.Text.RegularExpressions;
-
-namespace SharpCompress.Archives;
-
-internal abstract class ArchiveVolumeFactory
-{
-    internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
-    {
-        FileInfo? item = null;
-
-        //split 001, 002 ...
-        Match m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
-        if (m.Success)
-            item = new FileInfo(
-                Path.Combine(
-                    part1.DirectoryName!,
-                    String.Concat(
-                        m.Groups[1].Value,
-                        (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0')
-                    )
-                )
-            );
-
-        if (item != null && item.Exists)
-            return item;
-        return null;
-    }
-}
--- a/src/SharpCompress/Archives/GZip/GZipArchive.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchive.cs
@@ -1,206 +1,192 @@
-using System;
+using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
 using SharpCompress.Writers.GZip;

-namespace SharpCompress.Archives.GZip;
-
-public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+namespace SharpCompress.Archives.GZip
 {
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.CheckNotNull(nameof(fileInfo));
-        return new GZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.CheckNotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new GZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.CheckNotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new GZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.CheckNotNull(nameof(stream));
-        return new GZipArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static GZipArchive Create() => new GZipArchive();
-
-    /// <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) { }
-
-    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
-    {
-        srcStream.LoadAllParts();
-        var idx = 0;
-        return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, idx++));
-    }
-
-    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
-
-    public static bool IsGZipFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
+        /// <summary>
+        /// Constructor expects a filepath to an existing file.
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
        {
-            return false;
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }

-        using Stream stream = fileInfo.OpenRead();
-        return IsGZipFile(stream);
-    }
-
-    public void SaveTo(string filePath) => SaveTo(new FileInfo(filePath));
-
-    public void SaveTo(FileInfo fileInfo)
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        SaveTo(stream, new WriterOptions(CompressionType.GZip));
-    }
-
-    public static bool IsGZipFile(Stream stream)
-    {
-        // read the header on the first read
-        Span<byte> header = stackalloc byte[10];
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (!stream.ReadFully(header))
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null,
+                                       CancellationToken cancellationToken = default)
        {
-            return false;
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions(), cancellationToken);
        }

-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        /// <summary>
+        /// Takes a seekable Stream as a source
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null,
+                                       CancellationToken cancellationToken = default)
        {
-            return false;
+            stream.CheckNotNull(nameof(stream));
+            return new GZipArchive(stream, readerOptions ?? new ReaderOptions(), cancellationToken);
        }

-        return true;
-    }
-
-    internal GZipArchive()
-        : base(ArchiveType.GZip) { }
-
-    protected override GZipArchiveEntry CreateEntryInternal(
-        string filePath,
-        Stream source,
-        long size,
-        DateTime? modified,
-        bool closeStream
-    )
-    {
-        if (Entries.Any())
+        public static GZipArchive Create()
        {
-            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            return new GZipArchive();
        }
-        return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
-    }

-    protected override void SaveTo(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<GZipArchiveEntry> oldEntries,
-        IEnumerable<GZipArchiveEntry> newEntries
-    )
-    {
-        if (Entries.Count > 1)
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="options"></param>
+        internal GZipArchive(FileInfo fileInfo, ReaderOptions options,
+                             CancellationToken cancellationToken)
+            : base(ArchiveType.GZip, fileInfo, options, cancellationToken)
        {
-            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
        }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
+
+        protected override IAsyncEnumerable<GZipVolume> LoadVolumes(FileInfo file,
+                                                                    CancellationToken cancellationToken)
        {
-            using var entryStream = entry.OpenEntryStream();
-            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+            return  new GZipVolume(file, ReaderOptions).AsAsyncEnumerable();
        }
-    }

-    protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
-    {
-        var stream = volumes.Single().Stream;
-        yield return new GZipArchiveEntry(
-            this,
-            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
-        );
-    }
+        public static ValueTask<bool> IsGZipFileAsync(string filePath, CancellationToken cancellationToken = default)
+        {
+            return IsGZipFileAsync(new FileInfo(filePath), cancellationToken);
+        }

-    protected override IReader CreateReaderForSolidExtraction()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return GZipReader.Open(stream);
+        public static async ValueTask<bool> IsGZipFileAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+        {
+            if (!fileInfo.Exists)
+            {
+                return false;
+            }
+
+            await using Stream stream = fileInfo.OpenRead();
+            return await IsGZipFileAsync(stream, cancellationToken);
+        }
+
+        public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default)
+        {
+            return SaveToAsync(new FileInfo(filePath), cancellationToken);
+        }
+
+        public async Task SaveToAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+        {
+            await using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+            await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken);
+        }
+
+        public static async ValueTask<bool> IsGZipFileAsync(Stream stream, CancellationToken cancellationToken = default)
+        {
+            // read the header on the first read
+            using var header = MemoryPool<byte>.Shared.Rent(10);
+            var slice = header.Memory.Slice(0, 10);
+
+            // workitem 8501: handle edge case (decompress empty stream)
+            if (await stream.ReadAsync(slice, cancellationToken) != 10)
+            {
+                return false;
+            }
+
+            if (slice.Span[0] != 0x1F || slice.Span[1] != 0x8B || slice.Span[2] != 8)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Takes multiple seekable Streams for a multi-part archive
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="options"></param>
+        internal GZipArchive(Stream stream, ReaderOptions options,
+                             CancellationToken cancellationToken)
+            : base(ArchiveType.GZip, stream, options, cancellationToken)
+        {
+        }
+
+        internal GZipArchive()
+            : base(ArchiveType.GZip)
+        {
+        }
+
+        protected override async ValueTask<GZipArchiveEntry> CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
+                                                                bool closeStream, CancellationToken cancellationToken = default)
+        {
+            if (await Entries.AnyAsync(cancellationToken: cancellationToken))
+            {
+                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            }
+            return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
+        }
+
+        protected override async ValueTask SaveToAsync(Stream stream, WriterOptions options,
+                                            IAsyncEnumerable<GZipArchiveEntry> oldEntries,
+                                            IAsyncEnumerable<GZipArchiveEntry> newEntries, 
+                                            CancellationToken cancellationToken = default)
+        {
+            if (await Entries.CountAsync(cancellationToken: cancellationToken) > 1)
+            {
+                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
+            }
+
+            await using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+            await foreach (var entry in oldEntries.Concat(newEntries)
+                                                  .Where(x => !x.IsDirectory)
+                                                  .WithCancellation(cancellationToken))
+            {
+                await using var entryStream = await entry.OpenEntryStreamAsync(cancellationToken);
+                await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
+            }
+        }
+
+        protected override async IAsyncEnumerable<GZipVolume> LoadVolumes(IAsyncEnumerable<Stream> streams,
+                                                                          [EnumeratorCancellation]CancellationToken cancellationToken)
+        {
+            yield return new GZipVolume(await streams.FirstAsync(cancellationToken: cancellationToken), ReaderOptions);
+        }
+
+        protected override async IAsyncEnumerable<GZipArchiveEntry> LoadEntries(IAsyncEnumerable<GZipVolume> volumes,
+                                                                                [EnumeratorCancellation]CancellationToken cancellationToken)
+        {
+            Stream stream = (await volumes.SingleAsync(cancellationToken: cancellationToken)).Stream;
+            var part = new GZipFilePart(ReaderOptions.ArchiveEncoding);
+            await part.Initialize(stream, cancellationToken);
+            yield return new GZipArchiveEntry(this, part);
+        }
+
+        protected override async ValueTask<IReader> CreateReaderForSolidExtraction()
+        {
+            var stream = (await Volumes.SingleAsync()).Stream;
+            stream.Position = 0;
+            return GZipReader.Open(stream);
+        }
    }
 }
--- a/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
@@ -1,30 +1,36 @@
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.GZip;

-namespace SharpCompress.Archives.GZip;
-
-public class GZipArchiveEntry : GZipEntry, IArchiveEntry
+namespace SharpCompress.Archives.GZip
 {
-    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
-        : base(part) => Archive = archive;
-
-    public virtual Stream OpenEntryStream()
+    public class GZipArchiveEntry : GZipEntry, IArchiveEntry
    {
-        //this is to reset the stream to be read multiple times
-        var part = (GZipFilePart)Parts.Single();
-        if (part.GetRawStream().Position != part.EntryStartPosition)
+        internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
+            : base(part)
        {
-            part.GetRawStream().Position = part.EntryStartPosition;
+            Archive = archive;
        }
-        return Parts.Single().GetCompressedStream();
+
+        public virtual async ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        {
+            //this is to reset the stream to be read multiple times
+            var part = (GZipFilePart)Parts.Single();
+            if (part.GetRawStream().Position != part.EntryStartPosition)
+            {
+                part.GetRawStream().Position = part.EntryStartPosition;
+            }
+            return await Parts.Single().GetCompressedStreamAsync(cancellationToken);
+        }
+
+        #region IArchiveEntry Members
+
+        public IArchive Archive { get; }
+
+        public bool IsComplete => true;
+
+        #endregion
    }
-
-    #region IArchiveEntry Members
-
-    public IArchive Archive { get; }
-
-    public bool IsComplete => true;
-
-    #endregion
-}
+}
--- a/src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs
@@ -1,73 +1,70 @@
-#nullable disable
+#nullable disable

 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

-namespace SharpCompress.Archives.GZip;
-
-internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
+namespace SharpCompress.Archives.GZip
 {
-    private readonly bool closeStream;
-    private readonly Stream stream;
-
-    internal GZipWritableArchiveEntry(
-        GZipArchive archive,
-        Stream stream,
-        string path,
-        long size,
-        DateTime? lastModified,
-        bool closeStream
-    )
-        : base(archive, null)
+    internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
    {
-        this.stream = stream;
-        Key = path;
-        Size = size;
-        LastModifiedTime = lastModified;
-        this.closeStream = closeStream;
-    }
+        private readonly bool closeStream;
+        private readonly Stream stream;

-    public override long Crc => 0;
-
-    public override string Key { get; }
-
-    public override long CompressedSize => 0;
-
-    public override long Size { get; }
-
-    public override DateTime? LastModifiedTime { get; }
-
-    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 => throw new NotImplementedException();
-
-    Stream IWritableArchiveEntry.Stream => stream;
-
-    public override Stream OpenEntryStream()
-    {
-        //ensure new stream is at the start, this could be reset
-        stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
-    }
-
-    internal override void Close()
-    {
-        if (closeStream)
+        internal GZipWritableArchiveEntry(GZipArchive archive, Stream stream,
+                                          string path, long size, DateTime? lastModified, bool closeStream)
+            : base(archive, null)
        {
-            stream.Dispose();
+            this.stream = stream;
+            Key = path;
+            Size = size;
+            LastModifiedTime = lastModified;
+            this.closeStream = closeStream;
+        }
+
+        public override long Crc => 0;
+
+        public override string Key { get; }
+
+        public override long CompressedSize => 0;
+
+        public override long Size { get; }
+
+        public override DateTime? LastModifiedTime { get; }
+
+        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 => throw new NotImplementedException();
+
+        Stream IWritableArchiveEntry.Stream => stream;
+
+        public override ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        {
+            //ensure new stream is at the start, this could be reset
+            stream.Seek(0, SeekOrigin.Begin);
+            return new(new NonDisposingStream(stream));
+        }
+
+        internal override async ValueTask CloseAsync()
+        {
+            if (closeStream)
+            {
+                await stream.DisposeAsync();
+            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/IArchive.cs
+++ b/src/SharpCompress/Archives/IArchive.cs
@@ -1,48 +1,44 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives;
-
-public interface IArchive : IDisposable
+namespace SharpCompress.Archives
 {
-    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
-    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+    public interface IArchive : IAsyncDisposable
+    {
+        IAsyncEnumerable<IArchiveEntry> Entries { get; }
+        IAsyncEnumerable<IVolume> Volumes { get; }

-    event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
-    event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+        ArchiveType Type { get; }
+        ValueTask EnsureEntriesLoaded();
+        /// <summary>
+        /// Use this method to extract all entries in an archive in order.
+        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
+        /// extracted sequentially for the best performance.
+        /// </summary>
+        ValueTask<IReader> ExtractAllEntries();

-    IEnumerable<IArchiveEntry> Entries { get; }
-    IEnumerable<IVolume> Volumes { get; }
+        /// <summary>
+        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
+        /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
+        /// </summary>
+        ValueTask<bool> IsSolidAsync();

-    ArchiveType Type { get; }
+        /// <summary>
+        /// This checks to see if all the known entries have IsComplete = true
+        /// </summary>
+        ValueTask<bool> IsCompleteAsync();

-    /// <summary>
-    /// Use this method to extract all entries in an archive in order.
-    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
-    /// extracted sequentially for the best performance.
-    /// </summary>
-    IReader ExtractAllEntries();
+        /// <summary>
+        /// The total size of the files compressed in the archive.
+        /// </summary>
+        ValueTask<long> TotalSizeAsync();

-    /// <summary>
-    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-    /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
-    /// </summary>
-    bool IsSolid { get; }
-
-    /// <summary>
-    /// This checks to see if all the known entries have IsComplete = true
-    /// </summary>
-    bool IsComplete { get; }
-
-    /// <summary>
-    /// The total size of the files compressed in the archive.
-    /// </summary>
-    long TotalSize { get; }
-
-    /// <summary>
-    /// The total size of the files as uncompressed in the archive.
-    /// </summary>
-    long TotalUncompressSize { get; }
-}
+        /// <summary>
+        /// The total size of the files as uncompressed in the archive.
+        /// </summary>
+        ValueTask<long> TotalUncompressedSizeAsync();
+    }
+}
--- a/src/SharpCompress/Archives/IArchiveEntry.cs
+++ b/src/SharpCompress/Archives/IArchiveEntry.cs
@@ -1,23 +1,26 @@
-using System.IO;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;

-namespace SharpCompress.Archives;
-
-public interface IArchiveEntry : IEntry
+namespace SharpCompress.Archives
 {
-    /// <summary>
-    /// Opens the current entry as a stream that will decompress as it is read.
-    /// Read the entire stream or use SkipEntry on EntryStream.
-    /// </summary>
-    Stream OpenEntryStream();
+    public interface IArchiveEntry : IEntry
+    {
+        /// <summary>
+        /// Opens the current entry as a stream that will decompress as it is read.
+        /// Read the entire stream or use SkipEntry on EntryStream.
+        /// </summary>
+        ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);

-    /// <summary>
-    /// The archive can find all the parts of the archive needed to extract this entry.
-    /// </summary>
-    bool IsComplete { get; }
+        /// <summary>
+        /// The archive can find all the parts of the archive needed to extract this entry.
+        /// </summary>
+        bool IsComplete { get; }

-    /// <summary>
-    /// The archive instance this entry belongs to
-    /// </summary>
-    IArchive Archive { get; }
-}
+        /// <summary>
+        /// The archive instance this entry belongs to
+        /// </summary>
+        IArchive Archive { get; }
+    }
+}
--- a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
@@ -1,70 +1,60 @@
-using System.IO;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

-namespace SharpCompress.Archives;
-
-public static class IArchiveEntryExtensions
+namespace SharpCompress.Archives
 {
-    public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
+    public static class IArchiveEntryExtensions
    {
-        if (archiveEntry.IsDirectory)
+        public static async ValueTask WriteToAsync(this IArchiveEntry archiveEntry, Stream streamToWriteTo, CancellationToken cancellationToken = default)
        {
-            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-        }
-
-        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
-        streamListener.EnsureEntriesLoaded();
-        streamListener.FireEntryExtractionBegin(archiveEntry);
-        streamListener.FireFilePartExtractionBegin(
-            archiveEntry.Key,
-            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);
-        }
-        streamListener.FireEntryExtractionEnd(archiveEntry);
-    }
-
-    /// <summary>
-    /// Extract to specific directory, retaining filename
-    /// </summary>
-    public static void WriteToDirectory(
-        this IArchiveEntry entry,
-        string destinationDirectory,
-        ExtractionOptions? options = null
-    ) =>
-        ExtractionMethods.WriteEntryToDirectory(
-            entry,
-            destinationDirectory,
-            options,
-            entry.WriteToFile
-        );
-
-    /// <summary>
-    /// Extract to specific file
-    /// </summary>
-    public static void WriteToFile(
-        this IArchiveEntry entry,
-        string destinationFileName,
-        ExtractionOptions? options = null
-    ) =>
-        ExtractionMethods.WriteEntryToFile(
-            entry,
-            destinationFileName,
-            options,
-            (x, fm) =>
+            if (archiveEntry.IsDirectory)
            {
-                using var fs = File.Open(destinationFileName, fm);
-                entry.WriteTo(fs);
+                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
            }
-        );
-}
+
+            var archive = archiveEntry.Archive;
+            await archive.EnsureEntriesLoaded();
+            var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
+            if (entryStream is null)
+            {
+                return;
+            }
+            await using (entryStream)
+            {
+                await entryStream.TransferToAsync(streamToWriteTo, cancellationToken);
+            }
+        }
+
+        /// <summary>
+        /// Extract to specific directory, retaining filename
+        /// </summary>
+        public static ValueTask WriteEntryToDirectoryAsync(this IArchiveEntry entry, 
+                                                           string destinationDirectory,
+                                                           ExtractionOptions? options = null, 
+                                                           CancellationToken cancellationToken = default)
+        {
+            return ExtractionMethods.WriteEntryToDirectoryAsync(entry, destinationDirectory, options,
+                                              entry.WriteToFileAsync, cancellationToken);
+        }
+
+        /// <summary>
+        /// Extract to specific file
+        /// </summary>
+        public static ValueTask WriteToFileAsync(this IArchiveEntry entry,
+                                       string destinationFileName,
+                                       ExtractionOptions? options = null, 
+                                       CancellationToken cancellationToken = default)
+        {
+
+            return ExtractionMethods.WriteEntryToFileAsync(entry, destinationFileName, options,
+                                               async (x, fm, ct) =>
+                                               {
+                                                   await using FileStream fs = File.Open(x, fm);
+                                                   await entry.WriteToAsync(fs, ct);
+                                               }, cancellationToken);
+        }
+    }
+}
--- a/src/SharpCompress/Archives/IArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveExtensions.cs
@@ -1,77 +1,24 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;

-namespace SharpCompress.Archives;
-
-public static class IArchiveExtensions
+namespace SharpCompress.Archives
 {
-    /// <summary>
-    /// Extract to specific directory, retaining filename
-    /// </summary>
-    public static void WriteToDirectory(
-        this IArchive archive,
-        string destinationDirectory,
-        ExtractionOptions? options = null
-    )
+    public static class IArchiveExtensions
    {
-        foreach (var entry in archive.Entries.Where(x => !x.IsDirectory))
+        /// <summary>
+        /// Extract to specific directory, retaining filename
+        /// </summary>
+        public static async ValueTask WriteToDirectoryAsync(this IArchive archive, 
+                                            string destinationDirectory,
+                                            ExtractionOptions? options = null,
+                                            CancellationToken cancellationToken = default)
        {
-            entry.WriteToDirectory(destinationDirectory, options);
+            await foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory).WithCancellation(cancellationToken))
+            {
+                await entry.WriteEntryToDirectoryAsync(destinationDirectory, options, cancellationToken);
+            }
        }
    }
-
-    /// <summary>
-    /// Extracts the archive to the destination directory. Directories will be created as needed.
-    /// </summary>
-    /// <param name="archive">The archive to extract.</param>
-    /// <param name="destination">The folder to extract into.</param>
-    /// <param name="progressReport">Optional progress report callback.</param>
-    /// <param name="cancellationToken">Optional cancellation token.</param>
-    public static void ExtractToDirectory(
-        this IArchive archive,
-        string destination,
-        Action<double>? progressReport = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        // Prepare for progress reporting
-        var totalBytes = archive.TotalUncompressSize;
-        var bytesRead = 0L;
-
-        // Tracking for created directories.
-        var seenDirectories = new HashSet<string>();
-
-        // Extract
-        var entries = archive.ExtractAllEntries();
-        while (entries.MoveToNextEntry())
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            var entry = entries.Entry;
-            if (entry.IsDirectory)
-            {
-                continue;
-            }
-
-            // Create each directory
-            var path = Path.Combine(destination, entry.Key);
-            if (Path.GetDirectoryName(path) is { } directory && seenDirectories.Add(path))
-            {
-                Directory.CreateDirectory(directory);
-            }
-
-            // Write file
-            using var fs = File.OpenWrite(path);
-            entries.WriteEntryTo(fs);
-
-            // Update progress
-            bytesRead += entry.Size;
-            progressReport?.Invoke(bytesRead / (double)totalBytes);
-        }
-    }
-}
+}
--- a/src/SharpCompress/Archives/IArchiveExtractionListener.cs
+++ b/src/SharpCompress/Archives/IArchiveExtractionListener.cs
@@ -1,10 +0,0 @@
-using SharpCompress.Common;
-
-namespace SharpCompress.Archives;
-
-internal interface IArchiveExtractionListener : IExtractionListener
-{
-    void EnsureEntriesLoaded();
-    void FireEntryExtractionBegin(IArchiveEntry entry);
-    void FireEntryExtractionEnd(IArchiveEntry entry);
-}
--- a/src/SharpCompress/Archives/IArchiveFactory.cs
+++ b/src/SharpCompress/Archives/IArchiveFactory.cs
@@ -1,35 +0,0 @@
-using System.IO;
-using SharpCompress.Factories;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-/// <summary>
-/// Represents a factory used to identify and open archives.
-/// </summary>
-/// <remarks>
-/// Currently implemented by:<br/>
-/// <list type="table">
-/// <item><see cref="TarFactory"/></item>
-/// <item><see cref="RarFactory"/></item>
-/// <item><see cref="ZipFactory"/></item>
-/// <item><see cref="GZipFactory"/></item>
-/// <item><see cref="SevenZipFactory"/></item>
-/// </list>
-/// </remarks>
-public interface IArchiveFactory : IFactory
-{
-    /// <summary>
-    /// Opens an Archive for random access.
-    /// </summary>
-    /// <param name="stream">An open, readable and seekable stream.</param>
-    /// <param name="readerOptions">reading options.</param>
-    IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo">the file to open.</param>
-    /// <param name="readerOptions">reading options.</param>
-    IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
-}
--- a/src/SharpCompress/Archives/IMultiArchiveFactory.cs
+++ b/src/SharpCompress/Archives/IMultiArchiveFactory.cs
@@ -1,36 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Factories;
-using SharpCompress.Readers;
-
-namespace SharpCompress.Archives;
-
-/// <summary>
-/// Represents a factory used to identify and open archives.
-/// </summary>
-/// <remarks>
-/// Implemented by:<br/>
-/// <list type="table">
-/// <item><see cref="TarFactory"/></item>
-/// <item><see cref="RarFactory"/></item>
-/// <item><see cref="ZipFactory"/></item>
-/// <item><see cref="GZipFactory"/></item>
-/// <item><see cref="SevenZipFactory"/></item>
-/// </list>
-/// </remarks>
-public interface IMultiArchiveFactory : IFactory
-{
-    /// <summary>
-    /// Constructor with IEnumerable FileInfo objects, multi and split support.
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions">reading options.</param>
-    IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
-
-    /// <summary>
-    /// Constructor with IEnumerable Stream objects, multi and split support.
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions">reading options.</param>
-    IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
-}
--- a/src/SharpCompress/Archives/IWritableArchive.cs
+++ b/src/SharpCompress/Archives/IWritableArchive.cs
@@ -1,26 +1,23 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Writers;

-namespace SharpCompress.Archives;
-
-public interface IWritableArchive : IArchive
+namespace SharpCompress.Archives
 {
-    void RemoveEntry(IArchiveEntry entry);
+    public interface IWritableArchive : IArchive
+    {
+        ValueTask RemoveEntryAsync(IArchiveEntry entry, CancellationToken cancellationToken = default);

-    IArchiveEntry AddEntry(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size = 0,
-        DateTime? modified = null
-    );
+        ValueTask<IArchiveEntry> AddEntryAsync(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null, CancellationToken cancellationToken = default);

-    void SaveTo(Stream stream, WriterOptions options);
+        ValueTask SaveToAsync(Stream stream, WriterOptions options, CancellationToken cancellationToken = default);

-    /// <summary>
-    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
-    /// </summary>
-    /// <returns>IDisposeable to resume entry rebuilding</returns>
-    IDisposable PauseEntryRebuilding();
-}
+        /// <summary>
+        /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
+        /// </summary>
+        /// <returns>IDisposeable to resume entry rebuilding</returns>
+        IAsyncDisposable PauseEntryRebuilding();
+    }
+}
--- a/src/SharpCompress/Archives/IWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/IWritableArchiveEntry.cs
@@ -1,8 +1,9 @@
-using System.IO;
+using System.IO;

-namespace SharpCompress.Archives;
-
-internal interface IWritableArchiveEntry
+namespace SharpCompress.Archives
 {
-    Stream Stream { get; }
-}
+    internal interface IWritableArchiveEntry
+    {
+        Stream Stream { get; }
+    }
+}
--- a/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
@@ -1,86 +1,62 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Writers;

-namespace SharpCompress.Archives;
-
-public static class IWritableArchiveExtensions
+namespace SharpCompress.Archives
 {
-    public static void AddEntry(
-        this IWritableArchive writableArchive,
-        string entryPath,
-        string filePath
-    )
+    public static class IWritableArchiveExtensions
    {
-        var fileInfo = new FileInfo(filePath);
-        if (!fileInfo.Exists)
+        public static async ValueTask AddEntryAsync(this IWritableArchive writableArchive,
+                                         string entryPath, string filePath, 
+                                         CancellationToken cancellationToken = default)
        {
-            throw new FileNotFoundException("Could not AddEntry: " + filePath);
-        }
-        writableArchive.AddEntry(
-            entryPath,
-            new FileInfo(filePath).OpenRead(),
-            true,
-            fileInfo.Length,
-            fileInfo.LastWriteTime
-        );
-    }
-
-    public static void SaveTo(
-        this IWritableArchive writableArchive,
-        string filePath,
-        WriterOptions options
-    ) => writableArchive.SaveTo(new FileInfo(filePath), options);
-
-    public static void SaveTo(
-        this IWritableArchive writableArchive,
-        FileInfo fileInfo,
-        WriterOptions options
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        writableArchive.SaveTo(stream, options);
-    }
-
-    public static void AddAllFromDirectory(
-        this IWritableArchive writableArchive,
-        string filePath,
-        string searchPattern = "*.*",
-        SearchOption searchOption = SearchOption.AllDirectories
-    )
-    {
-        using (writableArchive.PauseEntryRebuilding())
-        {
-            foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
+            var fileInfo = new FileInfo(filePath);
+            if (!fileInfo.Exists)
            {
-                var fileInfo = new FileInfo(path);
-                writableArchive.AddEntry(
-                    path.Substring(filePath.Length),
-                    fileInfo.OpenRead(),
-                    true,
-                    fileInfo.Length,
-                    fileInfo.LastWriteTime
-                );
+                throw new FileNotFoundException("Could not AddEntry: " + filePath);
+            }
+            await writableArchive.AddEntryAsync(entryPath, new FileInfo(filePath).OpenRead(), true, fileInfo.Length,
+                                     fileInfo.LastWriteTime, cancellationToken);
+        }
+
+        public static Task SaveToAsync(this IWritableArchive writableArchive, string filePath, WriterOptions options, CancellationToken cancellationToken = default)
+        {
+            return writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
+        }
+
+        public static async Task SaveToAsync(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options, CancellationToken cancellationToken = default)
+        {
+            await using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+            await writableArchive.SaveToAsync(stream, options, cancellationToken);
+        }
+
+        public static async ValueTask AddAllFromDirectoryAsync(
+            this IWritableArchive writableArchive,
+            string filePath, string searchPattern = "*.*", 
+            SearchOption searchOption = SearchOption.AllDirectories,
+            CancellationToken cancellationToken = default)
+        {
+            await using (writableArchive.PauseEntryRebuilding())
+            {
+                foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
+                {
+                    var fileInfo = new FileInfo(path);
+                    await writableArchive.AddEntryAsync(path.Substring(filePath.Length), fileInfo.OpenRead(), true, fileInfo.Length,
+                                            fileInfo.LastWriteTime,
+                                            cancellationToken);
+                }
            }
        }
-    }
-
-    public static IArchiveEntry AddEntry(
-        this IWritableArchive writableArchive,
-        string key,
-        FileInfo fileInfo
-    )
-    {
-        if (!fileInfo.Exists)
+        public static ValueTask<IArchiveEntry> AddEntryAsync(this IWritableArchive writableArchive, string key, FileInfo fileInfo,
+                                                  CancellationToken cancellationToken = default)
        {
-            throw new ArgumentException("FileInfo does not exist.");
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("FileInfo does not exist.");
+            }
+            return writableArchive.AddEntryAsync(key, fileInfo.OpenRead(), true, fileInfo.Length, fileInfo.LastWriteTime, cancellationToken);
        }
-        return writableArchive.AddEntry(
-            key,
-            fileInfo.OpenRead(),
-            true,
-            fileInfo.Length,
-            fileInfo.LastWriteTime
-        );
    }
-}
+}
--- a/src/SharpCompress/Archives/IWriteableArchiveFactory.cs
+++ b/src/SharpCompress/Archives/IWriteableArchiveFactory.cs
@@ -1,20 +0,0 @@
-namespace SharpCompress.Archives;
-
-/// <summary>
-/// Decorator for <see cref="Factories.Factory"/> used to declare an archive format as able to create writeable archives
-/// </summary>
-/// <remarks>
-/// Implemented by:<br/>
-/// <list type="table">
-/// <item><see cref="Factories.TarFactory"/></item>
-/// <item><see cref="Factories.ZipFactory"/></item>
-/// <item><see cref="Factories.GZipFactory"/></item>
-/// </list>
-public interface IWriteableArchiveFactory : Factories.IFactory
-{
-    /// <summary>
-    /// Creates a new, empty archive, ready to be written.
-    /// </summary>
-    /// <returns></returns>
-    IWritableArchive CreateWriteableArchive();
-}
--- a/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Rar;
@@ -6,33 +6,39 @@ using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives.Rar;
-
-/// <summary>
-/// A rar part based on a FileInfo object
-/// </summary>
-internal class FileInfoRarArchiveVolume : RarVolume
+namespace SharpCompress.Archives.Rar
 {
-    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index = 0)
-        : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options), index)
+    /// <summary>
+    /// A rar part based on a FileInfo object
+    /// </summary>
+    internal class FileInfoRarArchiveVolume : RarVolume
    {
-        FileInfo = fileInfo;
-        FileParts = GetVolumeFileParts().ToArray().ToReadOnly();
+        internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options)
+            : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options))
+        {
+            FileInfo = fileInfo;
+            FileParts = GetVolumeFileParts().ToArray().ToReadOnly();
+        }
+
+        private static ReaderOptions FixOptions(ReaderOptions options)
+        {
+            //make sure we're closing streams with fileinfo
+            options.LeaveStreamOpen = false;
+            return options;
+        }
+
+        internal ReadOnlyCollection<RarFilePart> FileParts { get; }
+
+        internal FileInfo FileInfo { get; }
+
+        internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader)
+        {
+            return new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
+        }
+
+        internal override IEnumerable<RarFilePart> ReadFileParts()
+        {
+            return FileParts;
+        }
    }
-
-    private static ReaderOptions FixOptions(ReaderOptions options)
-    {
-        //make sure we're closing streams with fileinfo
-        options.LeaveStreamOpen = false;
-        return options;
-    }
-
-    internal ReadOnlyCollection<RarFilePart> FileParts { get; }
-
-    internal FileInfo FileInfo { get; }
-
-    internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
-        new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
-
-    internal override IEnumerable<RarFilePart> ReadFileParts() => FileParts;
 }
--- a/src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
@@ -1,21 +1,25 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Archives.Rar;
-
-internal sealed class FileInfoRarFilePart : SeekableFilePart
+namespace SharpCompress.Archives.Rar
 {
-    internal FileInfoRarFilePart(
-        FileInfoRarArchiveVolume volume,
-        string? password,
-        MarkHeader mh,
-        FileHeader fh,
-        FileInfo fi
-    )
-        : base(mh, fh, volume.Index, volume.Stream, password) => FileInfo = fi;
+    internal sealed class FileInfoRarFilePart : SeekableFilePart
+    {
+        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string? password, MarkHeader mh, FileHeader fh, FileInfo fi)
+            : base(mh, fh, volume.Stream, password)
+        {
+            FileInfo = fi;
+        }

-    internal FileInfo FileInfo { get; }
+        internal FileInfo FileInfo { get; }

-    internal override string FilePartName =>
-        "Rar File: " + FileInfo.FullName + " File Entry: " + FileHeader.FileName;
+        internal override string FilePartName
+        {
+            get
+            {
+                return "Rar File: " + FileInfo.FullName
+                       + " File Entry: " + FileHeader.FileName;
+            }
+        }
+    }
 }
--- a/src/SharpCompress/Archives/Rar/RarArchive.Extensions.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.Extensions.cs
@@ -1,18 +1,23 @@
 using System.Linq;

-namespace SharpCompress.Archives.Rar;
-
-public static class RarArchiveExtensions
+namespace SharpCompress.Archives.Rar
 {
-    /// <summary>
-    /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
-    /// </summary>
-    public static bool IsFirstVolume(this RarArchive archive) =>
-        archive.Volumes.First().IsFirstVolume;
+    public static class RarArchiveExtensions
+    {
+        /// <summary>
+        /// RarArchive is the first volume of a multi-part archive.  If MultipartVolume is true and IsFirstVolume is false then the first volume file must be missing.
+        /// </summary>
+        public static bool IsFirstVolume(this RarArchive archive)
+        {
+            return archive.Volumes.First().IsFirstVolume;
+        }

-    /// <summary>
-    /// RarArchive is part of a multi-part archive.
-    /// </summary>
-    public static bool IsMultipartVolume(this RarArchive archive) =>
-        archive.Volumes.First().IsMultiVolume;
-}
+        /// <summary>
+        /// RarArchive is part of a multi-part archive.
+        /// </summary>
+        public static bool IsMultipartVolume(this RarArchive archive)
+        {
+            return archive.Volumes.First().IsMultiVolume;
+        }
+    }
+}
--- a/src/SharpCompress/Archives/Rar/RarArchive.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.cs
@@ -5,173 +5,136 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Rar;

-namespace SharpCompress.Archives.Rar;
-
-public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
+namespace SharpCompress.Archives.Rar
 {
-    internal Lazy<IRarUnpack> UnpackV2017 { get; } =
-        new Lazy<IRarUnpack>(() => new Compressors.Rar.UnpackV2017.Unpack());
-    internal Lazy<IRarUnpack> UnpackV1 { get; } =
-        new Lazy<IRarUnpack>(() => new Compressors.Rar.UnpackV1.Unpack());
-
-    /// <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) { }
-
-    protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
-        RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
-
-    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream srcStream)
+    public class 
+        RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    {
-        SrcStream.LoadAllParts(); //request all streams
-        var streams = SrcStream.Streams.ToArray();
-        var idx = 0;
-        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
+        internal Lazy<IRarUnpack> UnpackV2017 { get; } = new Lazy<IRarUnpack>(() => new SharpCompress.Compressors.Rar.UnpackV2017.Unpack());
+        internal Lazy<IRarUnpack> UnpackV1 { get; } = new Lazy<IRarUnpack>(() => new SharpCompress.Compressors.Rar.UnpackV1.Unpack());
+
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="options"></param>
+        internal RarArchive(FileInfo fileInfo, ReaderOptions options)
+            : base(ArchiveType.Rar, fileInfo, options)
        {
-            SrcStream.IsVolumes = true;
-            streams[1].Position = 0;
-            SrcStream.Position = 0;
-
-            return srcStream.Streams.Select(
-                a => new StreamRarArchiveVolume(a, ReaderOptions, idx++)
-            );
        }
-        else //split mode or single file
+
+        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
        {
-            return new StreamRarArchiveVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
+            return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
        }
-    }

-    protected override IReader CreateReaderForSolidExtraction()
-    {
-        var stream = Volumes.First().Stream;
-        stream.Position = 0;
-        return RarReader.Open(stream, ReaderOptions);
-    }
-
-    public override bool IsSolid => Volumes.First().IsSolidArchive;
-
-    public virtual int MinVersion => Volumes.First().MinVersion;
-    public virtual int MaxVersion => Volumes.First().MaxVersion;
-
-    #region Creation
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="options"></param>
-    public static RarArchive Open(string filePath, ReaderOptions? options = null)
-    {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
-        var fileInfo = new FileInfo(filePath);
-        return new RarArchive(
-            new SourceStream(
-                fileInfo,
-                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                options ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="options"></param>
-    public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
-    {
-        fileInfo.CheckNotNull(nameof(fileInfo));
-        return new RarArchive(
-            new SourceStream(
-                fileInfo,
-                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                options ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="options"></param>
-    public static RarArchive Open(Stream stream, ReaderOptions? options = null)
-    {
-        stream.CheckNotNull(nameof(stream));
-        return new RarArchive(new SourceStream(stream, i => null, options ?? new ReaderOptions()));
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static RarArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.CheckNotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new RarArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.CheckNotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new RarArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
-
-    public static bool IsRarFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
+        /// <summary>
+        /// Takes multiple seekable Streams for a multi-part archive
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="options"></param>
+        internal RarArchive(IEnumerable<Stream> streams, ReaderOptions options)
+            : base(ArchiveType.Rar, streams, options)
        {
-            return false;
        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsRarFile(stream);
-    }

-    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
-    {
-        try
+        protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes)
        {
-            MarkHeader.Read(stream, true, false);
-            return true;
+            return RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
        }
-        catch
-        {
-            return false;
-        }
-    }

-    #endregion
+        protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams)
+        {
+            return RarArchiveVolumeFactory.GetParts(streams, ReaderOptions);
+        }
+
+        protected override IReader CreateReaderForSolidExtraction()
+        {
+            var stream = Volumes.First().Stream;
+            stream.Position = 0;
+            return RarReader.Open(stream, ReaderOptions);
+        }
+
+        public override bool IsSolid => Volumes.First().IsSolidArchive;
+
+        #region Creation
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="options"></param>
+        public static RarArchive Open(string filePath, ReaderOptions? options = null)
+        {
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
+        }
+
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="options"></param>
+        public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+        {
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            return new RarArchive(fileInfo, options ?? new ReaderOptions());
+        }
+
+        /// <summary>
+        /// Takes a seekable Stream as a source
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="options"></param>
+        public static RarArchive Open(Stream stream, ReaderOptions? options = null)
+        {
+            stream.CheckNotNull(nameof(stream));
+            return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
+        }
+
+        /// <summary>
+        /// Takes multiple seekable Streams for a multi-part archive
+        /// </summary>
+        /// <param name="streams"></param>
+        /// <param name="options"></param>
+        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
+        {
+            streams.CheckNotNull(nameof(streams));
+            return new RarArchive(streams, options ?? new ReaderOptions());
+        }
+
+        public static bool IsRarFile(string filePath)
+        {
+            return IsRarFile(new FileInfo(filePath));
+        }
+
+        public static bool IsRarFile(FileInfo fileInfo)
+        {
+            if (!fileInfo.Exists)
+            {
+                return false;
+            }
+            using (Stream stream = fileInfo.OpenRead())
+            {
+                return IsRarFile(stream);
+            }
+        }
+
+        public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
+        {
+            try
+            {
+                MarkHeader.Read(stream, true, false);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        #endregion
+    }
 }
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -7,95 +8,81 @@ using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives.Rar;
-
-public class RarArchiveEntry : RarEntry, IArchiveEntry
+namespace SharpCompress.Archives.Rar
 {
-    private readonly ICollection<RarFilePart> parts;
-    private readonly RarArchive archive;
-    private readonly ReaderOptions readerOptions;
-
-    internal RarArchiveEntry(
-        RarArchive archive,
-        IEnumerable<RarFilePart> parts,
-        ReaderOptions readerOptions
-    )
+    public class RarArchiveEntry : RarEntry, IArchiveEntry
    {
-        this.parts = parts.ToList();
-        this.archive = archive;
-        this.readerOptions = readerOptions;
-        IsSolid = FileHeader.IsSolid;
-    }
+        private readonly ICollection<RarFilePart> parts;
+        private readonly RarArchive archive;
+        private readonly ReaderOptions readerOptions;

-    public override CompressionType CompressionType => CompressionType.Rar;
-
-    public IArchive Archive => archive;
-
-    internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();
-
-    internal override FileHeader FileHeader => parts.First().FileHeader;
-
-    public override long Crc
-    {
-        get
+        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts, ReaderOptions readerOptions)
        {
-            CheckIncomplete();
-            return parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc;
-        }
-    }
-
-    public override long Size
-    {
-        get
-        {
-            CheckIncomplete();
-            return parts.First().FileHeader.UncompressedSize;
-        }
-    }
-
-    public override long CompressedSize
-    {
-        get
-        {
-            CheckIncomplete();
-            return parts.Aggregate(0L, (total, fp) => total + fp.FileHeader.CompressedSize);
-        }
-    }
-
-    public Stream OpenEntryStream()
-    {
-        if (IsRarV3)
-        {
-            return new RarStream(
-                archive.UnpackV1.Value,
-                FileHeader,
-                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-            );
+            this.parts = parts.ToList();
+            this.archive = archive;
+            this.readerOptions = readerOptions;
        }

-        return new RarStream(
-            archive.UnpackV2017.Value,
-            FileHeader,
-            new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
-        );
-    }
+        public override CompressionType CompressionType => CompressionType.Rar;

-    public bool IsComplete
-    {
-        get
+        public IArchive Archive => archive;
+
+        internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();
+
+        internal override FileHeader FileHeader => parts.First().FileHeader;
+
+        public override long Crc
        {
-            var headers = parts.Select(x => x.FileHeader);
-            return !headers.First().IsSplitBefore && !headers.Last().IsSplitAfter;
+            get
+            {
+                CheckIncomplete();
+                return parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc;
+            }
+        }
+
+        public override long Size
+        {
+            get
+            {
+                CheckIncomplete();
+                return parts.First().FileHeader.UncompressedSize;
+            }
+        }
+
+        public override long CompressedSize
+        {
+            get
+            {
+                CheckIncomplete();
+                return parts.Aggregate(0L, (total, fp) => total + fp.FileHeader.CompressedSize);
+            }
+        }
+
+        public Stream OpenEntryStream()
+        {
+            if (IsRarV3)
+            {
+                return new RarStream(archive.UnpackV1.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
+            }
+
+            return new RarStream(archive.UnpackV2017.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
+        }
+
+        public bool IsComplete
+        {
+            get
+            {
+                var headers = parts.Select(x => x.FileHeader);
+                return !headers.First().IsSplitBefore && !headers.Last().IsSplitAfter;
+            }
+        }
+
+        private void CheckIncomplete()
+        {
+            if (!readerOptions.DisableCheckIncomplete && !IsComplete)
+            {
+                throw new IncompleteArchiveException("ArchiveEntry is incomplete and cannot perform this operation.");
+            }
        }
    }
-
-    private void CheckIncomplete()
-    {
-        if (!readerOptions.DisableCheckIncomplete && !IsComplete)
-        {
-            throw new IncompleteArchiveException(
-                "ArchiveEntry is incomplete and cannot perform this operation."
-            );
-        }
-    }
-}
+}
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs
@@ -1,52 +1,49 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using SharpCompress.Common.Rar;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives.Rar;
-
-internal static class RarArchiveEntryFactory
+namespace SharpCompress.Archives.Rar
 {
-    private static IEnumerable<RarFilePart> GetFileParts(IEnumerable<RarVolume> parts)
+    internal static class RarArchiveEntryFactory
    {
-        foreach (var rarPart in parts)
+        private static IEnumerable<RarFilePart> GetFileParts(IEnumerable<RarVolume> parts)
        {
-            foreach (var fp in rarPart.ReadFileParts())
+            foreach (RarVolume rarPart in parts)
            {
-                yield return fp;
+                foreach (RarFilePart fp in rarPart.ReadFileParts())
+                {
+                    yield return fp;
+                }
            }
        }
-    }

-    private static IEnumerable<IEnumerable<RarFilePart>> GetMatchedFileParts(
-        IEnumerable<RarVolume> parts
-    )
-    {
-        var groupedParts = new List<RarFilePart>();
-        foreach (var fp in GetFileParts(parts))
+        private static IEnumerable<IEnumerable<RarFilePart>> GetMatchedFileParts(IEnumerable<RarVolume> parts)
        {
-            groupedParts.Add(fp);
+            var groupedParts = new List<RarFilePart>();
+            foreach (RarFilePart fp in GetFileParts(parts))
+            {
+                groupedParts.Add(fp);

-            if (!fp.FileHeader.IsSplitAfter)
+                if (!fp.FileHeader.IsSplitAfter)
+                {
+                    yield return groupedParts;
+                    groupedParts = new List<RarFilePart>();
+                }
+            }
+            if (groupedParts.Count > 0)
            {
                yield return groupedParts;
-                groupedParts = new List<RarFilePart>();
            }
        }
-        if (groupedParts.Count > 0)
-        {
-            yield return groupedParts;
-        }
-    }

-    internal static IEnumerable<RarArchiveEntry> GetEntries(
-        RarArchive archive,
-        IEnumerable<RarVolume> rarParts,
-        ReaderOptions readerOptions
-    )
-    {
-        foreach (var groupedParts in GetMatchedFileParts(rarParts))
+        internal static IEnumerable<RarArchiveEntry> GetEntries(RarArchive archive,
+                                                                IEnumerable<RarVolume> rarParts,
+                                                                ReaderOptions readerOptions)
        {
-            yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
+            foreach (var groupedParts in GetMatchedFileParts(rarParts))
+            {
+                yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
+            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
@@ -1,52 +1,140 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using System.Text.RegularExpressions;
+using SharpCompress.Common.Rar;
+using SharpCompress.Readers;
+using System.Linq;
+using System.Text;
+using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Archives.Rar;
-
-internal static class RarArchiveVolumeFactory
+namespace SharpCompress.Archives.Rar
 {
-    internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
+    internal static class RarArchiveVolumeFactory
    {
-        FileInfo? item = null;
-
-        //new style rar - ..part1 | /part01 | part001 ....
-        Match m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
-        if (m.Success)
-            item = new FileInfo(
-                Path.Combine(
-                    part1.DirectoryName!,
-                    String.Concat(
-                        m.Groups[1].Value,
-                        (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'),
-                        m.Groups[3].Value
-                    )
-                )
-            );
-        else
+        internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, ReaderOptions options)
        {
-            //old style - ...rar, .r00, .r01 ...
-            m = Regex.Match(part1.Name, @"^(.*\.)([r-z{])(ar|[0-9]+)$", RegexOptions.IgnoreCase);
-            if (m.Success)
-                item = new FileInfo(
-                    Path.Combine(
-                        part1.DirectoryName!,
-                        String.Concat(
-                            m.Groups[1].Value,
-                            index == 0
-                                ? m.Groups[2].Value + m.Groups[3].Value
-                                : (char)(m.Groups[2].Value[0] + ((index - 1) / 100))
-                                    + (index - 1).ToString("D4").Substring(2)
-                        )
-                    )
-                );
-            else //split .001, .002 ....
-                return ArchiveVolumeFactory.GetFilePart(index, part1);
+            foreach (Stream s in streams)
+            {
+                if (!s.CanRead || !s.CanSeek)
+                {
+                    throw new ArgumentException("Stream is not readable and seekable");
+                }
+                StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, options);
+                yield return part;
+            }
        }

-        if (item != null && item.Exists)
-            return item;
+        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
+        {
+            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
+            yield return part;

-        return null; //no more items
+            ArchiveHeader ah = part.ArchiveHeader;
+            if (!ah.IsVolume)
+            {
+                yield break; //if file isn't volume then there is no reason to look
+            }
+            fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
+            //we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
+            while (fileInfo != null && fileInfo.Exists)
+            {
+                part = new FileInfoRarArchiveVolume(fileInfo, options);
+
+                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
+                yield return part;
+            }
+        }
+
+        private static FileInfo? GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart? currentFilePart)
+        {
+            if (currentFilePart is null)
+            {
+                return null;
+            }
+            bool oldNumbering = ah.OldNumberingFormat
+                                || currentFilePart.MarkHeader.OldNumberingFormat;
+            if (oldNumbering)
+            {
+                return FindNextFileWithOldNumbering(currentFilePart.FileInfo);
+            }
+            else
+            {
+                return FindNextFileWithNewNumbering(currentFilePart.FileInfo);
+            }
+        }
+
+        private static FileInfo FindNextFileWithOldNumbering(FileInfo currentFileInfo)
+        {
+            // .rar, .r00, .r01, ...
+            string extension = currentFileInfo.Extension;
+
+            var buffer = new StringBuilder(currentFileInfo.FullName.Length);
+            buffer.Append(currentFileInfo.FullName.Substring(0,
+                                                             currentFileInfo.FullName.Length - extension.Length));
+            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) == 0)
+            {
+                buffer.Append(".r00");
+            }
+            else
+            {
+                if (int.TryParse(extension.Substring(2, 2), out int num))
+                {
+                    num++;
+                    buffer.Append(".r");
+                    if (num < 10)
+                    {
+                        buffer.Append('0');
+                    }
+                    buffer.Append(num);
+                }
+                else
+                {
+                    ThrowInvalidFileName(currentFileInfo);
+                }
+            }
+            return new FileInfo(buffer.ToString());
+        }
+
+        private static FileInfo FindNextFileWithNewNumbering(FileInfo currentFileInfo)
+        {
+            // part1.rar, part2.rar, ...
+            string extension = currentFileInfo.Extension;
+            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) != 0)
+            {
+                throw new ArgumentException("Invalid extension, expected 'rar': " + currentFileInfo.FullName);
+            }
+            int startIndex = currentFileInfo.FullName.LastIndexOf(".part");
+            if (startIndex < 0)
+            {
+                ThrowInvalidFileName(currentFileInfo);
+            }
+            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
+            buffer.Append(currentFileInfo.FullName, 0, startIndex);
+            string numString = currentFileInfo.FullName.Substring(startIndex + 5,
+                                                                  currentFileInfo.FullName.IndexOf('.', startIndex + 5) -
+                                                                  startIndex - 5);
+            buffer.Append(".part");
+            if (int.TryParse(numString, out int num))
+            {
+                num++;
+                for (int i = 0; i < numString.Length - num.ToString().Length; i++)
+                {
+                    buffer.Append('0');
+                }
+                buffer.Append(num);
+            }
+            else
+            {
+                ThrowInvalidFileName(currentFileInfo);
+            }
+            buffer.Append(".rar");
+            return new FileInfo(buffer.ToString());
+        }
+
+        private static void ThrowInvalidFileName(FileInfo fileInfo)
+        {
+            throw new ArgumentException("Filename invalid or next archive could not be found:"
+                                        + fileInfo.FullName);
+        }
    }
-}
+}
--- a/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
@@ -1,36 +1,31 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Archives.Rar;
-
-internal class SeekableFilePart : RarFilePart
+namespace SharpCompress.Archives.Rar
 {
-    private readonly Stream stream;
-    private readonly string? password;
-
-    internal SeekableFilePart(
-        MarkHeader mh,
-        FileHeader fh,
-        int index,
-        Stream stream,
-        string? password
-    )
-        : base(mh, fh, index)
+    internal class SeekableFilePart : RarFilePart
    {
-        this.stream = stream;
-        this.password = password;
-    }
+        private readonly Stream stream;
+        private readonly string? password;

-    internal override Stream GetCompressedStream()
-    {
-        stream.Position = FileHeader.DataStartPosition;
-        if (FileHeader.R4Salt != null)
+        internal SeekableFilePart(MarkHeader mh, FileHeader fh, Stream stream, string? password)
+            : base(mh, fh)
        {
-            return new RarCryptoWrapper(stream, password!, FileHeader.R4Salt);
+            this.stream = stream;
+            this.password = password;
        }
-        return stream;
-    }

-    internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
-}
+        internal override Stream GetCompressedStream()
+        {
+            stream.Position = FileHeader.DataStartPosition;
+            if (FileHeader.R4Salt != null)
+            {
+                return new RarCryptoWrapper(stream, password!, FileHeader.R4Salt);
+            }
+            return stream;
+        }
+
+        internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
+    }
+}
--- a/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
@@ -1,19 +1,27 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;

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

-    internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
+        internal override IEnumerable<RarFilePart> ReadFileParts()
+        {
+            return GetVolumeFileParts();
+        }

-    internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
-        new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
-}
+        internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader)
+        {
+            return new SeekableFilePart(markHeader, fileHeader, Stream, ReaderOptions.Password);
+        }
+    }
+}
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
@@ -1,4 +1,4 @@
-#nullable disable
+#nullable disable

 using System;
 using System.Collections.Generic;
@@ -10,256 +10,213 @@ using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 using SharpCompress.Readers;

-namespace SharpCompress.Archives.SevenZip;
-
-public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
+namespace SharpCompress.Archives.SevenZip
 {
-    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 class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
    {
-        filePath.CheckNotNullOrEmpty("filePath");
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
-    {
-        fileInfo.CheckNotNull("fileInfo");
-        return new SevenZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions readerOptions = null
-    )
-    {
-        fileInfos.CheckNotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new SevenZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(
-        IEnumerable<Stream> streams,
-        ReaderOptions readerOptions = null
-    )
-    {
-        streams.CheckNotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new SevenZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
-    {
-        stream.CheckNotNull("stream");
-        return new SevenZipArchive(
-            new SourceStream(stream, i => 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) { }
-
-    protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream srcStream)
-    {
-        SrcStream.LoadAllParts(); //request all streams
-        var idx = 0;
-        return new SevenZipVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
-    }
-
-    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
-
-    public static bool IsSevenZipFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
+        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)
        {
-            return false;
+            filePath.CheckNotNullOrEmpty("filePath");
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsSevenZipFile(stream);
-    }

-    internal SevenZipArchive()
-        : base(ArchiveType.SevenZip) { }
-
-    protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(
-        IEnumerable<SevenZipVolume> volumes
-    )
-    {
-        var stream = volumes.Single().Stream;
-        LoadFactory(stream);
-        var entries = new SevenZipArchiveEntry[database._files.Count];
-        for (var i = 0; i < database._files.Count; i++)
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
        {
-            var file = database._files[i];
-            entries[i] = new SevenZipArchiveEntry(
-                this,
-                new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding)
-            );
+            fileInfo.CheckNotNull("fileInfo");
+            return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
        }
-        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+        /// <summary>
+        /// Takes a seekable Stream as a source
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
-            var isSolid = false;
-            foreach (var entry in group)
+            stream.CheckNotNull("stream");
+            return new SevenZipArchive(stream, readerOptions ?? new ReaderOptions());
+        }
+
+        internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
+            : base(ArchiveType.SevenZip, fileInfo, readerOptions)
+        {
+        }
+
+        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
+        {
+            return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
+        }
+
+        public static bool IsSevenZipFile(string filePath)
+        {
+            return IsSevenZipFile(new FileInfo(filePath));
+        }
+
+        public static bool IsSevenZipFile(FileInfo fileInfo)
+        {
+            if (!fileInfo.Exists)
            {
-                entry.IsSolid = isSolid;
-                isSolid = true; //mark others in this group as solid - same as rar behaviour.
+                return false;
+            }
+            using (Stream stream = fileInfo.OpenRead())
+            {
+                return IsSevenZipFile(stream);
            }
        }

-        return entries;
-    }
-
-    private void LoadFactory(Stream stream)
-    {
-        if (database is null)
+        internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
        {
-            stream.Position = 0;
-            var reader = new ArchiveReader();
-            reader.Open(stream);
-            database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
        }
-    }

-    public static bool IsSevenZipFile(Stream stream)
-    {
-        try
+        internal SevenZipArchive()
+            : base(ArchiveType.SevenZip)
        {
-            return SignatureMatch(stream);
        }
-        catch
+
+        protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams)
        {
-            return false;
-        }
-    }
-
-    private static ReadOnlySpan<byte> SIGNATURE =>
-        new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
-
-    private static bool SignatureMatch(Stream stream)
-    {
-        var reader = new BinaryReader(stream);
-        ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
-        return signatureBytes.SequenceEqual(SIGNATURE);
-    }
-
-    protected override IReader CreateReaderForSolidExtraction() =>
-        new SevenZipReader(ReaderOptions, this);
-
-    public override bool IsSolid =>
-        Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1;
-
-    public override long TotalSize
-    {
-        get
-        {
-            var i = Entries.Count;
-            return database._packSizes.Aggregate(0L, (total, packSize) => total + packSize);
-        }
-    }
-
-    private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
-    {
-        private readonly SevenZipArchive archive;
-        private CFolder currentFolder;
-        private Stream currentStream;
-        private CFileItem currentItem;
-
-        internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-            : base(readerOptions, ArchiveType.SevenZip) => this.archive = archive;
-
-        public override SevenZipVolume Volume => archive.Volumes.Single();
-
-        protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
-        {
-            var entries = archive.Entries.ToList();
-            stream.Position = 0;
-            foreach (var dir in entries.Where(x => x.IsDirectory))
+            foreach (Stream s in streams)
            {
-                yield return dir;
-            }
-            foreach (
-                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
-            )
-            {
-                currentFolder = group.Key;
-                if (group.Key is null)
+                if (!s.CanRead || !s.CanSeek)
                {
-                    currentStream = Stream.Null;
-                }
-                else
-                {
-                    currentStream = archive.database.GetFolderStream(
-                        stream,
-                        currentFolder,
-                        new PasswordProvider(Options.Password)
-                    );
-                }
-                foreach (var entry in group)
-                {
-                    currentItem = entry.FilePart.Header;
-                    yield return entry;
+                    throw new ArgumentException("Stream is not readable and seekable");
                }
+                SevenZipVolume volume = new SevenZipVolume(s, ReaderOptions);
+                yield return volume;
            }
        }

-        protected override EntryStream GetEntryStream() =>
-            CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
-    }
+        protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(IEnumerable<SevenZipVolume> volumes)
+        {
+            var stream = volumes.Single().Stream;
+            LoadFactory(stream);
+            for (int i = 0; i < database._files.Count; i++)
+            {
+                var file = database._files[i];
+                yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding));
+            }
+        }

-    private class PasswordProvider : IPasswordProvider
-    {
-        private readonly string _password;
+        private void LoadFactory(Stream stream)
+        {
+            if (database is null)
+            {
+                stream.Position = 0;
+                var reader = new ArchiveReader();
+                reader.Open(stream);
+                database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
+            }
+        }

-        public PasswordProvider(string password) => _password = password;
+        public static bool IsSevenZipFile(Stream stream)
+        {
+            try
+            {
+                return SignatureMatch(stream);
+            }
+            catch
+            {
+                return false;
+            }
+        }

-        public string CryptoGetTextPassword() => _password;
+        private static ReadOnlySpan<byte> SIGNATURE => new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
+
+        private static bool SignatureMatch(Stream stream)
+        {
+            BinaryReader reader = new BinaryReader(stream);
+            ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
+            return signatureBytes.SequenceEqual(SIGNATURE);
+        }
+
+        protected override IReader CreateReaderForSolidExtraction()
+        {
+            return new SevenZipReader(ReaderOptions, this);
+        }
+
+        public override bool IsSolid { get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; } }
+
+        public override long TotalSize
+        {
+            get
+            {
+                int i = Entries.Count;
+                return database._packSizes.Aggregate(0L, (total, packSize) => total + packSize);
+            }
+        }
+
+        private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+        {
+            private readonly SevenZipArchive archive;
+            private CFolder currentFolder;
+            private Stream currentStream;
+            private CFileItem currentItem;
+
+            internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
+                : base(readerOptions, ArchiveType.SevenZip)
+            {
+                this.archive = archive;
+            }
+
+            public override SevenZipVolume Volume => archive.Volumes.Single();
+
+            protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
+            {
+                List<SevenZipArchiveEntry> entries = archive.Entries.ToList();
+                stream.Position = 0;
+                foreach (var dir in entries.Where(x => x.IsDirectory))
+                {
+                    yield return dir;
+                }
+                foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+                {
+                    currentFolder = group.Key;
+                    if (group.Key is null)
+                    {
+                        currentStream = Stream.Null;
+                    }
+                    else
+                    {
+                        currentStream = archive.database.GetFolderStream(stream, currentFolder, new PasswordProvider(Options.Password));
+                    }
+                    foreach (var entry in group)
+                    {
+                        currentItem = entry.FilePart.Header;
+                        yield return entry;
+                    }
+                }
+            }
+
+            protected override EntryStream GetEntryStream()
+            {
+                return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
+            }
+        }
+
+        private class PasswordProvider : IPasswordProvider
+        {
+            private readonly string _password;
+
+            public PasswordProvider(string password)
+            {
+                _password = password;
+            }
+
+            public string CryptoGetTextPassword()
+            {
+                return _password;
+            }
+        }
    }
 }
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs
@@ -1,21 +1,28 @@
 using System.IO;
 using SharpCompress.Common.SevenZip;

-namespace SharpCompress.Archives.SevenZip;
-
-public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
+namespace SharpCompress.Archives.SevenZip
 {
-    internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
-        : base(part) => Archive = archive;
+    public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
+    {
+        internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
+            : base(part)
+        {
+            Archive = archive;
+        }

-    public Stream OpenEntryStream() => FilePart.GetCompressedStream();
+        public Stream OpenEntryStream()
+        {
+            return FilePart.GetCompressedStream();
+        }

-    public IArchive Archive { get; }
+        public IArchive Archive { get; }

-    public bool IsComplete => true;
+        public bool IsComplete => true;

-    /// <summary>
-    /// This is a 7Zip Anti item
-    /// </summary>
-    public bool IsAnti => FilePart.Header.IsAnti;
-}
+        /// <summary>
+        /// This is a 7Zip Anti item
+        /// </summary>
+        public bool IsAnti => FilePart.Header.IsAnti;
+    }
+}
--- a/src/SharpCompress/Archives/Tar/TarArchive.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchive.cs
@@ -1,7 +1,10 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
@@ -11,228 +14,191 @@ using SharpCompress.Readers.Tar;
 using SharpCompress.Writers;
 using SharpCompress.Writers.Tar;

-namespace SharpCompress.Archives.Tar;
-
-public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+namespace SharpCompress.Archives.Tar
 {
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.CheckNotNull(nameof(fileInfo));
-        return new TarArchive(
-            new SourceStream(
-                fileInfo,
-                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.CheckNotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new TarArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.CheckNotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new TarArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.CheckNotNull(nameof(stream));
-        return new TarArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
-
-    public static bool IsTarFile(FileInfo fileInfo)
-    {
-        if (!fileInfo.Exists)
+        /// <summary>
+        /// Constructor expects a filepath to an existing file.
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
        {
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+        }
+
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null,
+                                      CancellationToken cancellationToken = default)
+        {
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Takes a seekable Stream as a source
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null,
+                    CancellationToken cancellationToken = default)
+        {
+            stream.CheckNotNull(nameof(stream));
+            return new TarArchive(stream, readerOptions ?? new ReaderOptions(), cancellationToken);
+        }
+
+        public static ValueTask<bool> IsTarFileAsync(string filePath, CancellationToken cancellationToken = default)
+        {
+            return IsTarFileAsync(new FileInfo(filePath), cancellationToken);
+        }
+
+        public static async ValueTask<bool> IsTarFileAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+        {
+            if (!fileInfo.Exists)
+            {
+                return false;
+            }
+
+            await using Stream stream = fileInfo.OpenRead();
+            return await IsTarFileAsync(stream, cancellationToken);
+        }
+
+        public static async ValueTask<bool> IsTarFileAsync(Stream stream, CancellationToken cancellationToken = default)
+        {
+            try
+            {
+                TarHeader tarHeader = new(new ArchiveEncoding());
+                bool readSucceeded = await tarHeader.Read(stream, cancellationToken);
+                bool isEmptyArchive = tarHeader.Name.Length == 0 && tarHeader.Size == 0 && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+                return readSucceeded || isEmptyArchive;
+            }
+            catch
+            {
+            }
            return false;
        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsTarFile(stream);
-    }

-    public static bool IsTarFile(Stream stream)
-    {
-        try
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        internal TarArchive(FileInfo fileInfo, ReaderOptions readerOptions,
+                            CancellationToken cancellationToken)
+            : base(ArchiveType.Tar, fileInfo, readerOptions, cancellationToken)
        {
-            var tarHeader = new TarHeader(new ArchiveEncoding());
-            var readSucceeded = tarHeader.Read(new BinaryReader(stream));
-            var isEmptyArchive =
-                tarHeader.Name.Length == 0
-                && tarHeader.Size == 0
-                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
-            return readSucceeded || isEmptyArchive;
        }
-        catch { }
-        return false;
-    }

-    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
-    {
-        SrcStream.LoadAllParts(); //request all streams
-        var idx = 0;
-        return new TarVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
-    }
-
-    /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
-    /// </summary>
-    /// <param name="srcStream"></param>
-    /// <param name="options"></param>
-    internal TarArchive(SourceStream srcStream)
-        : base(ArchiveType.Tar, srcStream) { }
-
-    internal TarArchive()
-        : base(ArchiveType.Tar) { }
-
-    protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
-    {
-        var stream = volumes.Single().Stream;
-        TarHeader? previousHeader = null;
-        foreach (
-            var header in TarHeaderFactory.ReadHeader(
-                StreamingMode.Seekable,
-                stream,
-                ReaderOptions.ArchiveEncoding
-            )
-        )
+        protected override IAsyncEnumerable<TarVolume> LoadVolumes(FileInfo file, CancellationToken cancellationToken)
        {
-            if (header != null)
+            return new TarVolume(file.OpenRead(), ReaderOptions).AsAsyncEnumerable();
+        }
+
+        /// <summary>
+        /// Takes multiple seekable Streams for a multi-part archive
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        internal TarArchive(Stream stream, ReaderOptions readerOptions,
+                            CancellationToken cancellationToken)
+            : base(ArchiveType.Tar, stream, readerOptions, cancellationToken)
+        {
+        }
+
+        internal TarArchive()
+            : base(ArchiveType.Tar)
+        {
+        }
+
+        protected override async IAsyncEnumerable<TarVolume> LoadVolumes(IAsyncEnumerable<Stream> streams, 
+                                                                         [EnumeratorCancellation]CancellationToken cancellationToken)
+        {
+            yield return new TarVolume(await streams.FirstAsync(cancellationToken: cancellationToken), ReaderOptions);
+        }
+
+        protected override async IAsyncEnumerable<TarArchiveEntry> LoadEntries(IAsyncEnumerable<TarVolume> volumes, 
+                                                                               [EnumeratorCancellation]CancellationToken cancellationToken)
+        {
+            Stream stream = (await volumes.SingleAsync(cancellationToken: cancellationToken)).Stream;
+            TarHeader? previousHeader = null;
+            await foreach (TarHeader? header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding, cancellationToken))
            {
-                if (header.EntryType == EntryType.LongName)
+                if (header != null)
                {
-                    previousHeader = header;
-                }
-                else
-                {
-                    if (previousHeader != null)
+                    if (header.EntryType == EntryType.LongName)
                    {
-                        var entry = new TarArchiveEntry(
-                            this,
-                            new TarFilePart(previousHeader, stream),
-                            CompressionType.None
-                        );
-
-                        var oldStreamPos = stream.Position;
-
-                        using (var entryStream = entry.OpenEntryStream())
-                        {
-                            using var memoryStream = new MemoryStream();
-                            entryStream.TransferTo(memoryStream);
-                            memoryStream.Position = 0;
-                            var bytes = memoryStream.ToArray();
-
-                            header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
-                        }
-
-                        stream.Position = oldStreamPos;
-
-                        previousHeader = null;
+                        previousHeader = header;
+                    }
+                    else
+                    {
+                        if (previousHeader != null)
+                        {
+                            var entry = new TarArchiveEntry(this, new TarFilePart(previousHeader, stream),
+                                                            CompressionType.None);
+
+                            var oldStreamPos = stream.Position;
+
+                            await using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+                            {
+                                await using (var memoryStream = new MemoryStream())
+                                {
+                                    await entryStream.TransferToAsync(memoryStream, cancellationToken);
+                                    memoryStream.Position = 0;
+                                    var bytes = memoryStream.ToArray();
+
+                                    header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
+                                }
+                            }
+
+                            stream.Position = oldStreamPos;
+
+                            previousHeader = null;
+                        }
+                        yield return new TarArchiveEntry(this, new TarFilePart(header, stream), CompressionType.None);
                    }
-                    yield return new TarArchiveEntry(
-                        this,
-                        new TarFilePart(header, stream),
-                        CompressionType.None
-                    );
                }
            }
        }
-    }

-    public static TarArchive Create() => new TarArchive();
-
-    protected override TarArchiveEntry CreateEntryInternal(
-        string filePath,
-        Stream source,
-        long size,
-        DateTime? modified,
-        bool closeStream
-    ) =>
-        new TarWritableArchiveEntry(
-            this,
-            source,
-            CompressionType.Unknown,
-            filePath,
-            size,
-            modified,
-            closeStream
-        );
-
-    protected override void SaveTo(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<TarArchiveEntry> oldEntries,
-        IEnumerable<TarArchiveEntry> newEntries
-    )
-    {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
+        public static TarArchive Create()
        {
-            using var entryStream = entry.OpenEntryStream();
-            writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
+            return new();
+        }
+
+        protected override ValueTask<TarArchiveEntry> CreateEntryInternal(string filePath, Stream source,
+                                                               long size, DateTime? modified, bool closeStream,
+                                                               CancellationToken cancellationToken)
+        {
+            return new (new TarWritableArchiveEntry(this, source, CompressionType.Unknown, filePath, size, modified,
+                                               closeStream));
+        }
+
+        protected override async ValueTask SaveToAsync(Stream stream, WriterOptions options,
+                                                       IAsyncEnumerable<TarArchiveEntry> oldEntries,
+                                                       IAsyncEnumerable<TarArchiveEntry> newEntries,
+                                                       CancellationToken cancellationToken = default)
+        {
+            await using var writer = await TarWriter.CreateAsync(stream, new TarWriterOptions(options), cancellationToken);
+            await foreach (var entry in oldEntries.Concat(newEntries)
+                                                  .Where(x => !x.IsDirectory)
+                                                  .WithCancellation(cancellationToken))
+            {
+                await using var entryStream = await entry.OpenEntryStreamAsync(cancellationToken);
+                await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, entry.Size, cancellationToken);
+            }
+        }
+
+        protected override async ValueTask<IReader> CreateReaderForSolidExtraction()
+        {
+            var stream = (await Volumes.SingleAsync()).Stream;
+            stream.Position = 0;
+            return await TarReader.OpenAsync(stream);
        }
    }
-
-    protected override IReader CreateReaderForSolidExtraction()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return TarReader.Open(stream);
-    }
 }
--- a/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
@@ -1,22 +1,31 @@
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;

-namespace SharpCompress.Archives.Tar;
-
-public class TarArchiveEntry : TarEntry, IArchiveEntry
+namespace SharpCompress.Archives.Tar
 {
-    internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
-        : base(part, compressionType) => Archive = archive;
+    public class TarArchiveEntry : TarEntry, IArchiveEntry
+    {
+        internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
+            : base(part, compressionType)
+        {
+            Archive = archive;
+        }

-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
+        public virtual async ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        {
+            return await Parts.Single().GetCompressedStreamAsync(cancellationToken);
+        }

-    #region IArchiveEntry Members
+        #region IArchiveEntry Members

-    public IArchive Archive { get; }
+        public IArchive Archive { get; }

-    public bool IsComplete => true;
+        public bool IsComplete => true;

-    #endregion
-}
+        #endregion
+    }
+}
--- a/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
@@ -1,73 +1,69 @@
-#nullable disable
+#nullable disable

 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

-namespace SharpCompress.Archives.Tar;
-
-internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
+namespace SharpCompress.Archives.Tar
 {
-    private readonly bool closeStream;
-    private readonly Stream stream;
-
-    internal TarWritableArchiveEntry(
-        TarArchive archive,
-        Stream stream,
-        CompressionType compressionType,
-        string path,
-        long size,
-        DateTime? lastModified,
-        bool closeStream
-    )
-        : base(archive, null, compressionType)
+    internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
    {
-        this.stream = stream;
-        Key = path;
-        Size = size;
-        LastModifiedTime = lastModified;
-        this.closeStream = closeStream;
-    }
+        private readonly bool closeStream;
+        private readonly Stream stream;

-    public override long Crc => 0;
-
-    public override string Key { get; }
-
-    public override long CompressedSize => 0;
-
-    public override long Size { get; }
-
-    public override DateTime? LastModifiedTime { get; }
-
-    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 => throw new NotImplementedException();
-    Stream IWritableArchiveEntry.Stream => stream;
-
-    public override Stream OpenEntryStream()
-    {
-        //ensure new stream is at the start, this could be reset
-        stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
-    }
-
-    internal override void Close()
-    {
-        if (closeStream)
+        internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType,
+                                         string path, long size, DateTime? lastModified, bool closeStream)
+            : base(archive, null, compressionType)
        {
-            stream.Dispose();
+            this.stream = stream;
+            Key = path;
+            Size = size;
+            LastModifiedTime = lastModified;
+            this.closeStream = closeStream;
+        }
+
+        public override long Crc => 0;
+
+        public override string Key { get; }
+
+        public override long CompressedSize => 0;
+
+        public override long Size { get; }
+
+        public override DateTime? LastModifiedTime { get; }
+
+        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 => throw new NotImplementedException();
+        Stream IWritableArchiveEntry.Stream => stream;
+
+        public override ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        {
+            //ensure new stream is at the start, this could be reset
+            stream.Seek(0, SeekOrigin.Begin);
+            return new(new NonDisposingStream(stream));
+        }
+
+        internal override async ValueTask CloseAsync()
+        {
+            if (closeStream)
+            {
+                await stream.DisposeAsync();
+            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/Zip/ZipArchive.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchive.cs
@@ -1,7 +1,10 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
@@ -12,294 +15,213 @@ using SharpCompress.Readers.Zip;
 using SharpCompress.Writers;
 using SharpCompress.Writers.Zip;

-namespace SharpCompress.Archives.Zip;
-
-public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+namespace SharpCompress.Archives.Zip
 {
+    public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+    {
 #nullable disable
-    private readonly SeekableZipHeaderFactory headerFactory;
-
+        private readonly SeekableZipHeaderFactory headerFactory;
 #nullable enable

-    /// <summary>
-    /// Gets or sets the compression level applied to files added to the archive,
-    /// if the compression method is set to deflate
-    /// </summary>
-    public CompressionLevel DeflateCompressionLevel { get; set; }
+        /// <summary>
+        /// Gets or sets the compression level applied to files added to the archive,
+        /// if the compression method is set to deflate
+        /// </summary>
+        public CompressionLevel DeflateCompressionLevel { get; set; }

-    /// <summary>
-    /// Constructor with a SourceStream able to handle FileInfo and Streams.
-    /// </summary>
-    /// <param name="srcStream"></param>
-    /// <param name="options"></param>
-    internal ZipArchive(SourceStream srcStream)
-        : base(ArchiveType.Zip, srcStream) =>
-        headerFactory = new SeekableZipHeaderFactory(
-            srcStream.ReaderOptions.Password,
-            srcStream.ReaderOptions.ArchiveEncoding
-        );
-
-    /// <summary>
-    /// Constructor expects a filepath to an existing file.
-    /// </summary>
-    /// <param name="filePath"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
-    {
-        filePath.CheckNotNullOrEmpty(nameof(filePath));
-        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-    }
-
-    /// <summary>
-    /// Constructor with a FileInfo object to an existing file.
-    /// </summary>
-    /// <param name="fileInfo"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-    {
-        fileInfo.CheckNotNull(nameof(fileInfo));
-        return new ZipArchive(
-            new SourceStream(
-                fileInfo,
-                i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all file parts passed in
-    /// </summary>
-    /// <param name="fileInfos"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? readerOptions = null
-    )
-    {
-        fileInfos.CheckNotNull(nameof(fileInfos));
-        var files = fileInfos.ToArray();
-        return new ZipArchive(
-            new SourceStream(
-                files[0],
-                i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Constructor with all stream parts passed in
-    /// </summary>
-    /// <param name="streams"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-    {
-        streams.CheckNotNull(nameof(streams));
-        var strms = streams.ToArray();
-        return new ZipArchive(
-            new SourceStream(
-                strms[0],
-                i => i < strms.Length ? strms[i] : null,
-                readerOptions ?? new ReaderOptions()
-            )
-        );
-    }
-
-    /// <summary>
-    /// Takes a seekable Stream as a source
-    /// </summary>
-    /// <param name="stream"></param>
-    /// <param name="readerOptions"></param>
-    public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-    {
-        stream.CheckNotNull(nameof(stream));
-        return new ZipArchive(
-            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
-        );
-    }
-
-    public static bool IsZipFile(string filePath, string? password = null) =>
-        IsZipFile(new FileInfo(filePath), password);
-
-    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
-    {
-        if (!fileInfo.Exists)
+        /// <summary>
+        /// Constructor expects a filepath to an existing file.
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
        {
-            return false;
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }
-        using Stream stream = fileInfo.OpenRead();
-        return IsZipFile(stream, password);
-    }

-    public static bool IsZipFile(Stream stream, string? password = null)
-    {
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null,
+                                      CancellationToken cancellationToken = default)
        {
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions(), cancellationToken);
+        }
+
+        /// <summary>
+        /// Takes a seekable Stream as a source
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null,
+                                      CancellationToken cancellationToken = default)
+        {
+            stream.CheckNotNull(nameof(stream));
+            return new ZipArchive(stream, readerOptions ?? new ReaderOptions(), cancellationToken);
+        }
+
+        public static ValueTask<bool> IsZipFile(string filePath, string? password = null)
+        {
+            return IsZipFileAsync(new FileInfo(filePath), password);
+        }
+
+        public static async ValueTask<bool> IsZipFileAsync(FileInfo fileInfo, string? password = null)
+        {
+            if (!fileInfo.Exists)
            {
                return false;
            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }

-    public static bool IsZipMulti(Stream stream, string? password = null)
-    {
-        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
-        try
+            await using Stream stream = fileInfo.OpenRead();
+            return await IsZipFileAsync(stream, password);
+        }
+
+        public static async ValueTask<bool> IsZipFileAsync(Stream stream, string? password = null, CancellationToken cancellationToken = default)
        {
-            var header = headerFactory
-                .ReadStreamHeader(stream)
-                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-            if (header is null)
+            StreamingZipHeaderFactory headerFactory = new(password, new ArchiveEncoding());
+            try
            {
-                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                RewindableStream rewindableStream;
+                if (stream is RewindableStream rs)
                {
-                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
-                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                    rewindableStream = rs;
                }
                else
+                {
+                    rewindableStream = new RewindableStream(stream);
+                }
+                ZipHeader? header = await headerFactory.ReadStreamHeader(rewindableStream, cancellationToken)
+                                                       .FirstOrDefaultAsync(x => x.ZipHeaderType != ZipHeaderType.Split, cancellationToken: cancellationToken);
+                if (header is null)
                {
                    return false;
                }
+                return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
            }
-            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-        }
-        catch (CryptographicException)
-        {
-            return true;
-        }
-        catch
-        {
-            return false;
-        }
-    }
-
-    protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream srcStream)
-    {
-        SrcStream.LoadAllParts(); //request all streams
-        SrcStream.Position = 0;
-
-        var streams = SrcStream.Streams.ToList();
-        var idx = 0;
-        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);
-            streams[1].Position -= 4;
-            if (isZip)
+            catch (CryptographicException)
            {
-                SrcStream.IsVolumes = true;
-
-                var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
-                streams.RemoveAt(0);
-                streams.Add(tmp);
-
-                //streams[0].Position = 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
-                return streams.Select(a => new ZipVolume(a, ReaderOptions, idx++));
+                return true;
+            }
+            catch
+            {
+                return false;
            }
        }

-        //split mode or single file
-        return new ZipVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
-    }
-
-    internal ZipArchive()
-        : base(ArchiveType.Zip) { }
-
-    protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
-    {
-        var vols = volumes.ToArray();
-        foreach (var h in headerFactory.ReadSeekableHeader(vols.Last().Stream))
+        /// <summary>
+        /// Constructor with a FileInfo object to an existing file.
+        /// </summary>
+        /// <param name="fileInfo"></param>
+        /// <param name="readerOptions"></param>
+        internal ZipArchive(FileInfo fileInfo, ReaderOptions readerOptions,
+                            CancellationToken cancellationToken)
+            : base(ArchiveType.Zip, fileInfo, readerOptions, cancellationToken)
        {
-            if (h != null)
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+        }
+
+        protected override IAsyncEnumerable<ZipVolume> LoadVolumes(FileInfo file,
+                                                                   CancellationToken cancellationToken)
+        {
+            return new ZipVolume(file.OpenRead(), ReaderOptions).AsAsyncEnumerable();
+        }
+
+        internal ZipArchive()
+            : base(ArchiveType.Zip)
+        {
+        }
+
+        /// <summary>
+        /// Takes multiple seekable Streams for a multi-part archive
+        /// </summary>
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        internal ZipArchive(Stream stream, ReaderOptions readerOptions,
+                            CancellationToken cancellationToken)
+            : base(ArchiveType.Zip, stream, readerOptions, cancellationToken)
+        {
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+        }
+
+        protected override async IAsyncEnumerable<ZipVolume> LoadVolumes(IAsyncEnumerable<Stream> streams,
+                                                                         [EnumeratorCancellation]CancellationToken cancellationToken)
+        {
+            yield return new ZipVolume(await streams.FirstAsync(cancellationToken: cancellationToken), ReaderOptions);
+        }
+
+        protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntries(IAsyncEnumerable<ZipVolume> volumes,
+                                                                               [EnumeratorCancellation]CancellationToken cancellationToken)
+        {
+            await Task.CompletedTask;
+            var volume = await volumes.SingleAsync(cancellationToken: cancellationToken);
+            Stream stream = volume.Stream;
+            await foreach (ZipHeader h in headerFactory.ReadSeekableHeader(stream, cancellationToken))
            {
-                switch (h.ZipHeaderType)
+                if (h != null)
                {
-                    case ZipHeaderType.DirectoryEntry:
-
-                        {
-                            var deh = (DirectoryEntryHeader)h;
-                            Stream s;
-                            if (
-                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
-                                > vols[deh.DiskNumberStart].Stream.Length
-                            )
-                            {
-                                var v = vols.Skip(deh.DiskNumberStart).ToArray();
-                                s = new SourceStream(
-                                    v[0].Stream,
-                                    i => i < v.Length ? v[i].Stream : null,
-                                    new ReaderOptions() { LeaveStreamOpen = true }
-                                );
-                            }
-                            else
-                            {
-                                s = vols[deh.DiskNumberStart].Stream;
-                            }
-
-                            yield return new ZipArchiveEntry(
-                                this,
-                                new SeekableZipFilePart(headerFactory, deh, s)
-                            );
-                        }
-                        break;
-                    case ZipHeaderType.DirectoryEnd:
+                    switch (h.ZipHeaderType)
                    {
-                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                        volumes.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                        yield break;
+                        case ZipHeaderType.DirectoryEntry:
+                        {
+                            yield return new ZipArchiveEntry(this,
+                                                             new SeekableZipFilePart(headerFactory,
+                                                                                     (DirectoryEntryHeader)h,
+                                                                                     stream));
+                        }
+                            break;
+                        case ZipHeaderType.DirectoryEnd:
+                        {
+                            byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
+                            volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                            yield break;
+                        }
                    }
                }
            }
        }
-    }

-    public void SaveTo(Stream stream) => SaveTo(stream, new WriterOptions(CompressionType.Deflate));
-
-    protected override void SaveTo(
-        Stream stream,
-        WriterOptions options,
-        IEnumerable<ZipArchiveEntry> oldEntries,
-        IEnumerable<ZipArchiveEntry> newEntries
-    )
-    {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
+        public ValueTask SaveToAsync(Stream stream, CancellationToken cancellationToken = default)
        {
-            using var entryStream = entry.OpenEntryStream();
-            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+            return SaveToAsync(stream, new WriterOptions(CompressionType.Deflate), cancellationToken);
+        }
+
+        protected override async ValueTask SaveToAsync(Stream stream, WriterOptions options, 
+                                                       IAsyncEnumerable<ZipArchiveEntry> oldEntries, 
+                                                       IAsyncEnumerable<ZipArchiveEntry> newEntries, 
+                                                       CancellationToken cancellationToken = default)
+        {
+            await using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+            await foreach (var entry in oldEntries.Concat(newEntries)
+                                                  .Where(x => !x.IsDirectory)
+                                                  .WithCancellation(cancellationToken))
+            {
+                await using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+                {
+                    await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
+                }
+            }
+        }
+
+        protected override ValueTask<ZipArchiveEntry> CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
+                                                               bool closeStream, CancellationToken cancellationToken = default)
+        {
+            return new(new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream));
+        }
+
+        public static ZipArchive Create()
+        {
+            return new();
+        }
+
+        protected override async ValueTask<IReader> CreateReaderForSolidExtraction()
+        {
+            var stream = (await Volumes.SingleAsync()).Stream;
+            stream.Position = 0;
+            return ZipReader.Open(stream, ReaderOptions);
        }
    }
-
-    protected override ZipArchiveEntry CreateEntryInternal(
-        string filePath,
-        Stream source,
-        long size,
-        DateTime? modified,
-        bool closeStream
-    ) => new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
-
-    public static ZipArchive Create() => new ZipArchive();
-
-    protected override IReader CreateReaderForSolidExtraction()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return ZipReader.Open(stream, ReaderOptions, Entries);
-    }
 }
--- a/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
@@ -1,23 +1,32 @@
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip;

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

-    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
+        public virtual ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        {
+            return Parts.Single().GetCompressedStreamAsync(cancellationToken);
+        }

-    #region IArchiveEntry Members
+        #region IArchiveEntry Members

-    public IArchive Archive { get; }
+        public IArchive Archive { get; }

-    public bool IsComplete => true;
+        public bool IsComplete => true;

-    #endregion
+        #endregion

-    public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
-}
+        public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
+    }
+}
--- a/src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs
@@ -1,35 +0,0 @@
-using System;
-using System.IO;
-using System.Text.RegularExpressions;
-
-namespace SharpCompress.Archives.Zip;
-
-internal static class ZipArchiveVolumeFactory
-{
-    internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
-    {
-        FileInfo? item = null;
-
-        //load files with zip/zipx first. Swapped to end once loaded in ZipArchive
-        //new style .zip, z01.. | .zipx, zx01 - if the numbers go beyond 99 then they use 100 ...1000 etc
-        Match m = Regex.Match(part1.Name, @"^(.*\.)(zipx?|zx?[0-9]+)$", RegexOptions.IgnoreCase);
-        if (m.Success)
-            item = new FileInfo(
-                Path.Combine(
-                    part1.DirectoryName!,
-                    String.Concat(
-                        m.Groups[1].Value,
-                        Regex.Replace(m.Groups[2].Value, @"[^xz]", ""),
-                        index.ToString().PadLeft(2, '0')
-                    )
-                )
-            );
-        else //split - 001, 002 ...
-            return ArchiveVolumeFactory.GetFilePart(index, part1);
-
-        if (item != null && item.Exists)
-            return item;
-
-        return null; //no more items
-    }
-}
--- a/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
@@ -1,73 +1,70 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;

-namespace SharpCompress.Archives.Zip;
-
-internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
+namespace SharpCompress.Archives.Zip
 {
-    private readonly bool closeStream;
-    private readonly Stream stream;
-    private bool isDisposed;
-
-    internal ZipWritableArchiveEntry(
-        ZipArchive archive,
-        Stream stream,
-        string path,
-        long size,
-        DateTime? lastModified,
-        bool closeStream
-    )
-        : base(archive, null)
+    internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
    {
-        this.stream = stream;
-        Key = path;
-        Size = size;
-        LastModifiedTime = lastModified;
-        this.closeStream = closeStream;
-    }
+        private readonly bool closeStream;
+        private readonly Stream stream;
+        private bool isDisposed;

-    public override long Crc => 0;
-
-    public override string Key { get; }
-
-    public override long CompressedSize => 0;
-
-    public override long Size { get; }
-
-    public override DateTime? LastModifiedTime { get; }
-
-    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 => throw new NotImplementedException();
-
-    Stream IWritableArchiveEntry.Stream => stream;
-
-    public override Stream OpenEntryStream()
-    {
-        //ensure new stream is at the start, this could be reset
-        stream.Seek(0, SeekOrigin.Begin);
-        return NonDisposingStream.Create(stream);
-    }
-
-    internal override void Close()
-    {
-        if (closeStream && !isDisposed)
+        internal ZipWritableArchiveEntry(ZipArchive archive, Stream stream, string path, long size,
+                                         DateTime? lastModified, bool closeStream)
+            : base(archive, null)
        {
-            stream.Dispose();
-            isDisposed = true;
+            this.stream = stream;
+            Key = path;
+            Size = size;
+            LastModifiedTime = lastModified;
+            this.closeStream = closeStream;
+        }
+
+        public override long Crc => 0;
+
+        public override string Key { get; }
+
+        public override long CompressedSize => 0;
+
+        public override long Size { get; }
+
+        public override DateTime? LastModifiedTime { get; }
+
+        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 => throw new NotImplementedException();
+
+        Stream IWritableArchiveEntry.Stream => stream;
+
+        public override ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+        {
+            //ensure new stream is at the start, this could be reset
+            stream.Seek(0, SeekOrigin.Begin);
+            return new(new NonDisposingStream(stream));
+        }
+
+        internal override async ValueTask CloseAsync()
+        {
+            if (closeStream && !isDisposed)
+            {
+                await stream.DisposeAsync();
+                isDisposed = true;
+            }
        }
    }
-}
+}
--- a/src/SharpCompress/AssemblyInfo.cs
+++ b/src/SharpCompress/AssemblyInfo.cs
@@ -1,3 +1,24 @@
-using System;
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;

+[assembly: AssemblyTitle("SharpCompress")]
+[assembly: AssemblyProduct("SharpCompress")]
+[assembly: InternalsVisibleTo("SharpCompress.Test" + SharpCompress.AssemblyInfo.PublicKeySuffix)]
 [assembly: CLSCompliant(true)]
+
+namespace SharpCompress
+{
+    /// <summary>
+    /// Just a static class to house the public key, to avoid repetition.
+    /// </summary>
+    internal static class AssemblyInfo
+    {
+        internal const string PublicKeySuffix =
+            ",PublicKey=002400000480000094000000060200000024000052534131000400000100010059acfa17d26c44" +
+            "7a4d03f16eaa72c9187c04f16e6569dd168b080e39a6f5c9fd00f28c768cd8e9a089d5a0e1b34c" +
+            "cd971488e7afe030ce5ce8df2053cf12ec89f6d38065c434c09ee6af3ee284c5dc08f44774b679" +
+            "bf39298e57efe30d4b00aecf9e4f6f8448b2cb0146d8956dfcab606cc64a0ac38c60a7d78b0d65" +
+            "d3b98dc0";
+    }
+}
--- a/src/SharpCompress/AsyncEnumerable.cs
+++ b/src/SharpCompress/AsyncEnumerable.cs
@@ -0,0 +1,25 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress
+{
+    public static class AsyncEnumerable
+    {
+        public static IAsyncEnumerable<T> Empty<T>() => EmptyAsyncEnumerable<T>.Instance;
+        
+
+        private class EmptyAsyncEnumerable<T> : IAsyncEnumerator<T>, IAsyncEnumerable<T>
+        {
+            public static readonly EmptyAsyncEnumerable<T> Instance = 
+                new();
+            public T Current => default!;
+            public ValueTask DisposeAsync() => default;
+            public ValueTask<bool> MoveNextAsync() => new(false);
+            public IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken cancellationToken = new CancellationToken())
+            {
+                return this;
+            }
+        }
+    }
+}
--- a/src/SharpCompress/Common/ArchiveEncoding.cs
+++ b/src/SharpCompress/Common/ArchiveEncoding.cs
@@ -1,55 +1,76 @@
-using System;
+using System;
 using System.Text;

-namespace SharpCompress.Common;
-
-public class ArchiveEncoding
+namespace SharpCompress.Common
 {
-    /// <summary>
-    /// Default encoding to use when archive format doesn't specify one.
-    /// </summary>
-    public Encoding Default { get; set; }
-
-    /// <summary>
-    /// ArchiveEncoding used by encryption schemes which don't comply with RFC 2898.
-    /// </summary>
-    public Encoding Password { get; set; }
-
-    /// <summary>
-    /// Set this encoding when you want to force it for all encoding operations.
-    /// </summary>
-    public Encoding? Forced { get; set; }
-
-    /// <summary>
-    /// Set this when you want to use a custom method for all decoding operations.
-    /// </summary>
-    /// <returns>string Func(bytes, index, length)</returns>
-    public Func<byte[], int, int, string>? CustomDecoder { get; set; }
-
-    public ArchiveEncoding()
-        : this(Encoding.Default, Encoding.Default) { }
-
-    public ArchiveEncoding(Encoding def, Encoding password)
+    public class ArchiveEncoding
    {
-        Default = def;
-        Password = password;
-    }
+        /// <summary>
+        /// Default encoding to use when archive format doesn't specify one.
+        /// </summary>
+        public Encoding Default { get; set; }

-#if !NETFRAMEWORK
-    static ArchiveEncoding() => Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+        /// <summary>
+        /// ArchiveEncoding used by encryption schemes which don't comply with RFC 2898.
+        /// </summary>
+        public Encoding Password { get; set; }
+
+        /// <summary>
+        /// Set this encoding when you want to force it for all encoding operations.
+        /// </summary>
+        public Encoding? Forced { get; set; }
+
+        /// <summary>
+        /// Set this when you want to use a custom method for all decoding operations.
+        /// </summary>
+        /// <returns>string Func(bytes, index, length)</returns>
+        //public Func<byte[], int, int, string>? CustomDecoder { get; set; }
+
+        public ArchiveEncoding()
+        : this(Encoding.Default, Encoding.Default)
+        {
+        }
+        public ArchiveEncoding(Encoding def, Encoding password)
+        {
+            Default = def;
+            Password = password;
+        }
+
+#if !NET461
+        static ArchiveEncoding()
+        {
+            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+        }
 #endif

-    public string Decode(byte[] bytes) => Decode(bytes, 0, bytes.Length);
+        public string Decode(byte[] bytes)
+        {
+            return Decode(bytes, 0, bytes.Length);
+        }

-    public string Decode(byte[] bytes, int start, int length) =>
-        GetDecoder().Invoke(bytes, start, length);
+        public string Decode(byte[] bytes, int start, int length)
+        {
+            return GetEncoding().GetString(bytes, start, length);
+        }
+        
+        public string Decode(ReadOnlySpan<byte> span)
+        {
+            return GetEncoding().GetString(span);
+        }

-    public string DecodeUTF8(byte[] bytes) => Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+        public string DecodeUTF8(byte[] bytes)
+        {
+            return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+        }

-    public byte[] Encode(string str) => GetEncoding().GetBytes(str);
+        public byte[] Encode(string str)
+        {
+            return GetEncoding().GetBytes(str);
+        }

-    public Encoding GetEncoding() => Forced ?? Default ?? Encoding.UTF8;
-
-    public Func<byte[], int, int, string> GetDecoder() =>
-        CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
+        public Encoding GetEncoding()
+        {
+            return Forced ?? Default ?? Encoding.UTF8;
+        }
+    }
 }
--- a/src/SharpCompress/Common/ArchiveException.cs
+++ b/src/SharpCompress/Common/ArchiveException.cs
@@ -1,9 +1,12 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public class ArchiveException : Exception
+namespace SharpCompress.Common
 {
-    public ArchiveException(string message)
-        : base(message) { }
-}
+    public class ArchiveException : Exception
+    {
+        public ArchiveException(string message)
+            : base(message)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/ArchiveExtractionEventArgs.cs
+++ b/src/SharpCompress/Common/ArchiveExtractionEventArgs.cs
@@ -1,10 +1,14 @@
 using System;

-namespace SharpCompress.Common;
-
-public class ArchiveExtractionEventArgs<T> : EventArgs
+namespace SharpCompress.Common
 {
-    internal ArchiveExtractionEventArgs(T entry) => Item = entry;
+    public class ArchiveExtractionEventArgs<T> : EventArgs
+    {
+        internal ArchiveExtractionEventArgs(T entry)
+        {
+            Item = entry;
+        }

-    public T Item { get; }
-}
+        public T Item { get; }
+    }
+}
--- a/src/SharpCompress/Common/ArchiveType.cs
+++ b/src/SharpCompress/Common/ArchiveType.cs
@@ -1,10 +1,11 @@
-namespace SharpCompress.Common;
-
-public enum ArchiveType
+namespace SharpCompress.Common
 {
-    Rar,
-    Zip,
-    Tar,
-    SevenZip,
-    GZip
-}
+    public enum ArchiveType
+    {
+        Rar,
+        Zip,
+        Tar,
+        SevenZip,
+        GZip
+    }
+}
--- a/src/SharpCompress/Common/CompressedBytesReadEventArgs.cs
+++ b/src/SharpCompress/Common/CompressedBytesReadEventArgs.cs
@@ -1,25 +1,23 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public sealed class CompressedBytesReadEventArgs : EventArgs
+namespace SharpCompress.Common
 {
-    public CompressedBytesReadEventArgs(
-        long compressedBytesRead,
-        long currentFilePartCompressedBytesRead
-    )
+    public sealed class CompressedBytesReadEventArgs : EventArgs
    {
-        CompressedBytesRead = compressedBytesRead;
-        CurrentFilePartCompressedBytesRead = currentFilePartCompressedBytesRead;
+        public CompressedBytesReadEventArgs(long compressedBytesRead, long currentFilePartCompressedBytesRead)
+        {
+            CompressedBytesRead = compressedBytesRead;
+            CurrentFilePartCompressedBytesRead = currentFilePartCompressedBytesRead;
+        }
+
+        /// <summary>
+        /// Compressed bytes read for the current entry
+        /// </summary>
+        public long CompressedBytesRead { get; }
+
+        /// <summary>
+        /// Current file part read for Multipart files (e.g. Rar)
+        /// </summary>
+        public long CurrentFilePartCompressedBytesRead { get; }
    }
-
-    /// <summary>
-    /// Compressed bytes read for the current entry
-    /// </summary>
-    public long CompressedBytesRead { get; }
-
-    /// <summary>
-    /// Current file part read for Multipart files (e.g. Rar)
-    /// </summary>
-    public long CurrentFilePartCompressedBytesRead { get; }
-}
+}
--- a/src/SharpCompress/Common/CompressionType.cs
+++ b/src/SharpCompress/Common/CompressionType.cs
@@ -1,18 +1,19 @@
-namespace SharpCompress.Common;
-
-public enum CompressionType
+namespace SharpCompress.Common
 {
-    None,
-    GZip,
-    BZip2,
-    PPMd,
-    Deflate,
-    Rar,
-    LZMA,
-    BCJ,
-    BCJ2,
-    LZip,
-    Xz,
-    Unknown,
-    Deflate64
-}
+    public enum CompressionType
+    {
+        None,
+        GZip,
+        BZip2,
+        PPMd,
+        Deflate,
+        Rar,
+        LZMA,
+        BCJ,
+        BCJ2,
+        LZip,
+        Xz,
+        Unknown,
+        Deflate64
+    }
+}
--- a/src/SharpCompress/Common/CryptographicException.cs
+++ b/src/SharpCompress/Common/CryptographicException.cs
@@ -1,9 +1,12 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public class CryptographicException : Exception
+namespace SharpCompress.Common
 {
-    public CryptographicException(string message)
-        : base(message) { }
-}
+    public class CryptographicException : Exception
+    {
+        public CryptographicException(string message)
+            : base(message)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/Entry.cs
+++ b/src/SharpCompress/Common/Entry.cs
@@ -1,90 +1,91 @@
-using System;
+using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Threading.Tasks;

-namespace SharpCompress.Common;
-
-public abstract class Entry : IEntry
+namespace SharpCompress.Common
 {
-    /// <summary>
-    /// The File's 32 bit CRC Hash
-    /// </summary>
-    public abstract long Crc { get; }
+    public abstract class Entry : IEntry
+    {
+        /// <summary>
+        /// The File's 32 bit CRC Hash
+        /// </summary>
+        public abstract long Crc { get; }

-    /// <summary>
-    /// The string key of the file internal to the Archive.
-    /// </summary>
-    public abstract string Key { get; }
+        /// <summary>
+        /// The string key of the file internal to the Archive.
+        /// </summary>
+        public abstract string Key { get; }

-    /// <summary>
-    /// The target of a symlink entry internal to the Archive. Will be null if not a symlink.
-    /// </summary>
-    public abstract string? LinkTarget { get; }
+        /// <summary>
+        /// The target of a symlink entry internal to the Archive. Will be null if not a symlink.
+        /// </summary>
+        public abstract string? LinkTarget { get; }

-    /// <summary>
-    /// The compressed file size
-    /// </summary>
-    public abstract long CompressedSize { get; }
+        /// <summary>
+        /// The compressed file size
+        /// </summary>
+        public abstract long CompressedSize { get; }

-    /// <summary>
-    /// The compression type
-    /// </summary>
-    public abstract CompressionType CompressionType { get; }
+        /// <summary>
+        /// The compression type
+        /// </summary>
+        public abstract CompressionType CompressionType { get; }

-    /// <summary>
-    /// The uncompressed file size
-    /// </summary>
-    public abstract long Size { get; }
+        /// <summary>
+        /// The uncompressed file size
+        /// </summary>
+        public abstract long Size { get; }

-    /// <summary>
-    /// The entry last modified time in the archive, if recorded
-    /// </summary>
-    public abstract DateTime? LastModifiedTime { get; }
+        /// <summary>
+        /// The entry last modified time in the archive, if recorded
+        /// </summary>
+        public abstract DateTime? LastModifiedTime { get; }

-    /// <summary>
-    /// The entry create time in the archive, if recorded
-    /// </summary>
-    public abstract DateTime? CreatedTime { get; }
+        /// <summary>
+        /// The entry create time in the archive, if recorded
+        /// </summary>
+        public abstract DateTime? CreatedTime { get; }

-    /// <summary>
-    /// The entry last accessed time in the archive, if recorded
-    /// </summary>
-    public abstract DateTime? LastAccessedTime { get; }
+        /// <summary>
+        /// The entry last accessed time in the archive, if recorded
+        /// </summary>
+        public abstract DateTime? LastAccessedTime { get; }

-    /// <summary>
-    /// The entry time when archived, if recorded
-    /// </summary>
-    public abstract DateTime? ArchivedTime { get; }
+        /// <summary>
+        /// The entry time when archived, if recorded
+        /// </summary>
+        public abstract DateTime? ArchivedTime { get; }

-    /// <summary>
-    /// Entry is password protected and encrypted and cannot be extracted.
-    /// </summary>
-    public abstract bool IsEncrypted { get; }
+        /// <summary>
+        /// Entry is password protected and encrypted and cannot be extracted.
+        /// </summary>
+        public abstract bool IsEncrypted { get; }

-    /// <summary>
-    /// Entry is directory.
-    /// </summary>
-    public abstract bool IsDirectory { get; }
+        /// <summary>
+        /// Entry is directory.
+        /// </summary>
+        public abstract bool IsDirectory { get; }

-    /// <summary>
-    /// Entry is split among multiple volumes
-    /// </summary>
-    public abstract bool IsSplitAfter { get; }
+        /// <summary>
+        /// Entry is split among multiple volumes
+        /// </summary>
+        public abstract bool IsSplitAfter { get; }

-    public int VolumeIndexFirst => Parts?.FirstOrDefault()?.Index ?? 0;
-    public int VolumeIndexLast => Parts?.LastOrDefault()?.Index ?? 0;
+        /// <inheritdoc/>
+        public override string ToString() => Key;

-    /// <inheritdoc/>
-    public override string ToString() => Key;
+        internal abstract IEnumerable<FilePart> Parts { get; }

-    internal abstract IEnumerable<FilePart> Parts { get; }
+        internal bool IsSolid { get; set; }

-    public bool IsSolid { get; set; }
+        internal virtual ValueTask CloseAsync()
+        {
+            return new ();
+        }

-    internal virtual void Close() { }
-
-    /// <summary>
-    /// Entry file attribute.
-    /// </summary>
-    public virtual int? Attrib => throw new NotImplementedException();
+        /// <summary>
+        /// Entry file attribute.
+        /// </summary>
+        public virtual int? Attrib => throw new NotImplementedException();
+    }
 }
--- a/src/SharpCompress/Common/EntryStream.cs
+++ b/src/SharpCompress/Common/EntryStream.cs
@@ -1,86 +1,85 @@
-using System;
+using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.IO;
 using SharpCompress.Readers;

-namespace SharpCompress.Common;
-
-public class EntryStream : Stream
+namespace SharpCompress.Common
 {
-    private readonly IReader _reader;
-    private readonly Stream _stream;
-    private bool _completed;
-    private bool _isDisposed;
-
-    internal EntryStream(IReader reader, Stream stream)
+    public class EntryStream : AsyncStream
    {
-        _reader = reader;
-        _stream = stream;
-    }
+        private readonly IReader _reader;
+        private readonly Stream _stream;
+        private bool _completed;
+        private bool _isDisposed;

-    /// <summary>
-    /// When reading a stream from OpenEntryStream, the stream must be completed so use this to finish reading the entire entry.
-    /// </summary>
-    public void SkipEntry()
-    {
-        this.Skip();
-        _completed = true;
-    }
-
-    protected override void Dispose(bool disposing)
-    {
-        if (!(_completed || _reader.Cancelled))
+        internal EntryStream(IReader reader, Stream stream)
        {
-            SkipEntry();
+            _reader = reader;
+            _stream = stream;
        }
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
-        base.Dispose(disposing);
-        _stream.Dispose();
-    }
-
-    public override bool CanRead => true;
-
-    public override bool CanSeek => false;
-
-    public override bool CanWrite => false;
-
-    public override void Flush() { }
-
-    public override long Length => _stream.Length;
-
-    public override long Position
-    {
-        get => throw new NotSupportedException();
-        set => throw new NotSupportedException();
-    }
-
-    public override int Read(byte[] buffer, int offset, int count)
-    {
-        var read = _stream.Read(buffer, offset, count);
-        if (read <= 0)
+
+        /// <summary>
+        /// When reading a stream from OpenEntryStream, the stream must be completed so use this to finish reading the entire entry.
+        /// </summary>
+        public async ValueTask SkipEntryAsync(CancellationToken cancellationToken = default)
        {
+            await this.SkipAsync(cancellationToken);
            _completed = true;
        }
-        return read;
-    }

-    public override int ReadByte()
-    {
-        var value = _stream.ReadByte();
-        if (value == -1)
+        public override async ValueTask DisposeAsync()
        {
-            _completed = true;
+            if (!(_completed || _reader.Cancelled))
+            {
+                await SkipEntryAsync();
+            }
+            if (_isDisposed)
+            {
+                return;
+            }
+            _isDisposed = true;
+            await _stream.DisposeAsync();
+        }
+
+        public override bool CanRead => true;
+
+        public override bool CanSeek => false;
+
+        public override bool CanWrite => false;
+        public override long Length => _stream.Length;
+
+        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
+
+        public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            int read = await _stream.ReadAsync(buffer, cancellationToken);
+            if (read <= 0)
+            {
+                _completed = true;
+            }
+            return read;
+        }
+
+        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
        }
-        return value;
    }
-
-    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
-
-    public override void SetLength(long value) => throw new NotSupportedException();
-
-    public override void Write(byte[] buffer, int offset, int count) =>
-        throw new NotSupportedException();
-}
+}
--- a/src/SharpCompress/Common/ExtractionException.cs
+++ b/src/SharpCompress/Common/ExtractionException.cs
@@ -1,12 +1,17 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public class ExtractionException : Exception
+namespace SharpCompress.Common
 {
-    public ExtractionException(string message)
-        : base(message) { }
+    public class ExtractionException : Exception
+    {
+        public ExtractionException(string message)
+            : base(message)
+        {
+        }

-    public ExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}
+        public ExtractionException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/ExtractionMethods.cs
+++ b/src/SharpCompress/Common/ExtractionMethods.cs
@@ -1,117 +1,97 @@
-using System;
+using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;

-namespace SharpCompress.Common;
-
-internal static class ExtractionMethods
+namespace SharpCompress.Common
 {
-    /// <summary>
-    /// Extract to specific directory, retaining filename
-    /// </summary>
-    public static void WriteEntryToDirectory(
-        IEntry entry,
-        string destinationDirectory,
-        ExtractionOptions? options,
-        Action<string, ExtractionOptions?> write
-    )
+    internal static class ExtractionMethods
    {
-        string destinationFileName;
-        string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
-
-        //check for trailing slash.
-        if (
-            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
-            != Path.DirectorySeparatorChar
-        )
+        /// <summary>
+        /// Extract to specific directory, retaining filename
+        /// </summary>
+        public static async ValueTask WriteEntryToDirectoryAsync(IEntry entry,
+                                                 string destinationDirectory,
+                                                 ExtractionOptions? options,
+                                                 Func<string, ExtractionOptions?, CancellationToken, ValueTask> write,
+                                                 CancellationToken cancellationToken = default)
        {
-            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
-        }
+            string destinationFileName;
+            string file = Path.GetFileName(entry.Key);
+            string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);

-        if (!Directory.Exists(fullDestinationDirectoryPath))
-        {
-            throw new ExtractionException(
-                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
-            );
-        }
-
-        options ??= new ExtractionOptions() { Overwrite = true };
-
-        string file = Path.GetFileName(entry.Key);
-        if (options.ExtractFullPath)
-        {
-            string folder = Path.GetDirectoryName(entry.Key)!;
-            string destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
-
-            if (!Directory.Exists(destdir))
+            options ??= new ExtractionOptions()
            {
-                if (!destdir.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
+                Overwrite = true
+            };
+
+            if (options.ExtractFullPath)
+            {
+                string folder = Path.GetDirectoryName(entry.Key)!;
+                string destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+
+                if (!Directory.Exists(destdir))
                {
-                    throw new ExtractionException(
-                        "Entry is trying to create a directory outside of the destination directory."
-                    );
+                    if (!destdir.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
+                    {
+                        throw new ExtractionException("Entry is trying to create a directory outside of the destination directory.");
+                    }
+
+                    Directory.CreateDirectory(destdir);
+                }
+                destinationFileName = Path.Combine(destdir, file);
+            }
+            else
+            {
+                destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
+
+            }
+
+            if (!entry.IsDirectory)
+            {
+                destinationFileName = Path.GetFullPath(destinationFileName);
+
+                if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
+                {
+                    throw new ExtractionException("Entry is trying to write a file outside of the destination directory.");
+                }
+                await write(destinationFileName, options, cancellationToken);
+            }
+            else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
+            {
+                Directory.CreateDirectory(destinationFileName);
+            }
+        }
+
+        public static async ValueTask WriteEntryToFileAsync(IEntry entry, string destinationFileName,
+                                            ExtractionOptions? options,
+                                            Func<string, FileMode, CancellationToken, ValueTask> openAndWrite,
+                                            CancellationToken cancellationToken = default)
+        {
+            if (entry.LinkTarget is not null)
+            {
+                if (options?.WriteSymbolicLink is null)
+                {
+                    throw new ExtractionException("Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null");
+                }
+                options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
+            }
+            else
+            {
+                FileMode fm = FileMode.Create;
+                options ??= new ExtractionOptions()
+                {
+                    Overwrite = true
+                };
+
+                if (!options.Overwrite)
+                {
+                    fm = FileMode.CreateNew;
                }

-                Directory.CreateDirectory(destdir);
+                await openAndWrite(destinationFileName, fm, cancellationToken);
+                entry.PreserveExtractionOptions(destinationFileName, options);
            }
-            destinationFileName = Path.Combine(destdir, file);
-        }
-        else
-        {
-            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
-        }
-
-        if (!entry.IsDirectory)
-        {
-            destinationFileName = Path.GetFullPath(destinationFileName);
-
-            if (
-                !destinationFileName.StartsWith(
-                    fullDestinationDirectoryPath,
-                    StringComparison.Ordinal
-                )
-            )
-            {
-                throw new ExtractionException(
-                    "Entry is trying to write a file outside of the destination directory."
-                );
-            }
-            write(destinationFileName, options);
-        }
-        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
-        {
-            Directory.CreateDirectory(destinationFileName);
        }
    }
-
-    public static void WriteEntryToFile(
-        IEntry entry,
-        string destinationFileName,
-        ExtractionOptions? options,
-        Action<string, FileMode> openAndWrite
-    )
-    {
-        if (entry.LinkTarget != null)
-        {
-            if (options?.WriteSymbolicLink is null)
-            {
-                throw new ExtractionException(
-                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
-                );
-            }
-            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
-        }
-        else
-        {
-            FileMode fm = FileMode.Create;
-            options ??= new ExtractionOptions() { Overwrite = true };
-
-            if (!options.Overwrite)
-            {
-                fm = FileMode.CreateNew;
-            }
-
-            openAndWrite(destinationFileName, fm);
-            entry.PreserveExtractionOptions(destinationFileName, options);
-        }
-    }
-}
+}
--- a/src/SharpCompress/Common/ExtractionOptions.cs
+++ b/src/SharpCompress/Common/ExtractionOptions.cs
@@ -1,40 +1,40 @@
-using System;
+using System;

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

-namespace SharpCompress.Common;
-
-public abstract class FilePart
+namespace SharpCompress.Common
 {
-    protected FilePart(ArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding;
+    public abstract class FilePart
+    {
+        protected FilePart(ArchiveEncoding archiveEncoding)
+        {
+            ArchiveEncoding = archiveEncoding;
+        }

-    internal ArchiveEncoding ArchiveEncoding { get; }
+        internal ArchiveEncoding ArchiveEncoding { get; }

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

-    internal abstract Stream GetCompressedStream();
-    internal abstract Stream? GetRawStream();
-    internal bool Skipped { get; set; }
+        internal abstract ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken);
+        internal abstract Stream? GetRawStream();
+        internal bool Skipped { get; set; }
+    }
 }
--- a/src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs
+++ b/src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs
@@ -1,28 +1,29 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public sealed class FilePartExtractionBeginEventArgs : EventArgs
+namespace SharpCompress.Common
 {
-    public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize)
+    public sealed class FilePartExtractionBeginEventArgs : EventArgs
    {
-        Name = name;
-        Size = size;
-        CompressedSize = compressedSize;
+        public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize)
+        {
+            Name = name;
+            Size = size;
+            CompressedSize = compressedSize;
+        }
+
+        /// <summary>
+        /// File name for the part for the current entry
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Uncompressed size of the current entry in the part
+        /// </summary>
+        public long Size { get; }
+
+        /// <summary>
+        /// Compressed size of the current entry in the part
+        /// </summary>
+        public long CompressedSize { get; }
    }
-
-    /// <summary>
-    /// File name for the part for the current entry
-    /// </summary>
-    public string Name { get; }
-
-    /// <summary>
-    /// Uncompressed size of the current entry in the part
-    /// </summary>
-    public long Size { get; }
-
-    /// <summary>
-    /// Compressed size of the current entry in the part
-    /// </summary>
-    public long CompressedSize { get; }
-}
+}
--- a/src/SharpCompress/Common/FlagUtility.cs
+++ b/src/SharpCompress/Common/FlagUtility.cs
@@ -1,86 +1,108 @@
 using System;

-namespace SharpCompress.Common;
-
-internal static class FlagUtility
+namespace SharpCompress.Common
 {
-    /// <summary>
-    /// Returns true if the flag is set on the specified bit field.
-    /// Currently only works with 32-bit bitfields.
-    /// </summary>
-    /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to test</param>
-    /// <returns></returns>
-    public static bool HasFlag<T>(long bitField, T flag)
-        where T : struct => HasFlag(bitField, flag);
-
-    /// <summary>
-    /// Returns true if the flag is set on the specified bit field.
-    /// Currently only works with 32-bit bitfields.
-    /// </summary>
-    /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to test</param>
-    /// <returns></returns>
-    public static bool HasFlag<T>(ulong bitField, T flag)
-        where T : struct => HasFlag(bitField, flag);
-
-    /// <summary>
-    /// Returns true if the flag is set on the specified bit field.
-    /// Currently only works with 32-bit bitfields.
-    /// </summary>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to test</param>
-    /// <returns></returns>
-    public static bool HasFlag(ulong bitField, ulong flag) => ((bitField & flag) == flag);
-
-    public static bool HasFlag(short bitField, short flag) => ((bitField & flag) == flag);
-
-    /// <summary>
-    /// Returns true if the flag is set on the specified bit field.
-    /// Currently only works with 32-bit bitfields.
-    /// </summary>
-    /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to test</param>
-    /// <returns></returns>
-    public static bool HasFlag<T>(T bitField, T flag)
-        where T : struct => HasFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag));
-
-    /// <summary>
-    /// Returns true if the flag is set on the specified bit field.
-    /// Currently only works with 32-bit bitfields.
-    /// </summary>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to test</param>
-    /// <returns></returns>
-    public static bool HasFlag(long bitField, long flag) => ((bitField & flag) == flag);
-
-    /// <summary>
-    /// Sets a bit-field to either on or off for the specified flag.
-    /// </summary>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to change</param>
-    /// <param name="on">bool</param>
-    /// <returns>The flagged variable with the flag changed</returns>
-    public static long SetFlag(long bitField, long flag, bool on)
+    internal static class FlagUtility
    {
-        if (on)
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag<T>(long bitField, T flag)
+            where T : struct
        {
-            return bitField | flag;
+            return HasFlag(bitField, flag);
        }
-        return bitField & (~flag);
-    }

-    /// <summary>
-    /// Sets a bit-field to either on or off for the specified flag.
-    /// </summary>
-    /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
-    /// <param name="bitField">Flagged variable</param>
-    /// <param name="flag">Flag to change</param>
-    /// <param name="on">bool</param>
-    /// <returns>The flagged variable with the flag changed</returns>
-    public static long SetFlag<T>(T bitField, T flag, bool on)
-        where T : struct => SetFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag), on);
-}
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag<T>(ulong bitField, T flag)
+            where T : struct
+        {
+            return HasFlag(bitField, flag);
+        }
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag(ulong bitField, ulong flag)
+        {
+            return ((bitField & flag) == flag);
+        }
+
+        public static bool HasFlag(short bitField, short flag)
+        {
+            return ((bitField & flag) == flag);
+        }
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag<T>(T bitField, T flag)
+            where T : struct
+        {
+            return HasFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag));
+        }
+
+        /// <summary>
+        /// Returns true if the flag is set on the specified bit field.
+        /// Currently only works with 32-bit bitfields. 
+        /// </summary>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to test</param>
+        /// <returns></returns>
+        public static bool HasFlag(long bitField, long flag)
+        {
+            return ((bitField & flag) == flag);
+        }
+
+        /// <summary>
+        /// Sets a bit-field to either on or off for the specified flag.
+        /// </summary>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to change</param>
+        /// <param name="on">bool</param>
+        /// <returns>The flagged variable with the flag changed</returns>
+        public static long SetFlag(long bitField, long flag, bool on)
+        {
+            if (on)
+            {
+                return bitField | flag;
+            }
+            return bitField & (~flag);
+        }
+
+        /// <summary>
+        /// Sets a bit-field to either on or off for the specified flag.
+        /// </summary>
+        /// <typeparam name="T">Enumeration with Flags attribute</typeparam>
+        /// <param name="bitField">Flagged variable</param>
+        /// <param name="flag">Flag to change</param>
+        /// <param name="on">bool</param>
+        /// <returns>The flagged variable with the flag changed</returns>
+        public static long SetFlag<T>(T bitField, T flag, bool on)
+            where T : struct
+        {
+            return SetFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag), on);
+        }
+    }
+}
--- a/src/SharpCompress/Common/GZip/GZipEntry.cs
+++ b/src/SharpCompress/Common/GZip/GZipEntry.cs
@@ -1,45 +1,54 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.CompilerServices;
+using System.Threading;

-namespace SharpCompress.Common.GZip;
-
-public class GZipEntry : Entry
+namespace SharpCompress.Common.GZip
 {
-    private readonly GZipFilePart _filePart;
-
-    internal GZipEntry(GZipFilePart filePart) => _filePart = filePart;
-
-    public override CompressionType CompressionType => CompressionType.GZip;
-
-    public override long Crc => _filePart.Crc ?? 0;
-
-    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 DateTime? LastModifiedTime => _filePart.DateModified;
-
-    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.AsEnumerable<FilePart>();
-
-    internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
+    public class GZipEntry : Entry
    {
-        yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
+        private readonly GZipFilePart _filePart;
+
+        internal GZipEntry(GZipFilePart filePart)
+        {
+            _filePart = filePart;
+        }
+
+        public override CompressionType CompressionType => CompressionType.GZip;
+
+        public override long Crc => _filePart.Crc ?? 0;
+
+        public override string Key => _filePart.FilePartName ?? string.Empty;
+
+        public override string? LinkTarget => null;
+
+        public override long CompressedSize => 0;
+
+        public override long Size => _filePart.UncompressedSize ?? 0;
+
+        public override DateTime? LastModifiedTime => _filePart.DateModified;
+
+        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.AsEnumerable<FilePart>();
+
+        internal static async IAsyncEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options,
+                                                                     [EnumeratorCancellation] CancellationToken cancellationToken)
+        {
+            var part = new GZipFilePart(options.ArchiveEncoding);
+            await part.Initialize(stream, cancellationToken);
+            yield return new GZipEntry(part);
+        }
    }
-}
+}
--- a/src/SharpCompress/Common/GZip/GZipFilePart.cs
+++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs
@@ -1,131 +1,70 @@
-using System;
+using System;
+using System.Buffers;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;

-namespace SharpCompress.Common.GZip;
-
-internal sealed class GZipFilePart : FilePart
+namespace SharpCompress.Common.GZip
 {
-    private string? _name;
-    private readonly Stream _stream;
-
-    internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
-        : base(archiveEncoding)
+    internal sealed class GZipFilePart : FilePart
    {
-        _stream = stream;
-        ReadAndValidateGzipHeader();
-        if (stream.CanSeek)
+        private string? _name;
+        //init only
+#nullable disable
+        private Stream _stream;
+#nullable enable
+
+        internal GZipFilePart(ArchiveEncoding archiveEncoding)
+            : base(archiveEncoding)
        {
-            var position = stream.Position;
-            stream.Position = stream.Length - 8;
-            ReadTrailer();
-            stream.Position = position;
-        }
-        EntryStartPosition = stream.Position;
-    }
-
-    internal long EntryStartPosition { get; }
-
-    internal DateTime? DateModified { get; private set; }
-    internal uint? Crc { get; private set; }
-    internal uint? UncompressedSize { get; private set; }
-
-    internal override string FilePartName => _name!;
-
-    internal override Stream GetCompressedStream() =>
-        new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
-
-    internal override Stream GetRawStream() => _stream;
-
-    private void ReadTrailer()
-    {
-        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-        Span<byte> trailer = stackalloc byte[8];
-        var n = _stream.Read(trailer);
-
-        Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
-        UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.Slice(4));
-    }
-
-    private void ReadAndValidateGzipHeader()
-    {
-        // read the header on the first read
-        Span<byte> header = stackalloc byte[10];
-        var n = _stream.Read(header);
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (n == 0)
-        {
-            return;
        }

-        if (n != 10)
+        internal async ValueTask Initialize(Stream stream, CancellationToken cancellationToken)
        {
-            throw new ZlibException("Not a valid GZIP stream.");
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            throw new ZlibException("Bad GZIP header.");
-        }
-
-        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
-        DateModified = TarHeader.EPOCH.AddSeconds(timet);
-        if ((header[3] & 0x04) == 0x04)
-        {
-            // read and discard extra field
-            n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
-
-            var extraLength = (short)(header[0] + (header[1] * 256));
-            var extra = new byte[extraLength];
-
-            if (!_stream.ReadFully(extra))
+            _stream = stream;
+            if (stream.CanSeek)
            {
-                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+                long position = stream.Position;
+                stream.Position = stream.Length - 8;
+                await ReadTrailerAsync(cancellationToken);
+                stream.Position = position;
            }
-            n = extraLength;
+            EntryStartPosition = stream.Position;
        }
-        if ((header[3] & 0x08) == 0x08)
-        {
-            _name = ReadZeroTerminatedString(_stream);
-        }
-        if ((header[3] & 0x10) == 0x010)
-        {
-            ReadZeroTerminatedString(_stream);
-        }
-        if ((header[3] & 0x02) == 0x02)
-        {
-            _stream.ReadByte(); // CRC16, ignore
-        }
-    }

-    private string ReadZeroTerminatedString(Stream stream)
-    {
-        Span<byte> buf1 = stackalloc byte[1];
-        var list = new List<byte>();
-        var done = false;
-        do
+        internal long EntryStartPosition { get; private set; }
+
+        internal DateTime? DateModified { get; private set; }
+        internal int? Crc { get; private set; }
+        internal int? UncompressedSize { get; private set; }
+
+        internal override string? FilePartName => _name;
+
+        internal override async ValueTask<Stream> GetCompressedStreamAsync(CancellationToken cancellationToken)
        {
-            // workitem 7740
-            var n = stream.Read(buf1);
-            if (n != 1)
-            {
-                throw new ZlibException("Unexpected EOF reading GZIP header.");
-            }
-            if (buf1[0] == 0)
-            {
-                done = true;
-            }
-            else
-            {
-                list.Add(buf1[0]);
-            }
-        } while (!done);
-        var buffer = list.ToArray();
-        return ArchiveEncoding.Decode(buffer);
+            var stream = new GZipStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
+            await stream.ReadAsync(Array.Empty<byte>(), 0, 0, cancellationToken);
+            _name = stream.FileName;
+            DateModified = stream.LastModified;
+            return stream;
+        }
+
+        internal override Stream GetRawStream()
+        {
+            return _stream;
+        }
+
+        private async ValueTask ReadTrailerAsync(CancellationToken cancellationToken)
+        {
+            // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
+
+            Crc = await _stream.ReadInt32(cancellationToken);
+            UncompressedSize = await _stream.ReadInt32(cancellationToken);
+        }
    }
 }
--- a/src/SharpCompress/Common/GZip/GZipVolume.cs
+++ b/src/SharpCompress/Common/GZip/GZipVolume.cs
@@ -1,17 +1,23 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;

-namespace SharpCompress.Common.GZip;
-
-public class GZipVolume : Volume
+namespace SharpCompress.Common.GZip
 {
-    public GZipVolume(Stream stream, ReaderOptions options, int index = 0)
-        : base(stream, options, index) { }
+    public class GZipVolume : Volume
+    {
+        public GZipVolume(Stream stream, ReaderOptions options)
+            : base(stream, options)
+        {
+        }

-    public GZipVolume(FileInfo fileInfo, ReaderOptions options)
-        : base(fileInfo.OpenRead(), options) => options.LeaveStreamOpen = false;
+        public GZipVolume(FileInfo fileInfo, ReaderOptions options)
+            : base(fileInfo.OpenRead(), options)
+        {
+            options.LeaveStreamOpen = false;
+        }

-    public override bool IsFirstVolume => true;
+        public override bool IsFirstVolume => true;

-    public override bool IsMultiVolume => true;
-}
+        public override bool IsMultiVolume => true;
+    }
+}
--- a/src/SharpCompress/Common/IEntry.Extensions.cs
+++ b/src/SharpCompress/Common/IEntry.Extensions.cs
@@ -1,48 +1,45 @@
-using System.IO;
+using System.IO;

-namespace SharpCompress.Common;
-
-internal static class EntryExtensions
+namespace SharpCompress.Common
 {
-    internal static void PreserveExtractionOptions(
-        this IEntry entry,
-        string destinationFileName,
-        ExtractionOptions options
-    )
+    internal static class EntryExtensions
    {
-        if (options.PreserveFileTime || options.PreserveAttributes)
+        internal static void PreserveExtractionOptions(this IEntry entry, string destinationFileName,
+                                                        ExtractionOptions options)
        {
-            var nf = new FileInfo(destinationFileName);
-            if (!nf.Exists)
+            if (options.PreserveFileTime || options.PreserveAttributes)
            {
-                return;
-            }
-
-            // update file time to original packed time
-            if (options.PreserveFileTime)
-            {
-                if (entry.CreatedTime.HasValue)
+                FileInfo nf = new FileInfo(destinationFileName);
+                if (!nf.Exists)
                {
-                    nf.CreationTime = entry.CreatedTime.Value;
+                    return;
                }

-                if (entry.LastModifiedTime.HasValue)
+                // update file time to original packed time
+                if (options.PreserveFileTime)
                {
-                    nf.LastWriteTime = entry.LastModifiedTime.Value;
+                    if (entry.CreatedTime.HasValue)
+                    {
+                        nf.CreationTime = entry.CreatedTime.Value;
+                    }
+
+                    if (entry.LastModifiedTime.HasValue)
+                    {
+                        nf.LastWriteTime = entry.LastModifiedTime.Value;
+                    }
+
+                    if (entry.LastAccessedTime.HasValue)
+                    {
+                        nf.LastAccessTime = entry.LastAccessedTime.Value;
+                    }
                }

-                if (entry.LastAccessedTime.HasValue)
+                if (options.PreserveAttributes)
                {
-                    nf.LastAccessTime = entry.LastAccessedTime.Value;
-                }
-            }
-
-            if (options.PreserveAttributes)
-            {
-                if (entry.Attrib.HasValue)
-                {
-                    nf.Attributes = (FileAttributes)
-                        System.Enum.ToObject(typeof(FileAttributes), entry.Attrib.Value);
+                    if (entry.Attrib.HasValue)
+                    {
+                        nf.Attributes = (FileAttributes)System.Enum.ToObject(typeof(FileAttributes), entry.Attrib.Value);
+                    }
                }
            }
        }
--- a/src/SharpCompress/Common/IEntry.cs
+++ b/src/SharpCompress/Common/IEntry.cs
@@ -1,24 +1,22 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public interface IEntry
+namespace SharpCompress.Common
 {
-    CompressionType CompressionType { get; }
-    DateTime? ArchivedTime { get; }
-    long CompressedSize { get; }
-    long Crc { get; }
-    DateTime? CreatedTime { get; }
-    string Key { get; }
-    string? LinkTarget { get; }
-    bool IsDirectory { get; }
-    bool IsEncrypted { get; }
-    bool IsSplitAfter { get; }
-    bool IsSolid { get; }
-    int VolumeIndexFirst { get; }
-    int VolumeIndexLast { get; }
-    DateTime? LastAccessedTime { get; }
-    DateTime? LastModifiedTime { get; }
-    long Size { get; }
-    int? Attrib { get; }
-}
+    public interface IEntry
+    {
+        CompressionType CompressionType { get; }
+        DateTime? ArchivedTime { get; }
+        long CompressedSize { get; }
+        long Crc { get; }
+        DateTime? CreatedTime { get; }
+        string Key { get; }
+        string? LinkTarget { get; }
+        bool IsDirectory { get; }
+        bool IsEncrypted { get; }
+        bool IsSplitAfter { get; }
+        DateTime? LastAccessedTime { get; }
+        DateTime? LastModifiedTime { get; }
+        long Size { get; }
+        int? Attrib { get; }
+    }
+}
--- a/src/SharpCompress/Common/IExtractionListener.cs
+++ b/src/SharpCompress/Common/IExtractionListener.cs
@@ -1,7 +1,8 @@
-namespace SharpCompress.Common;
-
-public interface IExtractionListener
+namespace SharpCompress.Common
 {
-    void FireFilePartExtractionBegin(string name, long size, long compressedSize);
-    void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes);
-}
+    internal interface IExtractionListener
+    {
+        void FireFilePartExtractionBegin(string name, long size, long compressedSize);
+        void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes);
+    }
+}
--- a/src/SharpCompress/Common/IVolume.cs
+++ b/src/SharpCompress/Common/IVolume.cs
@@ -1,10 +1,8 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public interface IVolume : IDisposable
+namespace SharpCompress.Common
 {
-    int Index { get; }
-
-    string FileName { get; }
-}
+    public interface IVolume : IAsyncDisposable
+    {
+    }
+}
--- a/src/SharpCompress/Common/IncompleteArchiveException.cs
+++ b/src/SharpCompress/Common/IncompleteArchiveException.cs
@@ -1,7 +1,10 @@
-namespace SharpCompress.Common;
-
-public class IncompleteArchiveException : ArchiveException
+namespace SharpCompress.Common
 {
-    public IncompleteArchiveException(string message)
-        : base(message) { }
-}
+    public class IncompleteArchiveException : ArchiveException
+    {
+        public IncompleteArchiveException(string message)
+            : base(message)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/InvalidFormatException.cs
+++ b/src/SharpCompress/Common/InvalidFormatException.cs
@@ -1,12 +1,17 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public class InvalidFormatException : ExtractionException
+namespace SharpCompress.Common
 {
-    public InvalidFormatException(string message)
-        : base(message) { }
+    public class InvalidFormatException : ExtractionException
+    {
+        public InvalidFormatException(string message)
+            : base(message)
+        {
+        }

-    public InvalidFormatException(string message, Exception inner)
-        : base(message, inner) { }
-}
+        public InvalidFormatException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/MultiVolumeExtractionException.cs
+++ b/src/SharpCompress/Common/MultiVolumeExtractionException.cs
@@ -1,12 +1,17 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public class MultiVolumeExtractionException : ExtractionException
+namespace SharpCompress.Common
 {
-    public MultiVolumeExtractionException(string message)
-        : base(message) { }
+    public class MultiVolumeExtractionException : ExtractionException
+    {
+        public MultiVolumeExtractionException(string message)
+            : base(message)
+        {
+        }

-    public MultiVolumeExtractionException(string message, Exception inner)
-        : base(message, inner) { }
-}
+        public MultiVolumeExtractionException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/MultipartStreamRequiredException.cs
+++ b/src/SharpCompress/Common/MultipartStreamRequiredException.cs
@@ -1,7 +1,10 @@
-namespace SharpCompress.Common;
-
-public class MultipartStreamRequiredException : ExtractionException
+namespace SharpCompress.Common
 {
-    public MultipartStreamRequiredException(string message)
-        : base(message) { }
-}
+    public class MultipartStreamRequiredException : ExtractionException
+    {
+        public MultipartStreamRequiredException(string message)
+            : base(message)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/OptionsBase.cs
+++ b/src/SharpCompress/Common/OptionsBase.cs
@@ -1,11 +1,13 @@
-namespace SharpCompress.Common;
-
-public class OptionsBase
+
+namespace SharpCompress.Common
 {
-    /// <summary>
-    /// SharpCompress will keep the supplied streams open.  Default is true.
-    /// </summary>
-    public bool LeaveStreamOpen { get; set; } = true;
+    public class OptionsBase
+    {
+        /// <summary>
+        /// SharpCompress will keep the supplied streams open.  Default is true.
+        /// </summary>
+        public bool LeaveStreamOpen { get; set; } = true;

-    public ArchiveEncoding ArchiveEncoding { get; set; } = new ArchiveEncoding();
-}
+        public ArchiveEncoding ArchiveEncoding { get; set; } = new ArchiveEncoding();
+    }
+}
--- a/src/SharpCompress/Common/PasswordProtectedException.cs
+++ b/src/SharpCompress/Common/PasswordProtectedException.cs
@@ -1,12 +1,17 @@
-using System;
+using System;

-namespace SharpCompress.Common;
-
-public class PasswordProtectedException : ExtractionException
+namespace SharpCompress.Common
 {
-    public PasswordProtectedException(string message)
-        : base(message) { }
+    public class PasswordProtectedException : ExtractionException
+    {
+        public PasswordProtectedException(string message)
+            : base(message)
+        {
+        }

-    public PasswordProtectedException(string message, Exception inner)
-        : base(message, inner) { }
-}
+        public PasswordProtectedException(string message, Exception inner)
+            : base(message, inner)
+        {
+        }
+    }
+}
--- a/src/SharpCompress/Common/Rar/Headers/AVHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/AVHeader.cs
@@ -1,31 +1,32 @@
-using SharpCompress.IO;
+using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class AvHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    public AvHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.Av)
+    internal class AvHeader : RarHeader
    {
-        if (IsRar5)
+        public AvHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.Av)
        {
-            throw new InvalidFormatException("unexpected rar5 record");
+            if (IsRar5)
+            {
+                throw new InvalidFormatException("unexpected rar5 record");
+            }
        }
+
+        protected override void ReadFinish(MarkingBinaryReader reader)
+        {
+            UnpackVersion = reader.ReadByte();
+            Method = reader.ReadByte();
+            AvVersion = reader.ReadByte();
+            AvInfoCrc = reader.ReadInt32();
+        }
+
+        internal int AvInfoCrc { get; private set; }
+
+        internal byte UnpackVersion { get; private set; }
+
+        internal byte Method { get; private set; }
+
+        internal byte AvVersion { get; private set; }
    }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
-    {
-        UnpackVersion = reader.ReadByte();
-        Method = reader.ReadByte();
-        AvVersion = reader.ReadByte();
-        AvInfoCrc = reader.ReadInt32();
-    }
-
-    internal int AvInfoCrc { get; private set; }
-
-    internal byte UnpackVersion { get; private set; }
-
-    internal byte Method { get; private set; }
-
-    internal byte AvVersion { get; private set; }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/ArchiveCryptHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/ArchiveCryptHeader.cs
@@ -1,50 +1,59 @@
-#nullable disable
+#nullable disable

 using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class ArchiveCryptHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    private const int CRYPT_VERSION = 0; // Supported encryption version.
-    private const int SIZE_SALT50 = 16;
-    private const int SIZE_PSWCHECK = 8;
-    private const int SIZE_PSWCHECK_CSUM = 4;
-    private const int CRYPT5_KDF_LG2_COUNT_MAX = 24; // LOG2 of maximum accepted iteration count.
-
-    private bool _usePswCheck;
-    private uint _lg2Count; // Log2 of PBKDF2 repetition count.
-    private byte[] _salt;
-    private byte[] _pswCheck;
-    private byte[] _pswCheckCsm;
-
-    public ArchiveCryptHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.Crypt) { }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    internal class ArchiveCryptHeader : RarHeader
    {
-        var cryptVersion = reader.ReadRarVIntUInt32();
-        if (cryptVersion > CRYPT_VERSION)
-        {
-            //error?
-            return;
-        }
-        var encryptionFlags = reader.ReadRarVIntUInt32();
-        _usePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
-        _lg2Count = reader.ReadRarVIntByte(1);

-        //UsePswCheck = HasHeaderFlag(EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
-        if (_lg2Count > CRYPT5_KDF_LG2_COUNT_MAX)
+        private const int CRYPT_VERSION = 0; // Supported encryption version.
+        private const int SIZE_SALT50 = 16;
+        private const int SIZE_SALT30 = 8;
+        private const int SIZE_INITV = 16;
+        private const int SIZE_PSWCHECK = 8;
+        private const int SIZE_PSWCHECK_CSUM = 4;
+        private const int CRYPT5_KDF_LG2_COUNT = 15; // LOG2 of PDKDF2 iteration count.
+        private const int CRYPT5_KDF_LG2_COUNT_MAX = 24; // LOG2 of maximum accepted iteration count.
+
+
+        private bool _usePswCheck;
+        private uint _lg2Count; // Log2 of PBKDF2 repetition count.
+        private byte[] _salt;
+        private byte[] _pswCheck;
+        private byte[] _pswCheckCsm;
+
+        public ArchiveCryptHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.Crypt)
        {
-            //error?
-            return;
        }

-        _salt = reader.ReadBytes(SIZE_SALT50);
-        if (_usePswCheck)
+        protected override void ReadFinish(MarkingBinaryReader reader)
        {
-            _pswCheck = reader.ReadBytes(SIZE_PSWCHECK);
-            _pswCheckCsm = reader.ReadBytes(SIZE_PSWCHECK_CSUM);
+            var cryptVersion = reader.ReadRarVIntUInt32();
+            if (cryptVersion > CRYPT_VERSION)
+            {
+                //error?
+                return;
+            }
+            var encryptionFlags = reader.ReadRarVIntUInt32();
+            _usePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
+            _lg2Count = reader.ReadRarVIntByte(1);
+
+
+            //UsePswCheck = HasHeaderFlag(EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
+            if (_lg2Count > CRYPT5_KDF_LG2_COUNT_MAX)
+            {
+                //error?
+                return;
+            }
+
+            _salt = reader.ReadBytes(SIZE_SALT50);
+            if (_usePswCheck)
+            {
+                _pswCheck = reader.ReadBytes(SIZE_PSWCHECK);
+                _pswCheckCsm = reader.ReadBytes(SIZE_PSWCHECK_CSUM);
+            }
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/ArchiveHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/ArchiveHeader.cs
@@ -1,59 +1,88 @@
 using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal sealed class ArchiveHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.Archive) { }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    internal sealed class ArchiveHeader : RarHeader
    {
-        if (IsRar5)
+        public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.Archive)
        {
-            Flags = reader.ReadRarVIntUInt16();
-            if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
-            {
-                VolumeNumber = (int)reader.ReadRarVIntUInt32();
-            }
-            // later: we may have a locator record if we need it
-            //if (ExtraSize != 0) {
-            //    ReadLocator(reader);
-            //}
        }
-        else
+
+        protected override void ReadFinish(MarkingBinaryReader reader)
        {
-            Flags = HeaderFlags;
-            HighPosAv = reader.ReadInt16();
-            PosAv = reader.ReadInt32();
-            if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
+            if (IsRar5)
            {
-                EncryptionVersion = reader.ReadByte();
+                Flags = reader.ReadRarVIntUInt16();
+                if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
+                {
+                    VolumeNumber = (int)reader.ReadRarVIntUInt32();
+                }
+                // later: we may have a locator record if we need it
+                //if (ExtraSize != 0) {
+                //    ReadLocator(reader);
+                //}
+            }
+            else
+            {
+                Flags = HeaderFlags;
+                HighPosAv = reader.ReadInt16();
+                PosAv = reader.ReadInt32();
+                if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
+                {
+                    EncryptionVersion = reader.ReadByte();
+                }
            }
        }
+
+        private void ReadLocator(MarkingBinaryReader reader)
+        {
+            var size = reader.ReadRarVIntUInt16();
+            var type = reader.ReadRarVIntUInt16();
+            if (type != 1)
+            {
+                throw new InvalidFormatException("expected locator record");
+            }
+
+            var flags = reader.ReadRarVIntUInt16();
+            const ushort hasQuickOpenOffset = 0x01;
+            const ushort hasRecoveryOffset = 0x02;
+            ulong quickOpenOffset = 0;
+            if ((flags & hasQuickOpenOffset) == hasQuickOpenOffset)
+            {
+                quickOpenOffset = reader.ReadRarVInt();
+            }
+            ulong recoveryOffset = 0;
+            if ((flags & hasRecoveryOffset) == hasRecoveryOffset)
+            {
+                recoveryOffset = reader.ReadRarVInt();
+            }
+        }
+
+        private ushort Flags { get; set; }
+
+        private bool HasFlag(ushort flag)
+        {
+            return (Flags & flag) == flag;
+        }
+
+        internal int? VolumeNumber { get; private set; }
+
+        internal short? HighPosAv { get; private set; }
+
+        internal int? PosAv { get; private set; }
+
+        private byte? EncryptionVersion { get; set; }
+
+        public bool? IsEncrypted => IsRar5 ? (bool?)null : HasFlag(ArchiveFlagsV4.PASSWORD);
+
+        public bool OldNumberingFormat => !IsRar5 && !HasFlag(ArchiveFlagsV4.NEW_NUMBERING);
+
+        public bool IsVolume => HasFlag(IsRar5 ? ArchiveFlagsV5.VOLUME : ArchiveFlagsV4.VOLUME);
+
+        // RAR5: Volume number field is present. True for all volumes except first.
+        public bool IsFirstVolume => IsRar5 ? VolumeNumber is null : HasFlag(ArchiveFlagsV4.FIRST_VOLUME);
+
+        public bool IsSolid => HasFlag(IsRar5 ? ArchiveFlagsV5.SOLID : ArchiveFlagsV4.SOLID);
    }
-
-    private ushort Flags { get; set; }
-
-    private bool HasFlag(ushort flag) => (Flags & flag) == flag;
-
-    internal int? VolumeNumber { get; private set; }
-
-    internal short? HighPosAv { get; private set; }
-
-    internal int? PosAv { get; private set; }
-
-    private byte? EncryptionVersion { get; set; }
-
-    public bool? IsEncrypted => IsRar5 ? null : HasFlag(ArchiveFlagsV4.PASSWORD);
-
-    public bool OldNumberingFormat => !IsRar5 && !HasFlag(ArchiveFlagsV4.NEW_NUMBERING);
-
-    public bool IsVolume => HasFlag(IsRar5 ? ArchiveFlagsV5.VOLUME : ArchiveFlagsV4.VOLUME);
-
-    // RAR5: Volume number field is present. True for all volumes except first.
-    public bool IsFirstVolume =>
-        IsRar5 ? VolumeNumber is null : HasFlag(ArchiveFlagsV4.FIRST_VOLUME);
-
-    public bool IsSolid => HasFlag(IsRar5 ? ArchiveFlagsV5.SOLID : ArchiveFlagsV4.SOLID);
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/CommentHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/CommentHeader.cs
@@ -1,30 +1,31 @@
-using SharpCompress.IO;
+using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class CommentHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    protected CommentHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.Comment)
+    internal class CommentHeader : RarHeader
    {
-        if (IsRar5)
+        protected CommentHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.Comment)
        {
-            throw new InvalidFormatException("unexpected rar5 record");
+            if (IsRar5)
+            {
+                throw new InvalidFormatException("unexpected rar5 record");
+            }
        }
+
+        protected override void ReadFinish(MarkingBinaryReader reader)
+        {
+            UnpSize = reader.ReadInt16();
+            UnpVersion = reader.ReadByte();
+            UnpMethod = reader.ReadByte();
+            CommCrc = reader.ReadInt16();
+        }
+
+        internal short UnpSize { get; private set; }
+
+        internal byte UnpVersion { get; private set; }
+
+        internal byte UnpMethod { get; private set; }
+        internal short CommCrc { get; private set; }
    }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
-    {
-        UnpSize = reader.ReadInt16();
-        UnpVersion = reader.ReadByte();
-        UnpMethod = reader.ReadByte();
-        CommCrc = reader.ReadInt16();
-    }
-
-    internal short UnpSize { get; private set; }
-
-    internal byte UnpVersion { get; private set; }
-
-    internal byte UnpMethod { get; private set; }
-    internal short CommCrc { get; private set; }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/EndArchiveHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/EndArchiveHeader.cs
@@ -1,37 +1,43 @@
 using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class EndArchiveHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.EndArchive) { }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    internal class EndArchiveHeader : RarHeader
    {
-        if (IsRar5)
+        public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.EndArchive)
        {
-            Flags = reader.ReadRarVIntUInt16();
        }
-        else
+
+        protected override void ReadFinish(MarkingBinaryReader reader)
        {
-            Flags = HeaderFlags;
-            if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
+            if (IsRar5)
            {
-                ArchiveCrc = reader.ReadInt32();
+                Flags = reader.ReadRarVIntUInt16();
            }
-            if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
+            else
            {
-                VolumeNumber = reader.ReadInt16();
+                Flags = HeaderFlags;
+                if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
+                {
+                    ArchiveCrc = reader.ReadInt32();
+                }
+                if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
+                {
+                    VolumeNumber = reader.ReadInt16();
+                }
            }
        }
+
+        private ushort Flags { get; set; }
+
+        private bool HasFlag(ushort flag)
+        {
+            return (Flags & flag) == flag;
+        }
+
+        internal int? ArchiveCrc { get; private set; }
+
+        internal short? VolumeNumber { get; private set; }
    }
-
-    private ushort Flags { get; set; }
-
-    private bool HasFlag(ushort flag) => (Flags & flag) == flag;
-
-    internal int? ArchiveCrc { get; private set; }
-
-    internal short? VolumeNumber { get; private set; }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
@@ -1,6 +1,8 @@
 #nullable disable

 #if !Rar2017_64bit
+using nint = System.Int32;
+using nuint = System.UInt32;
 using size_t = System.UInt32;
 #else
 using nint = System.Int64;
@@ -13,451 +15,442 @@ using System;
 using System.IO;
 using System.Text;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class FileHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    private uint _fileCrc;
-
-    public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
-        : base(header, reader, headerType) { }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    internal class FileHeader : RarHeader
    {
-        if (IsRar5)
+        private uint _fileCrc;
+
+        public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
+            : base(header, reader, headerType)
        {
-            ReadFromReaderV5(reader);
-        }
-        else
-        {
-            ReadFromReaderV4(reader);
-        }
-    }
-
-    private void ReadFromReaderV5(MarkingBinaryReader reader)
-    {
-        Flags = reader.ReadRarVIntUInt16();
-
-        var lvalue = checked((long)reader.ReadRarVInt());
-
-        // long.MaxValue causes the unpack code to finish when the input stream is exhausted
-        UncompressedSize = HasFlag(FileFlagsV5.UNPACKED_SIZE_UNKNOWN) ? long.MaxValue : lvalue;
-
-        FileAttributes = reader.ReadRarVIntUInt32();
-
-        if (HasFlag(FileFlagsV5.HAS_MOD_TIME))
-        {
-            FileLastModifiedTime = Utility.UnixTimeToDateTime(reader.ReadUInt32());
        }

-        if (HasFlag(FileFlagsV5.HAS_CRC32))
+        protected override void ReadFinish(MarkingBinaryReader reader)
        {
-            FileCrc = reader.ReadUInt32();
-        }
-
-        var compressionInfo = reader.ReadRarVIntUInt16();
-
-        // Lower 6 bits (0x003f mask) contain the version of compression algorithm, resulting in possible 0 - 63 values. Current version is 0.
-        // "+ 50" to not mix with old RAR format algorithms. For example,
-        // we may need to use the compression algorithm 15 in the future,
-        // but it was already used in RAR 1.5 and Unpack needs to distinguish
-        // them.
-        CompressionAlgorithm = (byte)((compressionInfo & 0x3f) + 50);
-
-        // 7th bit (0x0040) defines the solid flag. If it is set, RAR continues to use the compression dictionary left after processing preceding files.
-        // It can be set only for file headers and is never set for service headers.
-        IsSolid = (compressionInfo & 0x40) == 0x40;
-
-        // Bits 8 - 10 (0x0380 mask) define the compression method. Currently only values 0 - 5 are used. 0 means no compression.
-        CompressionMethod = (byte)((compressionInfo >> 7) & 0x7);
-
-        // Bits 11 - 14 (0x3c00) define the minimum size of dictionary size required to extract data. Value 0 means 128 KB, 1 - 256 KB, ..., 14 - 2048 MB, 15 - 4096 MB.
-        WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo >> 10) & 0xf);
-
-        HostOs = reader.ReadRarVIntByte();
-
-        var nameSize = reader.ReadRarVIntUInt16();
-
-        // Variable length field containing Name length bytes in UTF-8 format without trailing zero.
-        // For file header this is a name of archived file. Forward slash character is used as the path separator both for Unix and Windows names.
-        // Backslashes are treated as a part of name for Unix names and as invalid character for Windows file names. Type of name is defined by Host OS field.
-        //
-        // TODO: not sure if anything needs to be done to handle the following:
-        // If Unix file name contains any high ASCII characters which cannot be correctly converted to Unicode and UTF-8
-        // we map such characters to to 0xE080 - 0xE0FF private use Unicode area and insert 0xFFFE Unicode non-character
-        // to resulting string to indicate that it contains mapped characters, which need to be converted back when extracting.
-        // Concrete position of 0xFFFE is not defined, we need to search the entire string for it. Such mapped names are not
-        // portable and can be correctly unpacked only on the same system where they were created.
-        //
-        // For service header this field contains a name of service header. Now the following names are used:
-        // CMT	Archive comment
-        // QO	Archive quick open data
-        // ACL	NTFS file permissions
-        // STM	NTFS alternate data stream
-        // RR	Recovery record
-        var b = reader.ReadBytes(nameSize);
-        FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
-
-        // extra size seems to be redudant since we know the total header size
-        if (ExtraSize != RemainingHeaderBytes(reader))
-        {
-            throw new InvalidFormatException("rar5 header size / extra size inconsistency");
-        }
-
-        isEncryptedRar5 = false;
-
-        while (RemainingHeaderBytes(reader) > 0)
-        {
-            var size = reader.ReadRarVIntUInt16();
-            var n = RemainingHeaderBytes(reader);
-            var type = reader.ReadRarVIntUInt16();
-            switch (type)
+            if (IsRar5)
            {
-                //TODO
-                case 1: // file encryption
-
-                    {
-                        isEncryptedRar5 = true;
-
-                        //var version = reader.ReadRarVIntByte();
-                        //if (version != 0) throw new InvalidFormatException("unknown encryption algorithm " + version);
-                    }
-                    break;
-                //                    case 2: // file hash
-                //                        {
-                //
-                //                        }
-                //                        break;
-                case 3: // file time
-
-                    {
-                        var flags = reader.ReadRarVIntUInt16();
-                        var isWindowsTime = (flags & 1) == 0;
-                        if ((flags & 0x2) == 0x2)
-                        {
-                            FileLastModifiedTime = ReadExtendedTimeV5(reader, isWindowsTime);
-                        }
-                        if ((flags & 0x4) == 0x4)
-                        {
-                            FileCreatedTime = ReadExtendedTimeV5(reader, isWindowsTime);
-                        }
-                        if ((flags & 0x8) == 0x8)
-                        {
-                            FileLastAccessedTime = ReadExtendedTimeV5(reader, isWindowsTime);
-                        }
-                    }
-                    break;
-                //TODO
-                //                    case 4: // file version
-                //                        {
-                //
-                //                        }
-                //                        break;
-                //                    case 5: // file system redirection
-                //                        {
-                //
-                //                        }
-                //                        break;
-                //                    case 6: // unix owner
-                //                        {
-                //
-                //                        }
-                //                        break;
-                //                    case 7: // service data
-                //                        {
-                //
-                //                        }
-                //                        break;
-
-                default:
-                    // skip unknown record types to allow new record types to be added in the future
-                    break;
+                ReadFromReaderV5(reader);
            }
-            // drain any trailing bytes of extra record
-            var did = n - RemainingHeaderBytes(reader);
-            var drain = size - did;
-            if (drain > 0)
+            else
            {
-                reader.ReadBytes(drain);
+                ReadFromReaderV4(reader);
            }
        }

-        if (AdditionalDataSize != 0)
+        private void ReadFromReaderV5(MarkingBinaryReader reader)
        {
-            CompressedSize = AdditionalDataSize;
-        }
-    }
+            Flags = reader.ReadRarVIntUInt16();

-    private static DateTime ReadExtendedTimeV5(MarkingBinaryReader reader, bool isWindowsTime)
-    {
-        if (isWindowsTime)
-        {
-            return DateTime.FromFileTime(reader.ReadInt64());
-        }
-        else
-        {
-            return Utility.UnixTimeToDateTime(reader.ReadUInt32());
-        }
-    }
+            var lvalue = checked((long)reader.ReadRarVInt());

-    private static string ConvertPathV5(string path)
-    {
-        if (Path.DirectorySeparatorChar == '\\')
-        {
-            // replace embedded \\ with valid filename char
-            return path.Replace('\\', '-').Replace('/', '\\');
-        }
-        return path;
-    }
+            // long.MaxValue causes the unpack code to finish when the input stream is exhausted
+            UncompressedSize = HasFlag(FileFlagsV5.UNPACKED_SIZE_UNKNOWN) ? long.MaxValue : lvalue;

-    private void ReadFromReaderV4(MarkingBinaryReader reader)
-    {
-        Flags = HeaderFlags;
-        IsSolid = HasFlag(FileFlagsV4.SOLID);
-        WindowSize = IsDirectory
-            ? 0U
-            : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);
+            FileAttributes = reader.ReadRarVIntUInt32();

-        var lowUncompressedSize = reader.ReadUInt32();
-
-        HostOs = reader.ReadByte();
-
-        FileCrc = reader.ReadUInt32();
-
-        FileLastModifiedTime = Utility.DosDateToDateTime(reader.ReadUInt32());
-
-        CompressionAlgorithm = reader.ReadByte();
-        CompressionMethod = (byte)(reader.ReadByte() - 0x30);
-
-        var nameSize = reader.ReadInt16();
-
-        FileAttributes = reader.ReadUInt32();
-
-        uint highCompressedSize = 0;
-        uint highUncompressedkSize = 0;
-        if (HasFlag(FileFlagsV4.LARGE))
-        {
-            highCompressedSize = reader.ReadUInt32();
-            highUncompressedkSize = reader.ReadUInt32();
-        }
-        else
-        {
-            if (lowUncompressedSize == 0xffffffff)
+            if (HasFlag(FileFlagsV5.HAS_MOD_TIME))
            {
-                lowUncompressedSize = 0xffffffff;
-                highUncompressedkSize = int.MaxValue;
+                FileLastModifiedTime = Utility.UnixTimeToDateTime(reader.ReadUInt32());
            }
-        }
-        CompressedSize = UInt32To64(highCompressedSize, checked((uint)AdditionalDataSize));
-        UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);

-        nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
+            if (HasFlag(FileFlagsV5.HAS_CRC32))
+            {
+                FileCrc = reader.ReadUInt32();
+            }

-        var fileNameBytes = reader.ReadBytes(nameSize);
+            var compressionInfo = reader.ReadRarVIntUInt16();

-        const int saltSize = 8;
-        const int newLhdSize = 32;
+            // Lower 6 bits (0x003f mask) contain the version of compression algorithm, resulting in possible 0 - 63 values. Current version is 0.
+            // "+ 50" to not mix with old RAR format algorithms. For example,
+            // we may need to use the compression algorithm 15 in the future,
+            // but it was already used in RAR 1.5 and Unpack needs to distinguish
+            // them.
+            CompressionAlgorithm = (byte)((compressionInfo & 0x3f) + 50);

-        switch (HeaderCode)
-        {
-            case HeaderCodeV.RAR4_FILE_HEADER:
+            // 7th bit (0x0040) defines the solid flag. If it is set, RAR continues to use the compression dictionary left after processing preceding files. 
+            // It can be set only for file headers and is never set for service headers.
+            IsSolid = (compressionInfo & 0x40) == 0x40;

+            // Bits 8 - 10 (0x0380 mask) define the compression method. Currently only values 0 - 5 are used. 0 means no compression.
+            CompressionMethod = (byte)((compressionInfo >> 7) & 0x7);
+
+            // Bits 11 - 14 (0x3c00) define the minimum size of dictionary size required to extract data. Value 0 means 128 KB, 1 - 256 KB, ..., 14 - 2048 MB, 15 - 4096 MB.
+            WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo >> 10) & 0xf);
+
+            HostOs = reader.ReadRarVIntByte();
+
+            var nameSize = reader.ReadRarVIntUInt16();
+
+            // Variable length field containing Name length bytes in UTF-8 format without trailing zero.
+            // For file header this is a name of archived file. Forward slash character is used as the path separator both for Unix and Windows names.
+            // Backslashes are treated as a part of name for Unix names and as invalid character for Windows file names. Type of name is defined by Host OS field.
+            //
+            // TODO: not sure if anything needs to be done to handle the following:
+            // If Unix file name contains any high ASCII characters which cannot be correctly converted to Unicode and UTF-8
+            // we map such characters to to 0xE080 - 0xE0FF private use Unicode area and insert 0xFFFE Unicode non-character
+            // to resulting string to indicate that it contains mapped characters, which need to be converted back when extracting. 
+            // Concrete position of 0xFFFE is not defined, we need to search the entire string for it. Such mapped names are not
+            // portable and can be correctly unpacked only on the same system where they were created.
+            //
+            // For service header this field contains a name of service header. Now the following names are used:
+            // CMT	Archive comment
+            // QO	Archive quick open data
+            // ACL	NTFS file permissions
+            // STM	NTFS alternate data stream
+            // RR	Recovery record
+            var b = reader.ReadBytes(nameSize);
+            FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
+
+            // extra size seems to be redudant since we know the total header size
+            if (ExtraSize != RemainingHeaderBytes(reader))
+            {
+                throw new InvalidFormatException("rar5 header size / extra size inconsistency");
+            }
+
+            isEncryptedRar5 = false;
+
+            while (RemainingHeaderBytes(reader) > 0)
+            {
+                var size = reader.ReadRarVIntUInt16();
+                int n = RemainingHeaderBytes(reader);
+                var type = reader.ReadRarVIntUInt16();
+                switch (type)
                {
-                    if (HasFlag(FileFlagsV4.UNICODE))
-                    {
-                        var length = 0;
-                        while (length < fileNameBytes.Length && fileNameBytes[length] != 0)
+                    //TODO
+                    case 1: // file encryption
                        {
-                            length++;
+                            isEncryptedRar5 = true;
+
+                            //var version = reader.ReadRarVIntByte();
+                            //if (version != 0) throw new InvalidFormatException("unknown encryption algorithm " + version);
                        }
-                        if (length != nameSize)
+                        break;
+                    //                    case 2: // file hash
+                    //                        {
+                    //
+                    //                        }
+                    //                        break;
+                    case 3: // file time
                        {
-                            length++;
-                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
+                            ushort flags = reader.ReadRarVIntUInt16();
+                            var isWindowsTime = (flags & 1) == 0;
+                            if ((flags & 0x2) == 0x2)
+                            {
+                                FileLastModifiedTime = ReadExtendedTimeV5(reader, isWindowsTime);
+                            }
+                            if ((flags & 0x4) == 0x4)
+                            {
+                                FileCreatedTime = ReadExtendedTimeV5(reader, isWindowsTime);
+                            }
+                            if ((flags & 0x8) == 0x8)
+                            {
+                                FileLastAccessedTime = ReadExtendedTimeV5(reader, isWindowsTime);
+                            }
+                        }
+                        break;
+                    //TODO
+                    //                    case 4: // file version
+                    //                        {
+                    //
+                    //                        }
+                    //                        break;
+                    //                    case 5: // file system redirection
+                    //                        {
+                    //
+                    //                        }
+                    //                        break;
+                    //                    case 6: // unix owner
+                    //                        {
+                    //
+                    //                        }
+                    //                        break;
+                    //                    case 7: // service data
+                    //                        {
+                    //
+                    //                        }
+                    //                        break;
+
+                    default:
+                        // skip unknown record types to allow new record types to be added in the future
+                        break;
+                }
+                // drain any trailing bytes of extra record
+                int did = n - RemainingHeaderBytes(reader);
+                int drain = size - did;
+                if (drain > 0)
+                {
+                    reader.ReadBytes(drain);
+                }
+            }
+
+            if (AdditionalDataSize != 0)
+            {
+                CompressedSize = AdditionalDataSize;
+            }
+        }
+
+
+        private static DateTime ReadExtendedTimeV5(MarkingBinaryReader reader, bool isWindowsTime)
+        {
+            if (isWindowsTime)
+            {
+                return DateTime.FromFileTime(reader.ReadInt64());
+            }
+            else
+            {
+                return Utility.UnixTimeToDateTime(reader.ReadUInt32());
+            }
+        }
+
+        private static string ConvertPathV5(string path)
+        {
+            if (Path.DirectorySeparatorChar == '\\')
+            {
+                // replace embedded \\ with valid filename char
+                return path.Replace('\\', '-').Replace('/', '\\');
+            }
+            return path;
+        }
+
+
+        private void ReadFromReaderV4(MarkingBinaryReader reader)
+        {
+            Flags = HeaderFlags;
+            IsSolid = HasFlag(FileFlagsV4.SOLID);
+            WindowSize = IsDirectory ? 0U : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);
+
+            uint lowUncompressedSize = reader.ReadUInt32();
+
+            HostOs = reader.ReadByte();
+
+            FileCrc = reader.ReadUInt32();
+
+            FileLastModifiedTime = Utility.DosDateToDateTime(reader.ReadUInt32());
+
+            CompressionAlgorithm = reader.ReadByte();
+            CompressionMethod = (byte)(reader.ReadByte() - 0x30);
+
+            short nameSize = reader.ReadInt16();
+
+            FileAttributes = reader.ReadUInt32();
+
+            uint highCompressedSize = 0;
+            uint highUncompressedkSize = 0;
+            if (HasFlag(FileFlagsV4.LARGE))
+            {
+                highCompressedSize = reader.ReadUInt32();
+                highUncompressedkSize = reader.ReadUInt32();
+            }
+            else
+            {
+                if (lowUncompressedSize == 0xffffffff)
+                {
+                    lowUncompressedSize = 0xffffffff;
+                    highUncompressedkSize = int.MaxValue;
+                }
+            }
+            CompressedSize = UInt32To64(highCompressedSize, checked((uint)AdditionalDataSize));
+            UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
+
+            nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
+
+            byte[] fileNameBytes = reader.ReadBytes(nameSize);
+
+            const int saltSize = 8;
+            const int newLhdSize = 32;
+
+            switch (HeaderCode)
+            {
+                case HeaderCodeV.RAR4_FILE_HEADER:
+                    {
+                        if (HasFlag(FileFlagsV4.UNICODE))
+                        {
+                            int length = 0;
+                            while (length < fileNameBytes.Length
+                                   && fileNameBytes[length] != 0)
+                            {
+                                length++;
+                            }
+                            if (length != nameSize)
+                            {
+                                length++;
+                                FileName = FileNameDecoder.Decode(fileNameBytes, length);
+                            }
+                            else
+                            {
+                                FileName = ArchiveEncoding.Decode(fileNameBytes);
+                            }
                        }
                        else
                        {
                            FileName = ArchiveEncoding.Decode(fileNameBytes);
                        }
+                        FileName = ConvertPathV4(FileName);
                    }
-                    else
+                    break;
+                case HeaderCodeV.RAR4_NEW_SUB_HEADER:
                    {
-                        FileName = ArchiveEncoding.Decode(fileNameBytes);
-                    }
-                    FileName = ConvertPathV4(FileName);
-                }
-                break;
-            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+                        int datasize = HeaderSize - newLhdSize - nameSize;
+                        if (HasFlag(FileFlagsV4.SALT))
+                        {
+                            datasize -= saltSize;
+                        }
+                        if (datasize > 0)
+                        {
+                            SubData = reader.ReadBytes(datasize);
+                        }

+                        if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
+                        {
+                            RecoverySectors = SubData[8] + (SubData[9] << 8)
+                                              + (SubData[10] << 16) + (SubData[11] << 24);
+                        }
+                    }
+                    break;
+            }
+
+            if (HasFlag(FileFlagsV4.SALT))
+            {
+                R4Salt = reader.ReadBytes(saltSize);
+            }
+            if (HasFlag(FileFlagsV4.EXT_TIME))
+            {
+                // verify that the end of the header hasn't been reached before reading the Extended Time.
+                //  some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate.
+                if (RemainingHeaderBytes(reader) >= 2)
                {
-                    var datasize = HeaderSize - newLhdSize - nameSize;
-                    if (HasFlag(FileFlagsV4.SALT))
-                    {
-                        datasize -= saltSize;
-                    }
-                    if (datasize > 0)
-                    {
-                        SubData = reader.ReadBytes(datasize);
-                    }
-
-                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
-                    {
-                        RecoverySectors =
-                            SubData[8]
-                            + (SubData[9] << 8)
-                            + (SubData[10] << 16)
-                            + (SubData[11] << 24);
-                    }
+                    ushort extendedFlags = reader.ReadUInt16();
+                    FileLastModifiedTime = ProcessExtendedTimeV4(extendedFlags, FileLastModifiedTime, reader, 0);
+                    FileCreatedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
+                    FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
+                    FileArchivedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
                }
-                break;
-        }
-
-        if (HasFlag(FileFlagsV4.SALT))
-        {
-            R4Salt = reader.ReadBytes(saltSize);
-        }
-        if (HasFlag(FileFlagsV4.EXT_TIME))
-        {
-            // verify that the end of the header hasn't been reached before reading the Extended Time.
-            //  some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate.
-            if (RemainingHeaderBytes(reader) >= 2)
-            {
-                var extendedFlags = reader.ReadUInt16();
-                FileLastModifiedTime = ProcessExtendedTimeV4(
-                    extendedFlags,
-                    FileLastModifiedTime,
-                    reader,
-                    0
-                );
-                FileCreatedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 1);
-                FileLastAccessedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 2);
-                FileArchivedTime = ProcessExtendedTimeV4(extendedFlags, null, reader, 3);
            }
        }
-    }

-    private static long UInt32To64(uint x, uint y)
-    {
-        long l = x;
-        l <<= 32;
-        return l + y;
-    }
-
-    private static DateTime? ProcessExtendedTimeV4(
-        ushort extendedFlags,
-        DateTime? time,
-        MarkingBinaryReader reader,
-        int i
-    )
-    {
-        var rmode = (uint)extendedFlags >> ((3 - i) * 4);
-        if ((rmode & 8) == 0)
+        private static long UInt32To64(uint x, uint y)
        {
-            return null;
-        }
-        if (i != 0)
-        {
-            var dosTime = reader.ReadUInt32();
-            time = Utility.DosDateToDateTime(dosTime);
-        }
-        if ((rmode & 4) == 0)
-        {
-            time = time.Value.AddSeconds(1);
-        }
-        uint nanosecondHundreds = 0;
-        var count = (int)rmode & 3;
-        for (var j = 0; j < count; j++)
-        {
-            var b = reader.ReadByte();
-            nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
+            long l = x;
+            l <<= 32;
+            return l + y;
        }

-        //10^-7 to 10^-3
-        return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
-    }
-
-    private static string ConvertPathV4(string path)
-    {
-        if (Path.DirectorySeparatorChar == '/')
+        private static DateTime? ProcessExtendedTimeV4(ushort extendedFlags, DateTime? time, MarkingBinaryReader reader, int i)
        {
-            return path.Replace('\\', '/');
-        }
-        else if (Path.DirectorySeparatorChar == '\\')
-        {
-            return path.Replace('/', '\\');
-        }
-        return path;
-    }
-
-    public override string ToString() => FileName;
-
-    private ushort Flags { get; set; }
-
-    private bool HasFlag(ushort flag) => (Flags & flag) == flag;
-
-    internal uint FileCrc
-    {
-        get
-        {
-            if (IsRar5 && !HasFlag(FileFlagsV5.HAS_CRC32))
+            uint rmode = (uint)extendedFlags >> (3 - i) * 4;
+            if ((rmode & 8) == 0)
            {
-                //!!! rar5:
-                throw new InvalidOperationException("TODO rar5");
+                return null;
            }
-            return _fileCrc;
+            if (i != 0)
+            {
+                uint dosTime = reader.ReadUInt32();
+                time = Utility.DosDateToDateTime(dosTime);
+            }
+            if ((rmode & 4) == 0)
+            {
+                time = time.Value.AddSeconds(1);
+            }
+            uint nanosecondHundreds = 0;
+            int count = (int)rmode & 3;
+            for (int j = 0; j < count; j++)
+            {
+                byte b = reader.ReadByte();
+                nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
+            }
+
+            //10^-7 to 10^-3
+            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
        }
-        private set => _fileCrc = value;
+
+        private static string ConvertPathV4(string path)
+        {
+            if (Path.DirectorySeparatorChar == '/')
+            {
+                return path.Replace('\\', '/');
+            }
+            else if (Path.DirectorySeparatorChar == '\\')
+            {
+                return path.Replace('/', '\\');
+            }
+            return path;
+        }
+
+        public override string ToString()
+        {
+            return FileName;
+        }
+
+        private ushort Flags { get; set; }
+
+        private bool HasFlag(ushort flag)
+        {
+            return (Flags & flag) == flag;
+        }
+
+        internal uint FileCrc
+        {
+            get
+            {
+                if (IsRar5 && !HasFlag(FileFlagsV5.HAS_CRC32))
+                {
+                    //!!! rar5: 
+                    throw new InvalidOperationException("TODO rar5");
+                }
+                return _fileCrc;
+            }
+            private set => _fileCrc = value;
+        }
+
+        // 0 - storing
+        // 1 - fastest compression
+        // 2 - fast compression
+        // 3 - normal compression
+        // 4 - good compression
+        // 5 - best compression
+        internal byte CompressionMethod { get; private set; }
+        internal bool IsStored => CompressionMethod == 0;
+
+        // eg (see DoUnpack())
+        //case 15: // rar 1.5 compression
+        //case 20: // rar 2.x compression
+        //case 26: // files larger than 2GB
+        //case 29: // rar 3.x compression
+        //case 50: // RAR 5.0 compression algorithm.
+        internal byte CompressionAlgorithm { get; private set; }
+
+        public bool IsSolid { get; private set; }
+
+        // unused for UnpackV1 implementation (limitation)
+        internal size_t WindowSize { get; private set; }
+
+        internal byte[] R4Salt { 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 int RecoverySectors { get; private set; }
+        internal long DataStartPosition { get; set; }
+        public Stream PackedStream { get; set; }
+
+        public bool IsSplitBefore => IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_BEFORE) : HasFlag(FileFlagsV4.SPLIT_BEFORE);
+        public bool IsSplitAfter => IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_AFTER) : HasFlag(FileFlagsV4.SPLIT_AFTER);
+
+        public bool IsDirectory => HasFlag(IsRar5 ? FileFlagsV5.DIRECTORY : FileFlagsV4.DIRECTORY);
+
+        private bool isEncryptedRar5 = false;
+        public bool IsEncrypted => IsRar5 ? isEncryptedRar5 : HasFlag(FileFlagsV4.PASSWORD);
+
+        internal DateTime? FileLastModifiedTime { get; private set; }
+
+        internal DateTime? FileCreatedTime { get; private set; }
+
+        internal DateTime? FileLastAccessedTime { get; private set; }
+
+        internal DateTime? FileArchivedTime { get; private set; }
    }
-
-    // 0 - storing
-    // 1 - fastest compression
-    // 2 - fast compression
-    // 3 - normal compression
-    // 4 - good compression
-    // 5 - best compression
-    internal byte CompressionMethod { get; private set; }
-    internal bool IsStored => CompressionMethod == 0;
-
-    // eg (see DoUnpack())
-    //case 15: // rar 1.5 compression
-    //case 20: // rar 2.x compression
-    //case 26: // files larger than 2GB
-    //case 29: // rar 3.x compression
-    //case 50: // RAR 5.0 compression algorithm.
-    internal byte CompressionAlgorithm { get; private set; }
-
-    public bool IsSolid { get; private set; }
-
-    // unused for UnpackV1 implementation (limitation)
-    internal size_t WindowSize { get; private set; }
-
-    internal byte[] R4Salt { 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 int RecoverySectors { get; private set; }
-    internal long DataStartPosition { get; set; }
-    public Stream PackedStream { get; set; }
-
-    public bool IsSplitBefore =>
-        IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_BEFORE) : HasFlag(FileFlagsV4.SPLIT_BEFORE);
-    public bool IsSplitAfter =>
-        IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_AFTER) : HasFlag(FileFlagsV4.SPLIT_AFTER);
-
-    public bool IsDirectory => HasFlag(IsRar5 ? FileFlagsV5.DIRECTORY : FileFlagsV4.DIRECTORY);
-
-    private bool isEncryptedRar5 = false;
-    public bool IsEncrypted => IsRar5 ? isEncryptedRar5 : HasFlag(FileFlagsV4.PASSWORD);
-
-    internal DateTime? FileLastModifiedTime { get; private set; }
-
-    internal DateTime? FileCreatedTime { get; private set; }
-
-    internal DateTime? FileLastAccessedTime { get; private set; }
-
-    internal DateTime? FileArchivedTime { get; private set; }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/FileNameDecoder.cs
+++ b/src/SharpCompress/Common/Rar/Headers/FileNameDecoder.cs
@@ -1,78 +1,78 @@
 using System.Text;

-namespace SharpCompress.Common.Rar.Headers;
-
-/// <summary>
-/// This is for the crazy Rar encoding that I don't understand
-/// </summary>
-internal static class FileNameDecoder
+namespace SharpCompress.Common.Rar.Headers
 {
-    internal static int GetChar(byte[] name, int pos) => name[pos] & 0xff;
-
-    internal static string Decode(byte[] name, int encPos)
+    /// <summary>
+    /// This is for the crazy Rar encoding that I don't understand
+    /// </summary>
+    internal static class FileNameDecoder
    {
-        var decPos = 0;
-        var flags = 0;
-        var flagBits = 0;
-
-        var low = 0;
-        var high = 0;
-        var highByte = GetChar(name, encPos++);
-        var buf = new StringBuilder();
-        while (encPos < name.Length)
+        internal static int GetChar(byte[] name, int pos)
        {
-            if (flagBits == 0)
-            {
-                flags = GetChar(name, encPos++);
-                flagBits = 8;
-            }
-            switch (flags >> 6)
-            {
-                case 0:
-                    buf.Append((char)(GetChar(name, encPos++)));
-                    ++decPos;
-                    break;
-
-                case 1:
-                    buf.Append((char)(GetChar(name, encPos++) + (highByte << 8)));
-                    ++decPos;
-                    break;
-
-                case 2:
-                    low = GetChar(name, encPos);
-                    high = GetChar(name, encPos + 1);
-                    buf.Append((char)((high << 8) + low));
-                    ++decPos;
-                    encPos += 2;
-                    break;
-
-                case 3:
-                    var length = GetChar(name, encPos++);
-                    if ((length & 0x80) != 0)
-                    {
-                        var correction = GetChar(name, encPos++);
-                        for (
-                            length = (length & 0x7f) + 2;
-                            length > 0 && decPos < name.Length;
-                            length--, decPos++
-                        )
-                        {
-                            low = (GetChar(name, decPos) + correction) & 0xff;
-                            buf.Append((char)((highByte << 8) + low));
-                        }
-                    }
-                    else
-                    {
-                        for (length += 2; length > 0 && decPos < name.Length; length--, decPos++)
-                        {
-                            buf.Append((char)(GetChar(name, decPos)));
-                        }
-                    }
-                    break;
-            }
-            flags = (flags << 2) & 0xff;
-            flagBits -= 2;
+            return name[pos] & 0xff;
+        }
+
+        internal static string Decode(byte[] name, int encPos)
+        {
+            int decPos = 0;
+            int flags = 0;
+            int flagBits = 0;
+
+            int low = 0;
+            int high = 0;
+            int highByte = GetChar(name, encPos++);
+            StringBuilder buf = new StringBuilder();
+            while (encPos < name.Length)
+            {
+                if (flagBits == 0)
+                {
+                    flags = GetChar(name, encPos++);
+                    flagBits = 8;
+                }
+                switch (flags >> 6)
+                {
+                    case 0:
+                        buf.Append((char)(GetChar(name, encPos++)));
+                        ++decPos;
+                        break;
+
+                    case 1:
+                        buf.Append((char)(GetChar(name, encPos++) + (highByte << 8)));
+                        ++decPos;
+                        break;
+
+                    case 2:
+                        low = GetChar(name, encPos);
+                        high = GetChar(name, encPos + 1);
+                        buf.Append((char)((high << 8) + low));
+                        ++decPos;
+                        encPos += 2;
+                        break;
+
+                    case 3:
+                        int length = GetChar(name, encPos++);
+                        if ((length & 0x80) != 0)
+                        {
+                            int correction = GetChar(name, encPos++);
+                            for (length = (length & 0x7f) + 2; length > 0 && decPos < name.Length; length--, decPos++)
+                            {
+                                low = (GetChar(name, decPos) + correction) & 0xff;
+                                buf.Append((char)((highByte << 8) + low));
+                            }
+                        }
+                        else
+                        {
+                            for (length += 2; length > 0 && decPos < name.Length; length--, decPos++)
+                            {
+                                buf.Append((char)(GetChar(name, decPos)));
+                            }
+                        }
+                        break;
+                }
+                flags = (flags << 2) & 0xff;
+                flagBits -= 2;
+            }
+            return buf.ToString();
        }
-        return buf.ToString();
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/Flags.cs
+++ b/src/SharpCompress/Common/Rar/Headers/Flags.cs
@@ -1,148 +1,149 @@
-namespace SharpCompress.Common.Rar.Headers;
-
-public enum HeaderType : byte
+namespace SharpCompress.Common.Rar.Headers
 {
-    Null,
-    Mark,
-    Archive,
-    File,
-    Service,
-    Comment,
-    Av,
-    Protect,
-    Sign,
-    NewSub,
-    EndArchive,
-    Crypt
-}
+    internal enum HeaderType : byte
+    {
+        Null,
+        Mark,
+        Archive,
+        File,
+        Service,
+        Comment,
+        Av,
+        Protect,
+        Sign,
+        NewSub,
+        EndArchive,
+        Crypt
+    }

-internal static class HeaderCodeV
-{
-    public const byte RAR4_MARK_HEADER = 0x72;
-    public const byte RAR4_ARCHIVE_HEADER = 0x73;
-    public const byte RAR4_FILE_HEADER = 0x74;
-    public const byte RAR4_COMMENT_HEADER = 0x75;
-    public const byte RAR4_AV_HEADER = 0x76;
-    public const byte RAR4_SUB_HEADER = 0x77;
-    public const byte RAR4_PROTECT_HEADER = 0x78;
-    public const byte RAR4_SIGN_HEADER = 0x79;
-    public const byte RAR4_NEW_SUB_HEADER = 0x7a;
-    public const byte RAR4_END_ARCHIVE_HEADER = 0x7b;
+    internal static class HeaderCodeV
+    {
+        public const byte RAR4_MARK_HEADER = 0x72;
+        public const byte RAR4_ARCHIVE_HEADER = 0x73;
+        public const byte RAR4_FILE_HEADER = 0x74;
+        public const byte RAR4_COMMENT_HEADER = 0x75;
+        public const byte RAR4_AV_HEADER = 0x76;
+        public const byte RAR4_SUB_HEADER = 0x77;
+        public const byte RAR4_PROTECT_HEADER = 0x78;
+        public const byte RAR4_SIGN_HEADER = 0x79;
+        public const byte RAR4_NEW_SUB_HEADER = 0x7a;
+        public const byte RAR4_END_ARCHIVE_HEADER = 0x7b;

-    public const byte RAR5_ARCHIVE_HEADER = 0x01;
-    public const byte RAR5_FILE_HEADER = 0x02;
-    public const byte RAR5_SERVICE_HEADER = 0x03;
-    public const byte RAR5_ARCHIVE_ENCRYPTION_HEADER = 0x04;
-    public const byte RAR5_END_ARCHIVE_HEADER = 0x05;
-}
+        public const byte RAR5_ARCHIVE_HEADER = 0x01;
+        public const byte RAR5_FILE_HEADER = 0x02;
+        public const byte RAR5_SERVICE_HEADER = 0x03;
+        public const byte RAR5_ARCHIVE_ENCRYPTION_HEADER = 0x04;
+        public const byte RAR5_END_ARCHIVE_HEADER = 0x05;
+    }

-internal static class HeaderFlagsV4
-{
-    public const ushort HAS_DATA = 0x8000;
-}
+    internal static class HeaderFlagsV4
+    {
+        public const ushort HAS_DATA = 0x8000;
+    }

-internal static class EncryptionFlagsV5
-{
-    // RAR 5.0 archive encryption header specific flags.
-    public const uint CHFL_CRYPT_PSWCHECK = 0x01; // Password check data is present.
+    internal static class EncryptionFlagsV5
+    {
+        // RAR 5.0 archive encryption header specific flags.
+        public const uint CHFL_CRYPT_PSWCHECK = 0x01; // Password check data is present.

-    public const uint FHEXTRA_CRYPT_PSWCHECK = 0x01; // Password check data is present.
-    public const uint FHEXTRA_CRYPT_HASHMAC = 0x02;
-}
+        public const uint FHEXTRA_CRYPT_PSWCHECK = 0x01; // Password check data is present.
+        public const uint FHEXTRA_CRYPT_HASHMAC = 0x02;
+    }

-internal static class HeaderFlagsV5
-{
-    public const ushort HAS_EXTRA = 0x0001;
-    public const ushort HAS_DATA = 0x0002;
-    public const ushort KEEP = 0x0004; // block must be kept during an update
-    public const ushort SPLIT_BEFORE = 0x0008;
-    public const ushort SPLIT_AFTER = 0x0010;
-    public const ushort CHILD = 0x0020; // ??? Block depends on preceding file block.
-    public const ushort PRESERVE_CHILD = 0x0040; // ???? Preserve a child block if host block is modified
-}
+    internal static class HeaderFlagsV5
+    {
+        public const ushort HAS_EXTRA = 0x0001;
+        public const ushort HAS_DATA = 0x0002;
+        public const ushort KEEP = 0x0004;  // block must be kept during an update
+        public const ushort SPLIT_BEFORE = 0x0008;
+        public const ushort SPLIT_AFTER = 0x0010;
+        public const ushort CHILD = 0x0020; // ??? Block depends on preceding file block.
+        public const ushort PRESERVE_CHILD = 0x0040; // ???? Preserve a child block if host block is modified
+    }

-internal static class ArchiveFlagsV4
-{
-    public const ushort VOLUME = 0x0001;
-    public const ushort COMMENT = 0x0002;
-    public const ushort LOCK = 0x0004;
-    public const ushort SOLID = 0x0008;
-    public const ushort NEW_NUMBERING = 0x0010;
-    public const ushort AV = 0x0020;
-    public const ushort PROTECT = 0x0040;
-    public const ushort PASSWORD = 0x0080;
-    public const ushort FIRST_VOLUME = 0x0100;
-    public const ushort ENCRYPT_VER = 0x0200;
-}
+    internal static class ArchiveFlagsV4
+    {
+        public const ushort VOLUME = 0x0001;
+        public const ushort COMMENT = 0x0002;
+        public const ushort LOCK = 0x0004;
+        public const ushort SOLID = 0x0008;
+        public const ushort NEW_NUMBERING = 0x0010;
+        public const ushort AV = 0x0020;
+        public const ushort PROTECT = 0x0040;
+        public const ushort PASSWORD = 0x0080;
+        public const ushort FIRST_VOLUME = 0x0100;
+        public const ushort ENCRYPT_VER = 0x0200;
+    }

-internal static class ArchiveFlagsV5
-{
-    public const ushort VOLUME = 0x0001;
-    public const ushort HAS_VOLUME_NUMBER = 0x0002;
-    public const ushort SOLID = 0x0004;
-    public const ushort PROTECT = 0x0008;
-    public const ushort LOCK = 0x0010;
-}
+    internal static class ArchiveFlagsV5
+    {
+        public const ushort VOLUME = 0x0001;
+        public const ushort HAS_VOLUME_NUMBER = 0x0002;
+        public const ushort SOLID = 0x0004;
+        public const ushort PROTECT = 0x0008;
+        public const ushort LOCK = 0x0010;
+    }

-internal static class HostOsV4
-{
-    public const byte MS_DOS = 0;
-    public const byte OS2 = 1;
-    public const byte WIN32 = 2;
-    public const byte UNIX = 3;
-    public const byte MAC_OS = 4;
-    public const byte BE_OS = 5;
-}
+    internal static class HostOsV4
+    {
+        public const byte MS_DOS = 0;
+        public const byte OS2 = 1;
+        public const byte WIN32 = 2;
+        public const byte UNIX = 3;
+        public const byte MAC_OS = 4;
+        public const byte BE_OS = 5;
+    }

-internal static class HostOsV5
-{
-    public const byte WINDOWS = 0;
-    public const byte UNIX = 1;
-}
+    internal static class HostOsV5
+    {
+        public const byte WINDOWS = 0;
+        public const byte UNIX = 1;
+    }

-internal static class FileFlagsV4
-{
-    public const ushort SPLIT_BEFORE = 0x0001;
-    public const ushort SPLIT_AFTER = 0x0002;
-    public const ushort PASSWORD = 0x0004;
-    public const ushort COMMENT = 0x0008;
-    public const ushort SOLID = 0x0010;
+    internal static class FileFlagsV4
+    {
+        public const ushort SPLIT_BEFORE = 0x0001;
+        public const ushort SPLIT_AFTER = 0x0002;
+        public const ushort PASSWORD = 0x0004;
+        public const ushort COMMENT = 0x0008;
+        public const ushort SOLID = 0x0010;

-    public const ushort WINDOW_MASK = 0x00e0;
-    public const ushort WINDOW64 = 0x0000;
-    public const ushort WINDOW128 = 0x0020;
-    public const ushort WINDOW256 = 0x0040;
-    public const ushort WINDOW512 = 0x0060;
-    public const ushort WINDOW1024 = 0x0080;
-    public const ushort WINDOW2048 = 0x00a0;
-    public const ushort WINDOW4096 = 0x00c0;
-    public const ushort DIRECTORY = 0x00e0;
+        public const ushort WINDOW_MASK = 0x00e0;
+        public const ushort WINDOW64 = 0x0000;
+        public const ushort WINDOW128 = 0x0020;
+        public const ushort WINDOW256 = 0x0040;
+        public const ushort WINDOW512 = 0x0060;
+        public const ushort WINDOW1024 = 0x0080;
+        public const ushort WINDOW2048 = 0x00a0;
+        public const ushort WINDOW4096 = 0x00c0;
+        public const ushort DIRECTORY = 0x00e0;

-    public const ushort LARGE = 0x0100;
-    public const ushort UNICODE = 0x0200;
-    public const ushort SALT = 0x0400;
-    public const ushort VERSION = 0x0800;
-    public const ushort EXT_TIME = 0x1000;
-    public const ushort EXT_FLAGS = 0x2000;
-}
+        public const ushort LARGE = 0x0100;
+        public const ushort UNICODE = 0x0200;
+        public const ushort SALT = 0x0400;
+        public const ushort VERSION = 0x0800;
+        public const ushort EXT_TIME = 0x1000;
+        public const ushort EXT_FLAGS = 0x2000;
+    }

-internal static class FileFlagsV5
-{
-    public const ushort DIRECTORY = 0x0001;
-    public const ushort HAS_MOD_TIME = 0x0002;
-    public const ushort HAS_CRC32 = 0x0004;
-    public const ushort UNPACKED_SIZE_UNKNOWN = 0x0008;
-}
+    internal static class FileFlagsV5
+    {
+        public const ushort DIRECTORY = 0x0001;
+        public const ushort HAS_MOD_TIME = 0x0002;
+        public const ushort HAS_CRC32 = 0x0004;
+        public const ushort UNPACKED_SIZE_UNKNOWN = 0x0008;
+    }

-internal static class EndArchiveFlagsV4
-{
-    public const ushort NEXT_VOLUME = 0x0001;
-    public const ushort DATA_CRC = 0x0002;
-    public const ushort REV_SPACE = 0x0004;
-    public const ushort VOLUME_NUMBER = 0x0008;
-}
+    internal static class EndArchiveFlagsV4
+    {
+        public const ushort NEXT_VOLUME = 0x0001;
+        public const ushort DATA_CRC = 0x0002;
+        public const ushort REV_SPACE = 0x0004;
+        public const ushort VOLUME_NUMBER = 0x0008;
+    }

-internal static class EndArchiveFlagsV5
-{
-    public const ushort HAS_NEXT_VOLUME = 0x0001;
-}
+    internal static class EndArchiveFlagsV5
+    {
+        public const ushort HAS_NEXT_VOLUME = 0x0001;
+    }
+}
--- a/src/SharpCompress/Common/Rar/Headers/IRarHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/IRarHeader.cs
@@ -1,6 +1,7 @@
-namespace SharpCompress.Common.Rar.Headers;
-
-public interface IRarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    HeaderType HeaderType { get; }
-}
+    internal interface IRarHeader
+    {
+        HeaderType HeaderType { get; }
+    }
+}
--- a/src/SharpCompress/Common/Rar/Headers/MarkHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/MarkHeader.cs
@@ -1,132 +1,123 @@
 using System;
 using System.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class MarkHeader : IRarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    private const int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136
-
-    internal bool OldNumberingFormat { get; private set; }
-
-    public bool IsRar5 { get; }
-
-    private MarkHeader(bool isRar5) => IsRar5 = isRar5;
-
-    public HeaderType HeaderType => HeaderType.Mark;
-
-    private static byte GetByte(Stream stream)
+    internal class MarkHeader : IRarHeader
    {
-        var b = stream.ReadByte();
-        if (b != -1)
+        private const int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136
+
+        internal bool OldNumberingFormat { get; private set; }
+
+        public bool IsRar5 { get; }
+
+        private MarkHeader(bool isRar5)
        {
-            return (byte)b;
+            IsRar5 = isRar5;
        }
-        throw new EndOfStreamException();
-    }

-    public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
-    {
-        var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
-        try
+        public HeaderType HeaderType => HeaderType.Mark;
+
+        private static byte GetByte(Stream stream)
        {
-            var start = -1;
-            var b = GetByte(stream);
-            start++;
-            while (start <= maxScanIndex)
+            var b = stream.ReadByte();
+            if (b != -1)
            {
-                // Rar old signature: 52 45 7E 5E
-                // Rar4 signature:    52 61 72 21 1A 07 00
-                // Rar5 signature:    52 61 72 21 1A 07 01 00
-                if (b == 0x52)
+                return (byte)b;
+            }
+            throw new EndOfStreamException();
+        }
+
+        public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
+        {
+            int maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
+            try
+            {
+                int start = -1;
+                var b = GetByte(stream); start++;
+                while (start <= maxScanIndex)
                {
-                    b = GetByte(stream);
-                    start++;
-                    if (b == 0x61)
+                    // Rar old signature: 52 45 7E 5E
+                    // Rar4 signature:    52 61 72 21 1A 07 00
+                    // Rar5 signature:    52 61 72 21 1A 07 01 00
+                    if (b == 0x52)
                    {
-                        b = GetByte(stream);
-                        start++;
-                        if (b != 0x72)
+                        b = GetByte(stream); start++;
+                        if (b == 0x61)
                        {
-                            continue;
-                        }
-
-                        b = GetByte(stream);
-                        start++;
-                        if (b != 0x21)
-                        {
-                            continue;
-                        }
-
-                        b = GetByte(stream);
-                        start++;
-                        if (b != 0x1a)
-                        {
-                            continue;
-                        }
-
-                        b = GetByte(stream);
-                        start++;
-                        if (b != 0x07)
-                        {
-                            continue;
-                        }
-
-                        b = GetByte(stream);
-                        start++;
-                        if (b == 1)
-                        {
-                            b = GetByte(stream);
-                            start++;
-                            if (b != 0)
+                            b = GetByte(stream); start++;
+                            if (b != 0x72)
                            {
                                continue;
                            }

-                            return new MarkHeader(true); // Rar5
+                            b = GetByte(stream); start++;
+                            if (b != 0x21)
+                            {
+                                continue;
+                            }
+
+                            b = GetByte(stream); start++;
+                            if (b != 0x1a)
+                            {
+                                continue;
+                            }
+
+                            b = GetByte(stream); start++;
+                            if (b != 0x07)
+                            {
+                                continue;
+                            }
+
+                            b = GetByte(stream); start++;
+                            if (b == 1)
+                            {
+                                b = GetByte(stream); start++;
+                                if (b != 0)
+                                {
+                                    continue;
+                                }
+
+                                return new MarkHeader(true); // Rar5
+                            }
+                            else if (b == 0)
+                            {
+                                return new MarkHeader(false); // Rar4
+                            }
                        }
-                        else if (b == 0)
+                        else if (b == 0x45)
                        {
-                            return new MarkHeader(false); // Rar4
+                            b = GetByte(stream); start++;
+                            if (b != 0x7e)
+                            {
+                                continue;
+                            }
+
+                            b = GetByte(stream); start++;
+                            if (b != 0x5e)
+                            {
+                                continue;
+                            }
+
+                            throw new InvalidFormatException("Rar format version pre-4 is unsupported.");
                        }
                    }
-                    else if (b == 0x45)
+                    else
                    {
-                        b = GetByte(stream);
-                        start++;
-                        if (b != 0x7e)
-                        {
-                            continue;
-                        }
-
-                        b = GetByte(stream);
-                        start++;
-                        if (b != 0x5e)
-                        {
-                            continue;
-                        }
-
-                        throw new InvalidFormatException(
-                            "Rar format version pre-4 is unsupported."
-                        );
+                        b = GetByte(stream); start++;
                    }
                }
-                else
-                {
-                    b = GetByte(stream);
-                    start++;
-                }
            }
-        }
-        catch (Exception e)
-        {
-            if (!leaveStreamOpen)
+            catch (Exception e)
            {
-                stream.Dispose();
+                if (!leaveStreamOpen)
+                {
+                    stream.Dispose();
+                }
+                throw new InvalidFormatException("Error trying to read rar signature.", e);
            }
-            throw new InvalidFormatException("Error trying to read rar signature.", e);
-        }

-        throw new InvalidFormatException("Rar signature not found");
+            throw new InvalidFormatException("Rar signature not found");
+        }
    }
 }
--- a/src/SharpCompress/Common/Rar/Headers/NewSubHeaderType.cs
+++ b/src/SharpCompress/Common/Rar/Headers/NewSubHeaderType.cs
@@ -1,45 +1,49 @@
 using System;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal sealed class NewSubHeaderType : IEquatable<NewSubHeaderType>
+namespace SharpCompress.Common.Rar.Headers
 {
-    internal static readonly NewSubHeaderType SUBHEAD_TYPE_CMT = new('C', 'M', 'T');
-
-    //internal static final NewSubHeaderType SUBHEAD_TYPE_ACL = new (new byte[]{'A','C','L'});
-
-    //internal static final NewSubHeaderType SUBHEAD_TYPE_STREAM = new (new byte[]{'S','T','M'});
-
-    //internal static final NewSubHeaderType SUBHEAD_TYPE_UOWNER = new (new byte[]{'U','O','W'});
-
-    //internal static final NewSubHeaderType SUBHEAD_TYPE_AV = new (new byte[]{'A','V'});
-
-    internal static readonly NewSubHeaderType SUBHEAD_TYPE_RR = new('R', 'R');
-
-    //internal static final NewSubHeaderType SUBHEAD_TYPE_OS2EA = new (new byte[]{'E','A','2'});
-
-    //internal static final NewSubHeaderType SUBHEAD_TYPE_BEOSEA = new (new byte[]{'E','A','B','E'});
-
-    private readonly byte[] _bytes;
-
-    private NewSubHeaderType(params char[] chars)
+    internal sealed class NewSubHeaderType : IEquatable<NewSubHeaderType>
    {
-        _bytes = new byte[chars.Length];
-        for (var i = 0; i < chars.Length; ++i)
-        {
-            _bytes[i] = (byte)chars[i];
-        }
-    }
+        internal static readonly NewSubHeaderType SUBHEAD_TYPE_CMT = new('C', 'M', 'T');

-    internal bool Equals(byte[] bytes)
-    {
-        if (_bytes.Length != bytes.Length)
+        //internal static final NewSubHeaderType SUBHEAD_TYPE_ACL = new (new byte[]{'A','C','L'});
+
+        //internal static final NewSubHeaderType SUBHEAD_TYPE_STREAM = new (new byte[]{'S','T','M'});
+
+        //internal static final NewSubHeaderType SUBHEAD_TYPE_UOWNER = new (new byte[]{'U','O','W'});
+
+        //internal static final NewSubHeaderType SUBHEAD_TYPE_AV = new (new byte[]{'A','V'});
+
+        internal static readonly NewSubHeaderType SUBHEAD_TYPE_RR = new('R', 'R');
+
+        //internal static final NewSubHeaderType SUBHEAD_TYPE_OS2EA = new (new byte[]{'E','A','2'});
+
+        //internal static final NewSubHeaderType SUBHEAD_TYPE_BEOSEA = new (new byte[]{'E','A','B','E'});
+
+        private readonly byte[] _bytes;
+
+        private NewSubHeaderType(params char[] chars)
        {
-            return false;
+            _bytes = new byte[chars.Length];
+            for (int i = 0; i < chars.Length; ++i)
+            {
+                _bytes[i] = (byte)chars[i];
+            }
        }

-        return _bytes.AsSpan().SequenceEqual(bytes);
-    }
+        internal bool Equals(byte[] bytes)
+        {
+            if (_bytes.Length != bytes.Length)
+            {
+                return false;
+            }

-    public bool Equals(NewSubHeaderType? other) => other is not null && Equals(other._bytes);
-}
+            return _bytes.AsSpan().SequenceEqual(bytes);
+        }
+
+        public bool Equals(NewSubHeaderType? other)
+        {
+            return other is not null && Equals(other._bytes);
+        }
+    }
+}
--- a/src/SharpCompress/Common/Rar/Headers/ProtectHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/ProtectHeader.cs
@@ -1,30 +1,31 @@
-using SharpCompress.IO;
+using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-// ProtectHeader is part of the Recovery Record feature
-internal sealed class ProtectHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    public ProtectHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.Protect)
+    // ProtectHeader is part of the Recovery Record feature
+    internal sealed class ProtectHeader : RarHeader
    {
-        if (IsRar5)
+        public ProtectHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.Protect)
        {
-            throw new InvalidFormatException("unexpected rar5 record");
+            if (IsRar5)
+            {
+                throw new InvalidFormatException("unexpected rar5 record");
+            }
        }
-    }

-    protected override void ReadFinish(MarkingBinaryReader reader)
-    {
-        Version = reader.ReadByte();
-        RecSectors = reader.ReadUInt16();
-        TotalBlocks = reader.ReadUInt32();
-        Mark = reader.ReadBytes(8);
-    }
+        protected override void ReadFinish(MarkingBinaryReader reader)
+        {
+            Version = reader.ReadByte();
+            RecSectors = reader.ReadUInt16();
+            TotalBlocks = reader.ReadUInt32();
+            Mark = reader.ReadBytes(8);
+        }

-    internal uint DataSize => checked((uint)AdditionalDataSize);
-    internal byte Version { get; private set; }
-    internal ushort RecSectors { get; private set; }
-    internal uint TotalBlocks { get; private set; }
-    internal byte[]? Mark { get; private set; }
-}
+        internal uint DataSize => checked((uint)AdditionalDataSize);
+        internal byte Version { get; private set; }
+        internal ushort RecSectors { get; private set; }
+        internal uint TotalBlocks { get; private set; }
+        internal byte[]? Mark { get; private set; }
+    }
+}
--- a/src/SharpCompress/Common/Rar/Headers/RarHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/RarHeader.cs
@@ -2,129 +2,133 @@
 using System.IO;
 using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-// http://www.forensicswiki.org/w/images/5/5b/RARFileStructure.txt
-// https://www.rarlab.com/technote.htm
-internal class RarHeader : IRarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    private readonly HeaderType _headerType;
-    private readonly bool _isRar5;
-
-    internal static RarHeader? TryReadBase(
-        RarCrcBinaryReader reader,
-        bool isRar5,
-        ArchiveEncoding archiveEncoding
-    )
+    // http://www.forensicswiki.org/w/images/5/5b/RARFileStructure.txt
+    // https://www.rarlab.com/technote.htm
+    internal class RarHeader : IRarHeader
    {
-        try
-        {
-            return new RarHeader(reader, isRar5, archiveEncoding);
-        }
-        catch (EndOfStreamException)
-        {
-            return null;
-        }
-    }
+        private readonly HeaderType _headerType;
+        private readonly bool _isRar5;

-    private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
-    {
-        _headerType = HeaderType.Null;
-        _isRar5 = isRar5;
-        ArchiveEncoding = archiveEncoding;
-        if (IsRar5)
+        internal static RarHeader? TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
        {
-            HeaderCrc = reader.ReadUInt32();
-            reader.ResetCrc();
-            HeaderSize = (int)reader.ReadRarVIntUInt32(3);
-            reader.Mark();
-            HeaderCode = reader.ReadRarVIntByte();
-            HeaderFlags = reader.ReadRarVIntUInt16(2);
-
-            if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
+            try
            {
-                ExtraSize = reader.ReadRarVIntUInt32();
+                return new RarHeader(reader, isRar5, archiveEncoding);
            }
-            if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
+            catch (EndOfStreamException)
            {
-                AdditionalDataSize = (long)reader.ReadRarVInt();
+                return null;
            }
        }
-        else
+
+        private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
        {
-            reader.Mark();
-            HeaderCrc = reader.ReadUInt16();
-            reader.ResetCrc();
-            HeaderCode = reader.ReadByte();
-            HeaderFlags = reader.ReadUInt16();
-            HeaderSize = reader.ReadInt16();
-            if (HasHeaderFlag(HeaderFlagsV4.HAS_DATA))
+            _headerType = HeaderType.Null;
+            _isRar5 = isRar5;
+            ArchiveEncoding = archiveEncoding;
+            if (IsRar5)
            {
-                AdditionalDataSize = reader.ReadUInt32();
+                HeaderCrc = reader.ReadUInt32();
+                reader.ResetCrc();
+                HeaderSize = (int)reader.ReadRarVIntUInt32(3);
+                reader.Mark();
+                HeaderCode = reader.ReadRarVIntByte();
+                HeaderFlags = reader.ReadRarVIntUInt16(2);
+
+                if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
+                {
+                    ExtraSize = reader.ReadRarVIntUInt32();
+                }
+                if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
+                {
+                    AdditionalDataSize = (long)reader.ReadRarVInt();
+                }
+            }
+            else
+            {
+                reader.Mark();
+                HeaderCrc = reader.ReadUInt16();
+                reader.ResetCrc();
+                HeaderCode = reader.ReadByte();
+                HeaderFlags = reader.ReadUInt16();
+                HeaderSize = reader.ReadInt16();
+                if (HasHeaderFlag(HeaderFlagsV4.HAS_DATA))
+                {
+                    AdditionalDataSize = reader.ReadUInt32();
+                }
            }
        }
-    }

-    protected RarHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
-    {
-        _headerType = headerType;
-        _isRar5 = header.IsRar5;
-        HeaderCrc = header.HeaderCrc;
-        HeaderCode = header.HeaderCode;
-        HeaderFlags = header.HeaderFlags;
-        HeaderSize = header.HeaderSize;
-        ExtraSize = header.ExtraSize;
-        AdditionalDataSize = header.AdditionalDataSize;
-        ArchiveEncoding = header.ArchiveEncoding;
-        ReadFinish(reader);
-
-        var n = RemainingHeaderBytes(reader);
-        if (n > 0)
+        protected RarHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
        {
-            reader.ReadBytes(n);
+            _headerType = headerType;
+            _isRar5 = header.IsRar5;
+            HeaderCrc = header.HeaderCrc;
+            HeaderCode = header.HeaderCode;
+            HeaderFlags = header.HeaderFlags;
+            HeaderSize = header.HeaderSize;
+            ExtraSize = header.ExtraSize;
+            AdditionalDataSize = header.AdditionalDataSize;
+            ArchiveEncoding = header.ArchiveEncoding;
+            ReadFinish(reader);
+
+            int n = RemainingHeaderBytes(reader);
+            if (n > 0)
+            {
+                reader.ReadBytes(n);
+            }
+
+            VerifyHeaderCrc(reader.GetCrc32());
        }

-        VerifyHeaderCrc(reader.GetCrc32());
-    }
-
-    protected int RemainingHeaderBytes(MarkingBinaryReader reader) =>
-        checked(HeaderSize - (int)reader.CurrentReadByteCount);
-
-    protected virtual void ReadFinish(MarkingBinaryReader reader) =>
-        throw new NotImplementedException();
-
-    private void VerifyHeaderCrc(uint crc32)
-    {
-        var b = (IsRar5 ? crc32 : (ushort)crc32) == HeaderCrc;
-        if (!b)
+        protected int RemainingHeaderBytes(MarkingBinaryReader reader)
        {
-            throw new InvalidFormatException("rar header crc mismatch");
+            return checked(HeaderSize - (int)reader.CurrentReadByteCount);
        }
+
+        protected virtual void ReadFinish(MarkingBinaryReader reader)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void VerifyHeaderCrc(uint crc32)
+        {
+            var b = (IsRar5 ? crc32 : (ushort)crc32) == HeaderCrc;
+            if (!b)
+            {
+                throw new InvalidFormatException("rar header crc mismatch");
+            }
+        }
+
+        public HeaderType HeaderType => _headerType;
+
+        protected bool IsRar5 => _isRar5;
+
+        protected uint HeaderCrc { get; }
+
+        internal byte HeaderCode { get; }
+
+        protected ushort HeaderFlags { get; }
+
+        protected bool HasHeaderFlag(ushort flag)
+        {
+            return (HeaderFlags & flag) == flag;
+        }
+
+        protected int HeaderSize { get; }
+
+        internal ArchiveEncoding ArchiveEncoding { get; }
+
+        /// <summary>
+        /// Extra header size.
+        /// </summary>
+        protected uint ExtraSize { get; }
+
+        /// <summary>
+        /// Size of additional data (eg file contents)
+        /// </summary>
+        protected long AdditionalDataSize { get; }
    }
-
-    public HeaderType HeaderType => _headerType;
-
-    protected bool IsRar5 => _isRar5;
-
-    protected uint HeaderCrc { get; }
-
-    internal byte HeaderCode { get; }
-
-    protected ushort HeaderFlags { get; }
-
-    protected bool HasHeaderFlag(ushort flag) => (HeaderFlags & flag) == flag;
-
-    protected int HeaderSize { get; }
-
-    internal ArchiveEncoding ArchiveEncoding { get; }
-
-    /// <summary>
-    /// Extra header size.
-    /// </summary>
-    protected uint ExtraSize { get; }
-
-    /// <summary>
-    /// Size of additional data (eg file contents)
-    /// </summary>
-    protected long AdditionalDataSize { get; }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
+++ b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
@@ -3,197 +3,186 @@ using System.IO;
 using SharpCompress.IO;
 using SharpCompress.Readers;

-namespace SharpCompress.Common.Rar.Headers;
-
-public class RarHeaderFactory
+namespace SharpCompress.Common.Rar.Headers
 {
-    private bool _isRar5;
-
-    public RarHeaderFactory(StreamingMode mode, ReaderOptions options)
+    internal class RarHeaderFactory
    {
-        StreamingMode = mode;
-        Options = options;
-    }
+        private bool _isRar5;

-    public ReaderOptions Options { get; }
-    public StreamingMode StreamingMode { get; }
-    public bool IsEncrypted { get; private set; }
-
-    public IEnumerable<IRarHeader> ReadHeaders(Stream stream)
-    {
-        var markHeader = MarkHeader.Read(stream, Options.LeaveStreamOpen, Options.LookForHeader);
-        _isRar5 = markHeader.IsRar5;
-        yield return markHeader;
-
-        RarHeader? header;
-        while ((header = TryReadNextHeader(stream)) != null)
+        internal RarHeaderFactory(StreamingMode mode, ReaderOptions options)
        {
-            yield return header;
-            if (header.HeaderType == HeaderType.EndArchive)
+            StreamingMode = mode;
+            Options = options;
+        }
+
+        private ReaderOptions Options { get; }
+        internal StreamingMode StreamingMode { get; }
+        internal bool IsEncrypted { get; private set; }
+
+        internal IEnumerable<IRarHeader> ReadHeaders(Stream stream)
+        {
+            var markHeader = MarkHeader.Read(stream, Options.LeaveStreamOpen, Options.LookForHeader);
+            _isRar5 = markHeader.IsRar5;
+            yield return markHeader;
+
+            RarHeader? header;
+            while ((header = TryReadNextHeader(stream)) != null)
            {
-                // End of archive marker. RAR does not read anything after this header letting to use third
-                // party tools to add extra information such as a digital signature to archive.
-                yield break;
-            }
-        }
-    }
-
-    private RarHeader? TryReadNextHeader(Stream stream)
-    {
-        RarCrcBinaryReader reader;
-        if (!IsEncrypted)
-        {
-            reader = new RarCrcBinaryReader(stream);
-        }
-        else
-        {
-            if (Options.Password is null)
-            {
-                throw new CryptographicException(
-                    "Encrypted Rar archive has no password specified."
-                );
-            }
-            reader = new RarCryptoBinaryReader(stream, Options.Password);
-        }
-
-        var header = RarHeader.TryReadBase(reader, _isRar5, Options.ArchiveEncoding);
-        if (header is null)
-        {
-            return null;
-        }
-        switch (header.HeaderCode)
-        {
-            case HeaderCodeV.RAR5_ARCHIVE_HEADER:
-            case HeaderCodeV.RAR4_ARCHIVE_HEADER:
-            {
-                var ah = new ArchiveHeader(header, reader);
-                if (ah.IsEncrypted == true)
+                yield return header;
+                if (header.HeaderType == HeaderType.EndArchive)
                {
-                    //!!! rar5 we don't know yet
-                    IsEncrypted = true;
+                    // End of archive marker. RAR does not read anything after this header letting to use third
+                    // party tools to add extra information such as a digital signature to archive.
+                    yield break;
                }
-                return ah;
+            }
+        }
+
+        private RarHeader? TryReadNextHeader(Stream stream)
+        {
+            RarCrcBinaryReader reader;
+            if (!IsEncrypted)
+            {
+                reader = new RarCrcBinaryReader(stream);
+            }
+            else
+            {
+                if (Options.Password is null)
+                {
+                    throw new CryptographicException("Encrypted Rar archive has no password specified.");
+                }
+                reader = new RarCryptoBinaryReader(stream, Options.Password);
            }

-            case HeaderCodeV.RAR4_PROTECT_HEADER:
+            var header = RarHeader.TryReadBase(reader, _isRar5, Options.ArchiveEncoding);
+            if (header is null)
            {
-                var ph = new ProtectHeader(header, reader);
-                // skip the recovery record data, we do not use it.
-                switch (StreamingMode)
-                {
-                    case StreamingMode.Seekable:
-
+                return null;
+            }
+            switch (header.HeaderCode)
+            {
+                case HeaderCodeV.RAR5_ARCHIVE_HEADER:
+                case HeaderCodeV.RAR4_ARCHIVE_HEADER:
+                    {
+                        var ah = new ArchiveHeader(header, reader);
+                        if (ah.IsEncrypted == true)
                        {
-                            reader.BaseStream.Position += ph.DataSize;
+                            //!!! rar5 we don't know yet
+                            IsEncrypted = true;
                        }
-                        break;
-                    case StreamingMode.Streaming:
+                        return ah;
+                    }

+                case HeaderCodeV.RAR4_PROTECT_HEADER:
+                    {
+                        var ph = new ProtectHeader(header, reader);
+                        // skip the recovery record data, we do not use it.
+                        switch (StreamingMode)
                        {
-                            reader.BaseStream.Skip(ph.DataSize);
+                            case StreamingMode.Seekable:
+                                {
+                                    reader.BaseStream.Position += ph.DataSize;
+                                }
+                                break;
+                            case StreamingMode.Streaming:
+                                {
+                                    reader.BaseStream.Skip(ph.DataSize);
+                                }
+                                break;
+                            default:
+                                {
+                                    throw new InvalidFormatException("Invalid StreamingMode");
+                                }
                        }
-                        break;
-                    default:
+
+                        return ph;
+                    }
+
+                case HeaderCodeV.RAR5_SERVICE_HEADER:
+                    {
+                        var fh = new FileHeader(header, reader, HeaderType.Service);
+                        SkipData(fh, reader);
+                        return fh;
+                    }
+
+                case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+                    {
+                        var fh = new FileHeader(header, reader, HeaderType.NewSub);
+                        SkipData(fh, reader);
+                        return fh;
+                    }
+
+                case HeaderCodeV.RAR5_FILE_HEADER:
+                case HeaderCodeV.RAR4_FILE_HEADER:
+                    {
+                        var fh = new FileHeader(header, reader, HeaderType.File);
+                        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.PackedStream = ms;
+                                    }
+                                    else
+                                    {
+                                        fh.PackedStream = new RarCryptoWrapper(ms, Options.Password!, fh.R4Salt);
+                                    }
+                                }
+                                break;
+                            default:
+                                {
+                                    throw new InvalidFormatException("Invalid StreamingMode");
+                                }
+                        }
+                        return fh;
+                    }
+                case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
+                case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
+                    {
+                        return new EndArchiveHeader(header, reader);
+                    }
+                case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
+                    {
+                        var ch = new ArchiveCryptHeader(header, reader);
+                        IsEncrypted = true;
+                        return ch;
+                    }
+                default:
+                    {
+                        throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
+                    }
+            }
+        }
+
+        private void SkipData(FileHeader fh, RarCrcBinaryReader reader)
+        {
+            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);
+                    }
+                    break;
+                default:
                    {
                        throw new InvalidFormatException("Invalid StreamingMode");
                    }
-                }
-
-                return ph;
-            }
-
-            case HeaderCodeV.RAR5_SERVICE_HEADER:
-            {
-                var fh = new FileHeader(header, reader, HeaderType.Service);
-                SkipData(fh, reader);
-                return fh;
-            }
-
-            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
-            {
-                var fh = new FileHeader(header, reader, HeaderType.NewSub);
-                SkipData(fh, reader);
-                return fh;
-            }
-
-            case HeaderCodeV.RAR5_FILE_HEADER:
-            case HeaderCodeV.RAR4_FILE_HEADER:
-            {
-                var fh = new FileHeader(header, reader, HeaderType.File);
-                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.PackedStream = ms;
-                            }
-                            else
-                            {
-                                fh.PackedStream = new RarCryptoWrapper(
-                                    ms,
-                                    Options.Password!,
-                                    fh.R4Salt
-                                );
-                            }
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-                return fh;
-            }
-            case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
-            case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
-            {
-                return new EndArchiveHeader(header, reader);
-            }
-            case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
-            {
-                var ch = new ArchiveCryptHeader(header, reader);
-                IsEncrypted = true;
-                return ch;
-            }
-            default:
-            {
-                throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
            }
        }
    }
-
-    private void SkipData(FileHeader fh, RarCrcBinaryReader reader)
-    {
-        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);
-                }
-                break;
-            default:
-            {
-                throw new InvalidFormatException("Invalid StreamingMode");
-            }
-        }
-    }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/SignHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/SignHeader.cs
@@ -1,28 +1,29 @@
-using SharpCompress.IO;
+using SharpCompress.IO;

-namespace SharpCompress.Common.Rar.Headers;
-
-internal class SignHeader : RarHeader
+namespace SharpCompress.Common.Rar.Headers
 {
-    protected SignHeader(RarHeader header, RarCrcBinaryReader reader)
-        : base(header, reader, HeaderType.Sign)
+    internal class SignHeader : RarHeader
    {
-        if (IsRar5)
+        protected SignHeader(RarHeader header, RarCrcBinaryReader reader)
+            : base(header, reader, HeaderType.Sign)
        {
-            throw new InvalidFormatException("unexpected rar5 record");
+            if (IsRar5)
+            {
+                throw new InvalidFormatException("unexpected rar5 record");
+            }
        }
+
+        protected override void ReadFinish(MarkingBinaryReader reader)
+        {
+            CreationTime = reader.ReadInt32();
+            ArcNameSize = reader.ReadInt16();
+            UserNameSize = reader.ReadInt16();
+        }
+
+        internal int CreationTime { get; private set; }
+
+        internal short ArcNameSize { get; private set; }
+
+        internal short UserNameSize { get; private set; }
    }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
-    {
-        CreationTime = reader.ReadInt32();
-        ArcNameSize = reader.ReadInt16();
-        UserNameSize = reader.ReadInt16();
-    }
-
-    internal int CreationTime { get; private set; }
-
-    internal short ArcNameSize { get; private set; }
-
-    internal short UserNameSize { get; private set; }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarCrcBinaryReader.cs
+++ b/src/SharpCompress/Common/Rar/RarCrcBinaryReader.cs
@@ -2,34 +2,49 @@ using System.IO;
 using SharpCompress.Compressors.Rar;
 using SharpCompress.IO;

-namespace SharpCompress.Common.Rar;
-
-internal class RarCrcBinaryReader : MarkingBinaryReader
+namespace SharpCompress.Common.Rar
 {
-    private uint _currentCrc;
-
-    public RarCrcBinaryReader(Stream stream)
-        : base(stream) { }
-
-    public uint GetCrc32() => ~_currentCrc;
-
-    public void ResetCrc() => _currentCrc = 0xffffffff;
-
-    protected void UpdateCrc(byte b) => _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
-
-    protected byte[] ReadBytesNoCrc(int count) => base.ReadBytes(count);
-
-    public override byte ReadByte()
+    internal class RarCrcBinaryReader : MarkingBinaryReader
    {
-        var b = base.ReadByte();
-        _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
-        return b;
-    }
+        private uint _currentCrc;

-    public override byte[] ReadBytes(int count)
-    {
-        var result = base.ReadBytes(count);
-        _currentCrc = RarCRC.CheckCrc(_currentCrc, result, 0, result.Length);
-        return result;
+        public RarCrcBinaryReader(Stream stream)
+            : base(stream)
+        {
+        }
+
+        public uint GetCrc32()
+        {
+            return ~_currentCrc;
+        }
+
+        public void ResetCrc()
+        {
+            _currentCrc = 0xffffffff;
+        }
+
+        protected void UpdateCrc(byte b)
+        {
+            _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
+        }
+
+        protected byte[] ReadBytesNoCrc(int count)
+        {
+            return base.ReadBytes(count);
+        }
+
+        public override byte ReadByte()
+        {
+            var b = base.ReadByte();
+            _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
+            return b;
+        }
+
+        public override byte[] ReadBytes(int count)
+        {
+            var result = base.ReadBytes(count);
+            _currentCrc = RarCRC.CheckCrc(_currentCrc, result, 0, result.Length);
+            return result;
+        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs
@@ -1,104 +1,111 @@
 using System.Collections.Generic;
 using System.IO;

-namespace SharpCompress.Common.Rar;
-
-internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
+namespace SharpCompress.Common.Rar
 {
-    private RarRijndael _rijndael;
-    private byte[] _salt;
-    private readonly string _password;
-    private readonly Queue<byte> _data = new Queue<byte>();
-    private long _readCount;
-
-    public RarCryptoBinaryReader(Stream stream, string password)
-        : base(stream)
+    internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
    {
-        _password = password;
+        private RarRijndael _rijndael;
+        private byte[] _salt;
+        private readonly string _password;
+        private readonly Queue<byte> _data = new Queue<byte>();
+        private long _readCount;

-        // coderb: not sure why this was being done at this logical point
-        //SkipQueue();
-        var salt = ReadBytes(8);
-
-        _salt = salt;
-        _rijndael = RarRijndael.InitializeFrom(_password, salt);
-    }
-
-    // track read count ourselves rather than using the underlying stream since we buffer
-    public override long CurrentReadByteCount
-    {
-        get => _readCount;
-        protected set
+        public RarCryptoBinaryReader(Stream stream, string password)
+            : base(stream)
        {
-            // ignore
-        }
-    }
+            _password = password;

-    public override void Mark() => _readCount = 0;
+            // coderb: not sure why this was being done at this logical point
+            //SkipQueue();
+            byte[] salt = ReadBytes(8);

-    private bool UseEncryption => _salt != null;
-
-    public override byte ReadByte()
-    {
-        if (UseEncryption)
-        {
-            return ReadAndDecryptBytes(1)[0];
+            _salt = salt;
+            _rijndael = RarRijndael.InitializeFrom(_password, salt);
        }

-        _readCount++;
-        return base.ReadByte();
-    }
-
-    public override byte[] ReadBytes(int count)
-    {
-        if (UseEncryption)
+        // track read count ourselves rather than using the underlying stream since we buffer
+        public override long CurrentReadByteCount
        {
-            return ReadAndDecryptBytes(count);
-        }
-
-        _readCount += count;
-        return base.ReadBytes(count);
-    }
-
-    private byte[] ReadAndDecryptBytes(int count)
-    {
-        var queueSize = _data.Count;
-        var sizeToRead = count - queueSize;
-
-        if (sizeToRead > 0)
-        {
-            var alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
-            for (var i = 0; i < alignedSize / 16; i++)
+            get => _readCount;
+            protected set
            {
-                //long ax = System.currentTimeMillis();
-                var cipherText = ReadBytesNoCrc(16);
-                var readBytes = _rijndael.ProcessBlock(cipherText);
-                foreach (var readByte in readBytes)
-                {
-                    _data.Enqueue(readByte);
-                }
+                // ignore
            }
        }

-        var decryptedBytes = new byte[count];
-
-        for (var i = 0; i < count; i++)
+        public override void Mark()
        {
-            var b = _data.Dequeue();
-            decryptedBytes[i] = b;
-            UpdateCrc(b);
+            _readCount = 0;
        }

-        _readCount += count;
-        return decryptedBytes;
-    }
+        private bool UseEncryption => _salt != null;

-    public void ClearQueue() => _data.Clear();
+        public override byte ReadByte()
+        {
+            if (UseEncryption)
+            {
+                return ReadAndDecryptBytes(1)[0];
+            }

-    public void SkipQueue()
-    {
-        var position = BaseStream.Position;
-        BaseStream.Position = position + _data.Count;
-        ClearQueue();
+            _readCount++;
+            return base.ReadByte();
+        }
+
+        public override byte[] ReadBytes(int count)
+        {
+            if (UseEncryption)
+            {
+                return ReadAndDecryptBytes(count);
+            }
+
+            _readCount += count;
+            return base.ReadBytes(count);
+        }
+
+        private byte[] ReadAndDecryptBytes(int count)
+        {
+            int queueSize = _data.Count;
+            int sizeToRead = count - queueSize;
+
+            if (sizeToRead > 0)
+            {
+                int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
+                for (int i = 0; i < alignedSize / 16; i++)
+                {
+                    //long ax = System.currentTimeMillis();
+                    byte[] cipherText = ReadBytesNoCrc(16);
+                    var readBytes = _rijndael.ProcessBlock(cipherText);
+                    foreach (var readByte in readBytes)
+                    {
+                        _data.Enqueue(readByte);
+                    }
+                }
+            }
+
+            var decryptedBytes = new byte[count];
+
+            for (int i = 0; i < count; i++)
+            {
+                var b = _data.Dequeue();
+                decryptedBytes[i] = b;
+                UpdateCrc(b);
+            }
+
+            _readCount += count;
+            return decryptedBytes;
+        }
+
+        public void ClearQueue()
+        {
+            _data.Clear();
+        }
+
+        public void SkipQueue()
+        {
+            var position = BaseStream.Position;
+            BaseStream.Position = position + _data.Count;
+            ClearQueue();
+        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
@@ -2,86 +2,98 @@ using System;
 using System.Collections.Generic;
 using System.IO;

-namespace SharpCompress.Common.Rar;
-
-internal sealed class RarCryptoWrapper : Stream
+namespace SharpCompress.Common.Rar
 {
-    private readonly Stream _actualStream;
-    private readonly byte[] _salt;
-    private RarRijndael _rijndael;
-    private readonly Queue<byte> _data = new Queue<byte>();
-
-    public RarCryptoWrapper(Stream actualStream, string password, byte[] salt)
+    internal sealed class RarCryptoWrapper : Stream
    {
-        _actualStream = actualStream;
-        _salt = salt;
-        _rijndael = RarRijndael.InitializeFrom(password ?? "", salt);
-    }
+        private readonly Stream _actualStream;
+        private readonly byte[] _salt;
+        private RarRijndael _rijndael;
+        private readonly Queue<byte> _data = new Queue<byte>();

-    public override void Flush() => throw new NotSupportedException();
-
-    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
-
-    public override void SetLength(long value) => throw new NotSupportedException();
-
-    public override int Read(byte[] buffer, int offset, int count)
-    {
-        if (_salt is null)
+        public RarCryptoWrapper(Stream actualStream, string password, byte[] salt)
        {
-            return _actualStream.Read(buffer, offset, count);
+            _actualStream = actualStream;
+            _salt = salt;
+            _rijndael = RarRijndael.InitializeFrom(password, salt);
        }
-        return ReadAndDecrypt(buffer, offset, count);
-    }

-    public int ReadAndDecrypt(byte[] buffer, int offset, int count)
-    {
-        var queueSize = _data.Count;
-        var sizeToRead = count - queueSize;
-
-        if (sizeToRead > 0)
+        public override void Flush()
        {
-            var alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
-            Span<byte> cipherText = stackalloc byte[RarRijndael.CRYPTO_BLOCK_SIZE];
-            for (var i = 0; i < alignedSize / 16; i++)
-            {
-                //long ax = System.currentTimeMillis();
-                _actualStream.Read(cipherText);
+            throw new NotSupportedException();
+        }

-                var readBytes = _rijndael.ProcessBlock(cipherText);
-                foreach (var readByte in readBytes)
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (_salt is null)
+            {
+                return _actualStream.Read(buffer, offset, count);
+            }
+            return ReadAndDecrypt(buffer, offset, count);
+        }
+
+        public int ReadAndDecrypt(byte[] buffer, int offset, int count)
+        {
+            int queueSize = _data.Count;
+            int sizeToRead = count - queueSize;
+
+            if (sizeToRead > 0)
+            {
+                int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
+                Span<byte> cipherText = stackalloc byte[RarRijndael.CRYPTO_BLOCK_SIZE];
+                for (int i = 0; i < alignedSize / 16; i++)
                {
-                    _data.Enqueue(readByte);
+                    //long ax = System.currentTimeMillis();
+                    _actualStream.Read(cipherText);
+
+                    var readBytes = _rijndael.ProcessBlock(cipherText);
+                    foreach (var readByte in readBytes)
+                    {
+                        _data.Enqueue(readByte);
+                    }
+                }
+
+                for (int i = 0; i < count; i++)
+                {
+                    buffer[offset + i] = _data.Dequeue();
                }
            }
-
-            for (var i = 0; i < count; i++)
-            {
-                buffer[offset + i] = _data.Dequeue();
-            }
+            return count;
        }
-        return count;
-    }

-    public override void Write(byte[] buffer, int offset, int count) =>
-        throw new NotSupportedException();
-
-    public override bool CanRead => true;
-
-    public override bool CanSeek => false;
-
-    public override bool CanWrite => false;
-
-    public override long Length => throw new NotSupportedException();
-
-    public override long Position { get; set; }
-
-    protected override void Dispose(bool disposing)
-    {
-        if (_rijndael != null)
+        public override void Write(byte[] buffer, int offset, int count)
        {
-            _rijndael.Dispose();
-            _rijndael = null!;
+            throw new NotSupportedException();
+        }
+
+        public override bool CanRead => true;
+
+        public override bool CanSeek => false;
+
+        public override bool CanWrite => false;
+
+        public override long Length => throw new NotSupportedException();
+
+        public override long Position { get; set; }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (_rijndael != null)
+            {
+                _rijndael.Dispose();
+                _rijndael = null!;
+            }
+            base.Dispose(disposing);
        }
-        base.Dispose(disposing);
    }
 }
--- a/src/SharpCompress/Common/Rar/RarEntry.cs
+++ b/src/SharpCompress/Common/Rar/RarEntry.cs
@@ -1,72 +1,65 @@
-using System;
+using System;
 using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Common.Rar;
-
-public abstract class RarEntry : Entry
+namespace SharpCompress.Common.Rar
 {
-    internal abstract FileHeader FileHeader { get; }
+    public abstract class RarEntry : Entry
+    {
+        internal abstract FileHeader FileHeader { get; }

-    /// <summary>
-    /// As the V2017 port isn't complete, add this check to use the legacy Rar code.
-    /// </summary>
-    internal bool IsRarV3 =>
-        FileHeader.CompressionAlgorithm == 15
-        || FileHeader.CompressionAlgorithm == 20
-        || FileHeader.CompressionAlgorithm == 26
-        || FileHeader.CompressionAlgorithm == 29
-        || FileHeader.CompressionAlgorithm == 36; //Nanook - Added 20+26 as Test arc from WinRar2.8 (algo 20) was failing with 2017 code
+        /// <summary>
+        /// As the V2017 port isn't complete, add this check to use the legacy Rar code.
+        /// </summary>
+        internal bool IsRarV3 => FileHeader.CompressionAlgorithm == 29 || FileHeader.CompressionAlgorithm == 36;

-    /// <summary>
-    /// The File's 32 bit CRC Hash
-    /// </summary>
-    public override long Crc => FileHeader.FileCrc;
+        /// <summary>
+        /// The File's 32 bit CRC Hash
+        /// </summary>
+        public override long Crc => FileHeader.FileCrc;

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

-    public override string? LinkTarget => null;
+        public override string? LinkTarget => null;

-    /// <summary>
-    /// The entry last modified time in the archive, if recorded
-    /// </summary>
-    public override DateTime? LastModifiedTime => FileHeader.FileLastModifiedTime;
+        /// <summary>
+        /// The entry last modified time in the archive, if recorded
+        /// </summary>
+        public override DateTime? LastModifiedTime => FileHeader.FileLastModifiedTime;

-    /// <summary>
-    /// The entry create time in the archive, if recorded
-    /// </summary>
-    public override DateTime? CreatedTime => FileHeader.FileCreatedTime;
+        /// <summary>
+        /// The entry create time in the archive, if recorded
+        /// </summary>
+        public override DateTime? CreatedTime => FileHeader.FileCreatedTime;

-    /// <summary>
-    /// The entry last accessed time in the archive, if recorded
-    /// </summary>
-    public override DateTime? LastAccessedTime => FileHeader.FileLastAccessedTime;
+        /// <summary>
+        /// The entry last accessed time in the archive, if recorded
+        /// </summary>
+        public override DateTime? LastAccessedTime => FileHeader.FileLastAccessedTime;

-    /// <summary>
-    /// The entry time whend archived, if recorded
-    /// </summary>
-    public override DateTime? ArchivedTime => FileHeader.FileArchivedTime;
+        /// <summary>
+        /// The entry time whend archived, if recorded
+        /// </summary>
+        public override DateTime? ArchivedTime => FileHeader.FileArchivedTime;

-    /// <summary>
-    /// Entry is password protected and encrypted and cannot be extracted.
-    /// </summary>
-    public override bool IsEncrypted => FileHeader.IsEncrypted;
+        /// <summary>
+        /// Entry is password protected and encrypted and cannot be extracted.
+        /// </summary>
+        public override bool IsEncrypted => FileHeader.IsEncrypted;

-    /// <summary>
-    /// Entry is password protected and encrypted and cannot be extracted.
-    /// </summary>
-    public override bool IsDirectory => FileHeader.IsDirectory;
+        /// <summary>
+        /// Entry is password protected and encrypted and cannot be extracted.
+        /// </summary>
+        public override bool IsDirectory => FileHeader.IsDirectory;

-    public override bool IsSplitAfter => FileHeader.IsSplitAfter;
+        public override bool IsSplitAfter => FileHeader.IsSplitAfter;

-    public override string ToString() =>
-        string.Format(
-            "Entry Path: {0} Compressed Size: {1} Uncompressed Size: {2} CRC: {3}",
-            Key,
-            CompressedSize,
-            Size,
-            Crc
-        );
-}
+        public override string ToString()
+        {
+            return string.Format("Entry Path: {0} Compressed Size: {1} Uncompressed Size: {2} CRC: {3}",
+                                 Key, CompressedSize, Size, Crc);
+        }
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Hathcock	e08e4e5d9f	Enabling Bzip2 but something else is broken	2021-02-21 18:01:56 +00:00
Adam Hathcock	dd710ec308	fixed read only sub stream	2021-02-21 13:37:58 +00:00
Adam Hathcock	5cfc608010	More fixes?	2021-02-21 13:21:33 +00:00
Adam Hathcock	997c11ef25	Bug fix on counting	2021-02-21 12:14:07 +00:00
Adam Hathcock	249f11f543	Rework some zip writing	2021-02-21 12:10:17 +00:00
Adam Hathcock	eeb6761a9f	Reuse gzip header reading	2021-02-20 13:11:40 +00:00
Adam Hathcock	0c35abdebe	Explicit exception for read shortcut	2021-02-20 12:52:29 +00:00
Adam Hathcock	30da0b91ed	Fixed Gzip by reverting EmitHeaderAsync	2021-02-20 11:47:38 +00:00
Adam Hathcock	d9c53e1c82	ZLIbStreamfile fixes?	2021-02-20 11:41:46 +00:00
Adam Hathcock	14e6d95559	More clean up doesn’t help	2021-02-14 18:09:22 +00:00
Adam Hathcock	8cdc49cb85	ReadByteAsync	2021-02-14 14:09:25 +00:00
Adam Hathcock	5c11075d36	Updates for merge	2021-02-14 13:52:55 +00:00
Adam Hathcock	be34fe2056	Merge branch 'master' into async # Conflicts: # src/SharpCompress/Archives/GZip/GZipArchive.cs # src/SharpCompress/Common/GZip/GZipFilePart.cs # src/SharpCompress/Common/Tar/Headers/TarHeader.cs # src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs # src/SharpCompress/Common/Zip/ZipFilePart.cs # src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs # src/SharpCompress/Compressors/LZMA/LZipStream.cs # src/SharpCompress/Compressors/Xz/BinaryUtils.cs # src/SharpCompress/Compressors/Xz/Crc32.cs # src/SharpCompress/Writers/Tar/TarWriter.cs # src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs # src/SharpCompress/Writers/Zip/ZipWriter.cs	2021-02-14 13:38:58 +00:00
Adam Hathcock	7e9fb645cb	Minor changes	2021-02-14 12:55:05 +00:00
Adam Hathcock	15209178ce	AsyncStream for BZip2	2021-02-13 18:09:58 +00:00
Adam Hathcock	ea688e1f4c	Writer problems still :(	2021-02-13 17:52:31 +00:00
Adam Hathcock	fe4cc8e6cb	Zip LZMA write will roundtrip	2021-02-13 16:44:53 +00:00
Adam Hathcock	1f37ced35a	AsyncStream everything	2021-02-13 16:16:03 +00:00
Adam Hathcock	949e90351f	More LZMA conversion going, BZip2 not for now	2021-02-13 10:45:57 +00:00
Adam Hathcock	db02e8b634	Minor fixes	2021-02-08 18:25:14 +00:00
Adam Hathcock	d6fe729068	create async	2021-02-08 12:07:45 +00:00
Adam Hathcock	ef3d4da286	Fix test and some zip writing	2021-02-08 11:18:57 +00:00
Adam Hathcock	813bd5ae80	Async open entry	2021-02-08 10:17:34 +00:00
Adam Hathcock	f40d3342c8	Tar and Xz mostly work	2021-02-07 18:58:24 +00:00
Adam Hathcock	9738b812c4	Fix rewindable stream and encoding tests	2021-02-07 18:08:29 +00:00
Adam Hathcock	c6a011df17	Fixed reader issue	2021-02-07 18:03:17 +00:00
Adam Hathcock	7d2dc58766	More API fixes	2021-02-07 13:38:41 +00:00
Adam Hathcock	d234f2d509	First pass of trying tar	2021-02-07 11:30:44 +00:00
Adam Hathcock	cdba5ec419	AsyncEnumerable usage in entries	2021-02-07 09:08:15 +00:00
Adam Hathcock	9cf8a3dbbe	more awaits	2021-02-06 09:08:09 +00:00
Adam Hathcock	2b4f02997e	more async await	2021-02-01 08:34:12 +00:00
Adam Hathcock	bcdfd992a3	async dispose and fix tests?	2021-01-24 09:18:38 +00:00
Adam Hathcock	3a820c52bd	async Deflate. Start of writer	2021-01-24 09:06:02 +00:00