more reverts

# Conflicts:
#	src/SharpCompress/Writers/Zip/ZipWriter.cs

.config/dotnet-tools.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "csharpier": {
+      "version": "0.27.3",
+      "commands": [
+        "dotnet-csharpier"
+      ]
+    }
+  }
+}

.editorconfig

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

.github/dependabot.yml

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

.github/workflows/dotnetcore.yml

@@ -1,5 +1,10 @@
 name: SharpCompress
-on: [push]
+on:
+  push:
+    branches:
+      - 'master'
+  pull_request:
+    types: [ opened, synchronize, reopened, ready_for_review ]
 
 jobs:
   build:
@@ -9,9 +14,12 @@ jobs:
         os: [windows-latest, ubuntu-latest]
 
     steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-dotnet@v1
+    - uses: actions/checkout@v4
+    - uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 3.1.100
-    - name: Run the Cake script
-      uses: ecampidoglio/cake-action@master
+        dotnet-version: 8.0.x
+    - run: dotnet run --project build/build.csproj
+    - uses: actions/upload-artifact@v4
+      with:
+        name: ${{ matrix.os }}-sharpcompress.nupkg
+        path: artifacts/*

.gitignore

@@ -17,3 +17,5 @@ tools
 .idea/
 
 .DS_Store
+*.snupkg
+/tests/TestArchives/6d23a38c-f064-4ef1-ad89-b942396f53b9/Scratch

Directory.Build.props

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

FORMATS.md

@@ -19,7 +19,6 @@
 | 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.

README.md

@@ -1,14 +1,12 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET Standard 1.3 and 2.0 that can unrar, un7zip, unzip, untar unbzip2 and ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1, .NET Core 3.1 and .NET 5.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
-AppVeyor Build -
-[![Build status](https://ci.appveyor.com/api/projects/status/voxg971oemmvxh1e/branch/master?svg=true)](https://ci.appveyor.com/project/adamhathcock/sharpcompress/branch/master)
-
 GitHub Actions Build -
-[![GitHubActions](https://github.com/adamhathcock/sharpcompress/workflows/SharpCompress/badge.svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
+[![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)
 
 ## Need Help?
 
@@ -38,13 +36,15 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 ## TODOs (always lots)
 
-* RAR 5 decryption support
+* RAR 5 decryption crc check support
 * 7Zip writing
 * Zip64 (Need writing and extend Reading)
 * Multi-volume Zip support.
 
 ## 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,6 +185,8 @@ 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

SharpCompress.sln

@@ -3,8 +3,6 @@ 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,6 +11,14 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress", "src\SharpC
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress.Test", "tests\SharpCompress.Test\SharpCompress.Test.csproj", "{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}"
 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
@@ -27,6 +33,10 @@ Global
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

SharpCompress.sln.DotSettings

@@ -126,4 +126,7 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=6af8f80e_002D9fdd_002D4223_002D8e02_002D473db916f9b2/@EntryIndexedValue">&lt;SessionState ContinuousTestingIsOn="False" ContinuousTestingMode="0" FrameworkVersion="{x:Null}" IsLocked="False" Name="All tests from Solution" PlatformMonoPreference="{x:Null}" PlatformType="{x:Null}" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"&gt;
+  &lt;Solution /&gt;
+&lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>

USAGE.md

@@ -33,6 +33,18 @@ 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#
@@ -143,4 +155,4 @@ foreach(var entry in tr.Entries)
 {
     Console.WriteLine($"{entry.Key}");
 }
-```
+```

appveyor.yml

@@ -1,20 +0,0 @@
-version: '{build}'
-image: Visual Studio 2019
-
-pull_requests:
-  do_not_increment_build_number: true
-
-branches:
-  only:
-  - master
-
-nuget:
-  disable_publish_on_pr: true
-
-build_script:
-- ps: .\build.ps1
-
-test: off
-
-artifacts:
-- path: src\SharpCompress\bin\Release\*.nupkg

build.cake

@@ -1,89 +0,0 @@
-var target = Argument("target", "Default");
-var tag = Argument("tag", "cake");
-
-Task("Restore")
-  .Does(() =>
-{
-    DotNetCoreRestore(".");
-});
-
-Task("Build")
-  .IsDependentOn("Restore")
-  .Does(() =>
-{
-    if (IsRunningOnWindows())
-    {
-        MSBuild("./sharpcompress.sln", c => 
-        { 
-            c.SetConfiguration("Release")
-            .SetVerbosity(Verbosity.Minimal)
-            .UseToolVersion(MSBuildToolVersion.VS2019);
-        });
-    }
-    else 
-    {
-        var settings = new DotNetCoreBuildSettings
-        {
-            Framework = "netstandard1.3",
-            Configuration = "Release",
-            NoRestore = true
-        };
-
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
-
-        settings.Framework = "netstandard2.0";
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
-
-        settings.Framework = "netstandard2.1";
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
-    }
-});
-
-Task("Test")
-  .IsDependentOn("Build")
-  .Does(() =>
-{
-    var files = GetFiles("tests/**/*.csproj");
-    foreach(var file in files)
-    {
-        var settings = new DotNetCoreTestSettings
-        {
-            Configuration = "Release",
-            Framework = "netcoreapp3.1"
-        };
-        DotNetCoreTest(file.ToString(), settings);
-    }
-});
-
-Task("Pack")
-    .IsDependentOn("Build")
-    .Does(() => 
-{
-    if (IsRunningOnWindows())
-    {
-        MSBuild("src/SharpCompress/SharpCompress.csproj", c => c
-            .SetConfiguration("Release")
-            .SetVerbosity(Verbosity.Minimal)
-            .UseToolVersion(MSBuildToolVersion.VS2019)
-            .WithProperty("NoBuild", "true")
-            .WithTarget("Pack"));
-    } 
-    else 
-    {
-        Information("Skipping Pack as this is not Windows");
-    }
-});
-
-Task("Default")
-    .IsDependentOn("Restore")
-    .IsDependentOn("Build")
-    .IsDependentOn("Test")
-    .IsDependentOn("Pack");
-
- Task("RunTests")
-    .IsDependentOn("Restore")
-    .IsDependentOn("Build")
-    .IsDependentOn("Test");
-
-
-RunTarget(target);

build.ps1

@@ -1,228 +0,0 @@
-##########################################################################
-# This is the Cake bootstrapper script for PowerShell.
-# This file was downloaded from https://github.com/cake-build/resources
-# Feel free to change this file to fit your needs.
-##########################################################################
-
-<#
-
-.SYNOPSIS
-This is a Powershell script to bootstrap a Cake build.
-
-.DESCRIPTION
-This Powershell script will download NuGet if missing, restore NuGet tools (including Cake)
-and execute your Cake build script with the parameters you provide.
-
-.PARAMETER Script
-The build script to execute.
-.PARAMETER Target
-The build script target to run.
-.PARAMETER Configuration
-The build configuration to use.
-.PARAMETER Verbosity
-Specifies the amount of information to be displayed.
-.PARAMETER Experimental
-Tells Cake to use the latest Roslyn release.
-.PARAMETER WhatIf
-Performs a dry run of the build script.
-No tasks will be executed.
-.PARAMETER Mono
-Tells Cake to use the Mono scripting engine.
-.PARAMETER SkipToolPackageRestore
-Skips restoring of packages.
-.PARAMETER ScriptArgs
-Remaining arguments are added here.
-
-.LINK
-http://cakebuild.net
-
-#>
-
-[CmdletBinding()]
-Param(
-    [string]$Script = "build.cake",
-    [string]$Target = "Default",
-    [ValidateSet("Release", "Debug")]
-    [string]$Configuration = "Release",
-    [ValidateSet("Quiet", "Minimal", "Normal", "Verbose", "Diagnostic")]
-    [string]$Verbosity = "Verbose",
-    [switch]$Experimental,
-    [Alias("DryRun","Noop")]
-    [switch]$WhatIf,
-    [switch]$Mono,
-    [switch]$SkipToolPackageRestore,
-    [Parameter(Position=0,Mandatory=$false,ValueFromRemainingArguments=$true)]
-    [string[]]$ScriptArgs
-)
-
-[Reflection.Assembly]::LoadWithPartialName("System.Security") | Out-Null
-function MD5HashFile([string] $filePath)
-{
-    if ([string]::IsNullOrEmpty($filePath) -or !(Test-Path $filePath -PathType Leaf))
-    {
-        return $null
-    }
-
-    [System.IO.Stream] $file = $null;
-    [System.Security.Cryptography.MD5] $md5 = $null;
-    try
-    {
-        $md5 = [System.Security.Cryptography.MD5]::Create()
-        $file = [System.IO.File]::OpenRead($filePath)
-        return [System.BitConverter]::ToString($md5.ComputeHash($file))
-    }
-    finally
-    {
-        if ($file -ne $null)
-        {
-            $file.Dispose()
-        }
-    }
-}
-
-Write-Host "Preparing to run build script..."
-
-if(!$PSScriptRoot){
-    $PSScriptRoot = Split-Path $MyInvocation.MyCommand.Path -Parent
-}
-
-$TOOLS_DIR = Join-Path $PSScriptRoot "tools"
-$ADDINS_DIR = Join-Path $TOOLS_DIR "addins"
-$MODULES_DIR = Join-Path $TOOLS_DIR "modules"
-$NUGET_EXE = Join-Path $TOOLS_DIR "nuget.exe"
-$CAKE_EXE = Join-Path $TOOLS_DIR "Cake/Cake.exe"
-$NUGET_URL = "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe"
-$PACKAGES_CONFIG = Join-Path $TOOLS_DIR "packages.config"
-$PACKAGES_CONFIG_MD5 = Join-Path $TOOLS_DIR "packages.config.md5sum"
-$ADDINS_PACKAGES_CONFIG = Join-Path $ADDINS_DIR "packages.config"
-$MODULES_PACKAGES_CONFIG = Join-Path $MODULES_DIR "packages.config"
-
-# Should we use mono?
-$UseMono = "";
-if($Mono.IsPresent) {
-    Write-Verbose -Message "Using the Mono based scripting engine."
-    $UseMono = "-mono"
-}
-
-# Should we use the new Roslyn?
-$UseExperimental = "";
-if($Experimental.IsPresent -and !($Mono.IsPresent)) {
-    Write-Verbose -Message "Using experimental version of Roslyn."
-    $UseExperimental = "-experimental"
-}
-
-# Is this a dry run?
-$UseDryRun = "";
-if($WhatIf.IsPresent) {
-    $UseDryRun = "-dryrun"
-}
-
-# Make sure tools folder exists
-if ((Test-Path $PSScriptRoot) -and !(Test-Path $TOOLS_DIR)) {
-    Write-Verbose -Message "Creating tools directory..."
-    New-Item -Path $TOOLS_DIR -Type directory | out-null
-}
-
-# Make sure that packages.config exist.
-if (!(Test-Path $PACKAGES_CONFIG)) {
-    Write-Verbose -Message "Downloading packages.config..."
-    try { (New-Object System.Net.WebClient).DownloadFile("http://cakebuild.net/download/bootstrapper/packages", $PACKAGES_CONFIG) } catch {
-        Throw "Could not download packages.config."
-    }
-}
-
-# Try find NuGet.exe in path if not exists
-if (!(Test-Path $NUGET_EXE)) {
-    Write-Verbose -Message "Trying to find nuget.exe in PATH..."
-    $existingPaths = $Env:Path -Split ';' | Where-Object { (![string]::IsNullOrEmpty($_)) -and (Test-Path $_ -PathType Container) }
-    $NUGET_EXE_IN_PATH = Get-ChildItem -Path $existingPaths -Filter "nuget.exe" | Select -First 1
-    if ($NUGET_EXE_IN_PATH -ne $null -and (Test-Path $NUGET_EXE_IN_PATH.FullName)) {
-        Write-Verbose -Message "Found in PATH at $($NUGET_EXE_IN_PATH.FullName)."
-        $NUGET_EXE = $NUGET_EXE_IN_PATH.FullName
-    }
-}
-
-# Try download NuGet.exe if not exists
-if (!(Test-Path $NUGET_EXE)) {
-    Write-Verbose -Message "Downloading NuGet.exe..."
-    try {
-        (New-Object System.Net.WebClient).DownloadFile($NUGET_URL, $NUGET_EXE)
-    } catch {
-        Throw "Could not download NuGet.exe."
-    }
-}
-
-# Save nuget.exe path to environment to be available to child processed
-$ENV:NUGET_EXE = $NUGET_EXE
-
-# Restore tools from NuGet?
-if(-Not $SkipToolPackageRestore.IsPresent) {
-    Push-Location
-    Set-Location $TOOLS_DIR
-
-    # Check for changes in packages.config and remove installed tools if true.
-    [string] $md5Hash = MD5HashFile($PACKAGES_CONFIG)
-    if((!(Test-Path $PACKAGES_CONFIG_MD5)) -Or
-      ($md5Hash -ne (Get-Content $PACKAGES_CONFIG_MD5 ))) {
-        Write-Verbose -Message "Missing or changed package.config hash..."
-        Remove-Item * -Recurse -Exclude packages.config,nuget.exe
-    }
-
-    Write-Verbose -Message "Restoring tools from NuGet..."
-    $NuGetOutput = Invoke-Expression "&`"$NUGET_EXE`" install -ExcludeVersion -OutputDirectory `"$TOOLS_DIR`""
-
-    if ($LASTEXITCODE -ne 0) {
-        Throw "An error occured while restoring NuGet tools."
-    }
-    else
-    {
-        $md5Hash | Out-File $PACKAGES_CONFIG_MD5 -Encoding "ASCII"
-    }
-    Write-Verbose -Message ($NuGetOutput | out-string)
-    
-    Pop-Location
-}
-
-# Restore addins from NuGet
-if (Test-Path $ADDINS_PACKAGES_CONFIG) {
-    Push-Location
-    Set-Location $ADDINS_DIR
-
-    Write-Verbose -Message "Restoring addins from NuGet..."
-    $NuGetOutput = Invoke-Expression "&`"$NUGET_EXE`" install -ExcludeVersion -OutputDirectory `"$ADDINS_DIR`""
-
-    if ($LASTEXITCODE -ne 0) {
-        Throw "An error occured while restoring NuGet addins."
-    }
-
-    Write-Verbose -Message ($NuGetOutput | out-string)
-
-    Pop-Location
-}
-
-# Restore modules from NuGet
-if (Test-Path $MODULES_PACKAGES_CONFIG) {
-    Push-Location
-    Set-Location $MODULES_DIR
-
-    Write-Verbose -Message "Restoring modules from NuGet..."
-    $NuGetOutput = Invoke-Expression "&`"$NUGET_EXE`" install -ExcludeVersion -OutputDirectory `"$MODULES_DIR`""
-
-    if ($LASTEXITCODE -ne 0) {
-        Throw "An error occured while restoring NuGet modules."
-    }
-
-    Write-Verbose -Message ($NuGetOutput | out-string)
-
-    Pop-Location
-}
-
-# Make sure that Cake has been installed.
-if (!(Test-Path $CAKE_EXE)) {
-    Throw "Could not find Cake.exe at $CAKE_EXE"
-}
-
-# Start Cake
-Write-Host "Running build script..."
-Invoke-Expression "& `"$CAKE_EXE`" `"$Script`" -target=`"$Target`" -configuration=`"$Configuration`" -verbosity=`"$Verbosity`" $UseMono $UseDryRun $UseExperimental $ScriptArgs"
-exit $LASTEXITCODE

build.sh

@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-##########################################################################
-# This is the Cake bootstrapper script for Linux and OS X.
-# This file was downloaded from https://github.com/cake-build/resources
-# Feel free to change this file to fit your needs.
-##########################################################################
-
-# Define directories.
-SCRIPT_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
-TOOLS_DIR=$SCRIPT_DIR/tools
-CAKE_VERSION=0.27.1
-CAKE_DLL=$TOOLS_DIR/Cake.CoreCLR.$CAKE_VERSION/Cake.dll
-
-# Make sure the tools folder exist.
-if [ ! -d "$TOOLS_DIR" ]; then
-  mkdir "$TOOLS_DIR"
-fi
-
-###########################################################################
-# INSTALL CAKE
-###########################################################################
-
-if [ ! -f "$CAKE_DLL" ]; then
-    curl -Lsfo Cake.CoreCLR.zip "https://www.nuget.org/api/v2/package/Cake.CoreCLR/$CAKE_VERSION" && unzip -q Cake.CoreCLR.zip -d "$TOOLS_DIR/Cake.CoreCLR.$CAKE_VERSION" && rm -f Cake.CoreCLR.zip
-    if [ $? -ne 0 ]; then
-        echo "An error occured while installing Cake."
-        exit 1
-    fi
-fi
-
-# Make sure that Cake has been installed.
-if [ ! -f "$CAKE_DLL" ]; then
-    echo "Could not find Cake.exe at '$CAKE_DLL'."
-    exit 1
-fi
-
-###########################################################################
-# RUN BUILD SCRIPT
-###########################################################################
-
-# Start Cake
-exec dotnet "$CAKE_DLL" "$@"

build/Program.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+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";
+
+Target(
+    Clean,
+    ForEach("**/bin", "**/obj"),
+    dir =>
+    {
+        IEnumerable<string> GetDirectories(string d)
+        {
+            return Glob.Directories(".", d);
+        }
+
+        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,
+    () =>
+    {
+        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("net8.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);

build/build.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.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" />
+  </ItemGroup>
+
+</Project>

global.json

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "8.0.100",
+    "rollForward": "latestFeature"
+  }
+}

src/SharpCompress/Algorithms/Adler32.cs

@@ -0,0 +1,486 @@
+// 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.
+            var 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)
+        {
+            var 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)
+    {
+        var s1 = adler & 0xFFFF;
+        var s2 = (adler >> 16) & 0xFFFF;
+
+        // Process the data in blocks.
+        var length = (uint)buffer.Length;
+        var blocks = length / BlockSize;
+        length -= blocks * BlockSize;
+
+        fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
+        {
+            fixed (byte* tapPtr = &MemoryMarshal.GetReference(Tap1Tap2))
+            {
+                var localBufferPtr = bufferPtr;
+
+                // _mm_setr_epi8 on x86
+                var tap1 = Sse2.LoadVector128((sbyte*)tapPtr);
+                var tap2 = Sse2.LoadVector128((sbyte*)(tapPtr + 0x10));
+                var zero = Vector128<byte>.Zero;
+                var ones = Vector128.Create((short)1);
+
+                while (blocks > 0)
+                {
+                    var 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.
+                    var v_ps = Vector128.CreateScalar(s1 * n);
+                    var v_s2 = Vector128.CreateScalar(s2);
+                    var v_s1 = Vector128<uint>.Zero;
+
+                    do
+                    {
+                        // Load 32 input bytes.
+                        var bytes1 = Sse3.LoadDquVector128(localBufferPtr);
+                        var 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());
+                        var 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());
+                        var 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)
+    {
+        var s1 = adler & 0xFFFF;
+        var s2 = (adler >> 16) & 0xFFFF;
+        var length = (uint)buffer.Length;
+
+        fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
+        {
+            var localBufferPtr = bufferPtr;
+
+            var 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)
+            {
+                var k = length < NMAX ? (int)length : (int)NMAX;
+                k -= k % 32;
+                length -= (uint)k;
+
+                var vs10 = vs1;
+                var vs3 = Vector256<uint>.Zero;
+
+                while (k >= 32)
+                {
+                    // Load 32 input bytes.
+                    var block = Avx.LoadVector256(localBufferPtr);
+
+                    // Sum of abs diff, resulting in 2 x int32's
+                    var vs1sad = Avx2.SumAbsoluteDifferences(block, zero);
+
+                    vs1 = Avx2.Add(vs1, vs1sad.AsUInt32());
+                    vs3 = Avx2.Add(vs3, vs10);
+
+                    // sum 32 uint8s to 16 shorts.
+                    var vshortsum2 = Avx2.MultiplyAddAdjacent(block, dot2v);
+
+                    // sum 16 shorts to 8 uint32s.
+                    var 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)
+    {
+        var s1 = adler & 0xFFFF;
+        var s2 = (adler >> 16) & 0xFFFF;
+        uint k;
+
+        fixed (byte* bufferPtr = buffer)
+        {
+            var localBufferPtr = bufferPtr;
+            var 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;
+        }
+    }
+}

src/SharpCompress/Archives/AbstractArchive.cs

@@ -1,177 +1,173 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
 {
-    public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
-        where TEntry : IArchiveEntry
-        where TVolume : IVolume
+    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)
     {
-        private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
-        private readonly LazyReadOnlyCollection<TEntry> lazyEntries;
+        Type = type;
+        ReaderOptions = srcStream.ReaderOptions;
+        SrcStream = srcStream;
+        lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
+        lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+    }
 
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+#nullable disable
+    internal AbstractArchive(ArchiveType type)
+    {
+        Type = type;
+        lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
+        lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+    }
 
-        public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
-        public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+#nullable enable
 
-        protected ReaderOptions ReaderOptions { get; }
+    public ArchiveType Type { get; }
 
-        private bool disposed;
+    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
+        EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
 
-        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
+    void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) =>
+        EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
+    private static Stream CheckStreams(Stream stream)
+    {
+        if (!stream.CanSeek || !stream.CanRead)
         {
-            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));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+            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 ICollection<TEntry> Entries => lazyEntries;
 
-        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
+    /// <summary>
+    /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
+    /// </summary>
+    public ICollection<TVolume> Volumes => lazyVolumes;
 
-        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
+    /// <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)
         {
-            Type = type;
-            ReaderOptions = readerOptions;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+            lazyVolumes.ForEach(v => v.Dispose());
+            lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+            SrcStream?.Dispose();
+
+            disposed = true;
         }
+    }
 
-        internal AbstractArchive(ArchiveType type)
-        {
-            Type = type;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
-        }
+    void IArchiveExtractionListener.EnsureEntriesLoaded()
+    {
+        lazyEntries.EnsureFullyLoaded();
+        lazyVolumes.EnsureFullyLoaded();
+    }
 
-        public ArchiveType Type { get; }
+    void IExtractionListener.FireCompressedBytesRead(
+        long currentPartCompressedBytes,
+        long compressedReadBytes
+    ) =>
+        CompressedBytesRead?.Invoke(
+            this,
+            new CompressedBytesReadEventArgs(
+                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
+                compressedBytesRead: compressedReadBytes
+            )
+        );
 
-        void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry)
-        {
-            EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-        }
+    void IExtractionListener.FireFilePartExtractionBegin(
+        string name,
+        long size,
+        long compressedSize
+    ) =>
+        FilePartExtractionBegin?.Invoke(
+            this,
+            new FilePartExtractionBeginEventArgs(
+                compressedSize: compressedSize,
+                size: size,
+                name: name
+            )
+        );
 
-        void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry)
-        {
-            EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-        }
+    /// <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();
+    }
 
-        private static Stream CheckStreams(Stream stream)
-        {
-            if (!stream.CanSeek || !stream.CanRead)
-            {
-                throw new ArgumentException("Archive streams must be Readable and Seekable");
-            }
-            return stream;
-        }
+    protected abstract IReader CreateReaderForSolidExtraction();
 
-        /// <summary>
-        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
-        /// </summary>
-        public virtual ICollection<TEntry> Entries { get { return lazyEntries; } }
+    /// <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>
-        /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
-        /// </summary>
-        public ICollection<TVolume> Volumes { get { return lazyVolumes; } }
-
-        /// <summary>
-        /// The total size of the files compressed in the archive.
-        /// </summary>
-        public virtual long TotalSize { get { return 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 { get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); } }
-
-        protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams);
-        protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
-
-        IEnumerable<IArchiveEntry> IArchive.Entries { get { return Entries.Cast<IArchiveEntry>(); } }
-
-        IEnumerable<IVolume> IArchive.Volumes { get { return lazyVolumes.Cast<IVolume>(); } }
-
-        public virtual void Dispose()
-        {
-            if (!disposed)
-            {
-                lazyVolumes.ForEach(v => v.Dispose());
-                lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
-                disposed = true;
-            }
-        }
-
-        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()
+    /// <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
         {
             ((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 { get { return 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
-            {
-                ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-                return Entries.All(x => x.IsComplete);
-            }
+            return Entries.All(x => x.IsComplete);
         }
     }
 }

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -1,145 +1,179 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
-using SharpCompress.Readers;
+using SharpCompress.IO;
 using SharpCompress.Writers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public abstract class AbstractWritableArchive<TEntry, TVolume>
+    : AbstractArchive<TEntry, TVolume>,
+        IWritableArchive
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
 {
-    public abstract class AbstractWritableArchive<TEntry, TVolume> : AbstractArchive<TEntry, TVolume>, IWritableArchive
-        where TEntry : IArchiveEntry
-        where TVolume : IVolume
+    private class RebuildPauseDisposable : IDisposable
     {
-        private readonly List<TEntry> newEntries = new List<TEntry>();
-        private readonly List<TEntry> removedEntries = new List<TEntry>();
+        private readonly AbstractWritableArchive<TEntry, TVolume> archive;
 
-        private readonly List<TEntry> modifiedEntries = new List<TEntry>();
-        private bool hasModifications;
-
-        internal AbstractWritableArchive(ArchiveType type)
-            : base(type)
+        public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume> archive)
         {
+            this.archive = archive;
+            archive.pauseRebuilding = true;
         }
 
-        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
-            : base(type, stream.AsEnumerable(), readerFactoryOptions)
+        public void Dispose()
         {
-        }
-
-        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
-            : base(type, fileInfo, readerFactoryOptions)
-        {
-        }
-
-        public override ICollection<TEntry> Entries
-        {
-            get
-            {
-                if (hasModifications)
-                {
-                    return modifiedEntries;
-                }
-                return base.Entries;
-            }
-        }
-
-        private void RebuildModifiedCollection()
-        {
-            hasModifications = true;
-            newEntries.RemoveAll(v => removedEntries.Contains(v));
-            modifiedEntries.Clear();
-            modifiedEntries.AddRange(OldEntries.Concat(newEntries));
-        }
-
-        private IEnumerable<TEntry> OldEntries { get { return 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)
-        {
-            return AddEntry(key, source, false, size, modified);
-        }
-
-        IArchiveEntry IWritableArchive.AddEntry(string key, Stream source, bool closeStream, long size, DateTime? modified)
-        {
-            return AddEntry(key, source, closeStream, size, modified);
-        }
-
-        public TEntry AddEntry(string key, Stream source, bool closeStream,
-                               long size = 0, DateTime? modified = null)
-        {
-            if (key.StartsWith("/")
-                || key.StartsWith("\\"))
-            {
-                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.StartsWith("\\"))
-                {
-                    p = p.Substring(1);
-                }
-                return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
-            }
-            return false;
-        }
-
-        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);
-        }
-
-        protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
-                                     bool closeStream)
-        {
-            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);
-        }
-
-        protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
-                                                      bool closeStream);
-
-        protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
-
-        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());
+            archive.pauseRebuilding = false;
+            archive.RebuildModifiedCollection();
         }
     }
+
+    private readonly List<TEntry> newEntries = new();
+    private readonly List<TEntry> removedEntries = new();
+
+    private readonly List<TEntry> modifiedEntries = new();
+    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)
+            {
+                return modifiedEntries;
+            }
+            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] == '\\')
+            {
+                p = p.Substring(1);
+            }
+            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+        }
+        return false;
+    }
+
+    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);
+    }
+
+    protected TEntry CreateEntry(
+        string key,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    )
+    {
+        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);
+    }
+
+    protected abstract TEntry CreateEntryInternal(
+        string key,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    );
+
+    protected abstract void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TEntry> oldEntries,
+        IEnumerable<TEntry> newEntries
+    );
+
+    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());
+    }
 }

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -1,148 +1,241 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Archives.GZip;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Archives.SevenZip;
-using SharpCompress.Archives.Tar;
-using SharpCompress.Archives.Zip;
+using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.Factories;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class ArchiveFactory
 {
-    public class ArchiveFactory
+    /// <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)
     {
-        /// <summary>
-        /// Opens an Archive for random access
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        /// <returns></returns>
-        public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
+        readerOptions ??= new ReaderOptions();
+
+        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)
         {
-            stream.CheckNotNull(nameof(stream));
-            if (!stream.CanRead || !stream.CanSeek)
-            {
-                throw new ArgumentException("Stream should be readable and seekable");
-            }
-            readerOptions = readerOptions ?? new ReaderOptions();
-            if (ZipArchive.IsZipFile(stream, null))
-            {
-                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 (GZipArchive.IsGZipFile(stream))
-            {
-                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 (TarArchive.IsTarFile(stream))
-            {
-                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 factory.CreateWriteableArchive();
         }
 
-        public static IWritableArchive Create(ArchiveType type)
+        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)
         {
-            switch (type)
+            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))
             {
-                case ArchiveType.Zip:
-                {
-                    return ZipArchive.Create();
-                }
-                case ArchiveType.Tar:
-                {
-                    return TarArchive.Create();
-                }
-                case ArchiveType.GZip:
-                {
-                    return GZipArchive.Create();
-                }
-                default:
-                {
-                    throw new NotSupportedException("Cannot create Archives of type: " + type);
-                }
+                stream.Seek(startPosition, SeekOrigin.Begin);
+
+                return factory;
             }
         }
 
-        /// <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)
+        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)
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), options);
+            throw new ArgumentException("Stream should be readable and seekable");
         }
 
-        /// <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)
+        var startPosition = stream.Position;
+
+        foreach (var factory in Factory.Factories)
         {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            options = options ?? new ReaderOptions { LeaveStreamOpen = false };
-            using (var stream = fileInfo.OpenRead())
+            stream.Position = startPosition;
+
+            if (factory.IsArchive(stream, null))
             {
-                if (ZipArchive.IsZipFile(stream, null))
-                {
-                    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 (GZipArchive.IsGZipFile(stream))
-                {
-                    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");
+                type = factory.KnownArchiveType;
+                return true;
             }
         }
 
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
-                                            ExtractionOptions options = null)
+        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>())
         {
-            using (IArchive archive = Open(sourceArchive))
+            var i = 1;
+            var part = factory.GetFilePart(i++, part1);
+
+            if (part != null)
             {
-                foreach (IArchiveEntry entry in archive.Entries)
+                yield return part;
+                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
                 {
-                    entry.WriteToDirectory(destinationDirectory, options);
+                    yield return part;
                 }
+
+                yield break;
             }
         }
     }

src/SharpCompress/Archives/ArchiveVolumeFactory.cs

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

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -1,182 +1,206 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 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
+namespace SharpCompress.Archives.GZip;
+
+public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
 {
-    public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static GZipArchive Open(string filePath, ReaderOptions readerOptions = null)
+        filePath.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();
+
+    /// <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)
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+            return false;
         }
 
-        /// <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)
+        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))
         {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
+            return false;
         }
 
-        /// <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)
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
         {
-            stream.CheckNotNull(nameof(stream));
-            return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
+            return false;
         }
 
-        public static GZipArchive Create()
+        return true;
+    }
+
+    internal GZipArchive()
+        : base(ArchiveType.GZip) { }
+
+    protected override GZipArchiveEntry CreateEntryInternal(
+        string filePath,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    )
+    {
+        if (Entries.Any())
         {
-            return new GZipArchive();
+            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
         }
+        return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
+    }
 
-        /// <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)
-            : base(ArchiveType.GZip, fileInfo, options)
+    protected override void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> newEntries
+    )
+    {
+        if (Entries.Count > 1)
         {
+            throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
         }
-
-        protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file)
+        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
-            return new GZipVolume(file, ReaderOptions).AsEnumerable();
-        }
-
-        public static bool IsGZipFile(string filePath)
-        {
-            return IsGZipFile(new FileInfo(filePath));
-        }
-
-        public static bool IsGZipFile(FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                return false;
-            }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsGZipFile(stream);
-            }
-        }
-
-        public void SaveTo(string filePath)
-        {
-            SaveTo(new FileInfo(filePath));
-        }
-
-        public void SaveTo(FileInfo fileInfo)
-        {
-            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
-            byte[] header = new byte[10];
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (!stream.ReadFully(header))
-            {
-                return false;
-            }
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <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)
-            : base(ArchiveType.GZip, stream, options)
-        {
-        }
-
-        internal GZipArchive()
-            : base(ArchiveType.GZip)
-        {
-        }
-
-        protected override GZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                                bool closeStream)
-        {
-            if (Entries.Any())
-            {
-                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
-            }
-            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)
-            {
-                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
-            }
-            using (var writer = new GZipWriter(stream, new GZipWriterOptions(options)))
-            {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
-                    }
-                }
-            }
-        }
-
-        protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new GZipVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
-        protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
-        {
-            Stream stream = volumes.Single().Stream;
-            yield return new GZipArchiveEntry(this, new GZipFilePart(stream, ReaderOptions.ArchiveEncoding));
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.Single().Stream;
-            stream.Position = 0;
-            return GZipReader.Open(stream);
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
         }
     }
+
+    protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
+    {
+        var stream = volumes.Single().Stream;
+        yield return new GZipArchiveEntry(
+            this,
+            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
+        );
+    }
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return GZipReader.Open(stream);
+    }
 }

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -2,33 +2,29 @@
 using System.Linq;
 using SharpCompress.Common.GZip;
 
-namespace SharpCompress.Archives.GZip
+namespace SharpCompress.Archives.GZip;
+
+public class GZipArchiveEntry : GZipEntry, IArchiveEntry
 {
-    public class GZipArchiveEntry : GZipEntry, IArchiveEntry
+    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
+        : base(part) => Archive = archive;
+
+    public virtual Stream OpenEntryStream()
     {
-        internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
-            : base(part)
+        //this is to reset the stream to be read multiple times
+        var part = (GZipFilePart)Parts.Single();
+        if (part.GetRawStream().Position != part.EntryStartPosition)
         {
-            Archive = archive;
+            part.GetRawStream().Position = part.EntryStartPosition;
         }
-
-        public virtual Stream OpenEntryStream()
-        {
-            //this is to reset the stream to be read multiple times
-            var part = Parts.Single() as GZipFilePart;
-            if (part.GetRawStream().Position != part.EntryStartPosition)
-            {
-                part.GetRawStream().Position = part.EntryStartPosition;
-            }
-            return Parts.Single().GetCompressedStream();
-        }
-
-        #region IArchiveEntry Members
-
-        public IArchive Archive { get; }
-
-        public bool IsComplete => true;
-
-        #endregion
+        return Parts.Single().GetCompressedStream();
     }
-}
+
+    #region IArchiveEntry Members
+
+    public IArchive Archive { get; }
+
+    public bool IsComplete => true;
+
+    #endregion
+}

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -1,66 +1,73 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.GZip
+namespace SharpCompress.Archives.GZip;
+
+internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
 {
-    internal class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
+    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)
     {
-        private readonly bool closeStream;
-        private readonly Stream stream;
+        this.stream = stream;
+        Key = path;
+        Size = size;
+        LastModifiedTime = lastModified;
+        this.closeStream = closeStream;
+    }
 
-        internal GZipWritableArchiveEntry(GZipArchive archive, Stream stream,
-                                          string path, long size, DateTime? lastModified, bool closeStream)
-            : base(archive, null)
+    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)
         {
-            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 Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream)
-            {
-                stream.Dispose();
-            }
+            stream.Dispose();
         }
     }
-}
+}

src/SharpCompress/Archives/IArchive.cs

@@ -1,49 +1,48 @@
-using System;
+using System;
 using System.Collections.Generic;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public interface IArchive : IDisposable
 {
-    public interface IArchive : IDisposable
-    {
-        event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
-        event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
 
-        event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
-        event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+    event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
+    event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
 
-        IEnumerable<IArchiveEntry> Entries { get; }
-        IEnumerable<IVolume> Volumes { get; }
+    IEnumerable<IArchiveEntry> Entries { get; }
+    IEnumerable<IVolume> Volumes { get; }
 
-        ArchiveType Type { get; }
+    ArchiveType Type { get; }
 
-        /// <summary>
-        /// Use this method to extract all entries in an archive in order.
-        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
-        /// extracted sequentially for the best performance.
-        /// </summary>
-        IReader ExtractAllEntries();
+    /// <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>
-        /// 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>
+    /// 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>
+    /// 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 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>
+    long TotalUncompressSize { get; }
+}

src/SharpCompress/Archives/IArchiveEntry.cs

@@ -1,24 +1,23 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public interface IArchiveEntry : IEntry
 {
-    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>
-        Stream OpenEntryStream();
+    /// <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();
 
-        /// <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; }
+}

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -1,67 +1,70 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class IArchiveEntryExtensions
 {
-    public static class IArchiveEntryExtensions
+    public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
     {
-        public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
+        if (archiveEntry.IsDirectory)
         {
-            if (archiveEntry.Archive.Type == ArchiveType.Rar && archiveEntry.Archive.IsSolid)
-            {
-                throw new InvalidFormatException("Cannot use Archive random access on SOLID Rar files.");
-            }
-
-            if (archiveEntry.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-            var streamListener = archiveEntry.Archive as IArchiveExtractionListener;
-            streamListener.EnsureEntriesLoaded();
-            streamListener.FireEntryExtractionBegin(archiveEntry);
-            streamListener.FireFilePartExtractionBegin(archiveEntry.Key, archiveEntry.Size, archiveEntry.CompressedSize);
-            var entryStream = archiveEntry.OpenEntryStream();
-            if (entryStream == 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);
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        /// <summary>
-        /// Extract to specific file
-        /// </summary>
-        public static void WriteToFile(this IArchiveEntry entry, string destinationFileName,
-                                       ExtractionOptions options = null)
+        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)
         {
-            
-            ExtractionMethods.WriteEntryToFile(entry, destinationFileName, options,
-                                               (x, fm) =>
-                                               {
-                                                   using (FileStream fs = File.Open(destinationFileName, fm))
-                                                   {
-                                                       entry.WriteTo(fs);
-                                                   }
-                                               });
+            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) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                entry.WriteTo(fs);
+            }
+        );
+}

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -1,20 +1,77 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class IArchiveExtensions
 {
-    public static class IArchiveExtensions
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchive archive,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    )
     {
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(this IArchive archive, string destinationDirectory,
-                                            ExtractionOptions options = null)
+        foreach (var entry in archive.Entries.Where(x => !x.IsDirectory))
         {
-            foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory))
-            {
-                entry.WriteToDirectory(destinationDirectory, options);
-            }
+            entry.WriteToDirectory(destinationDirectory, options);
         }
     }
-}
+
+    /// <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);
+        }
+    }
+}

src/SharpCompress/Archives/IArchiveExtractionListener.cs

@@ -1,11 +1,10 @@
-using SharpCompress.Common;
+using SharpCompress.Common;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+internal interface IArchiveExtractionListener : IExtractionListener
 {
-    internal interface IArchiveExtractionListener : IExtractionListener
-    {
-        void EnsureEntriesLoaded();
-        void FireEntryExtractionBegin(IArchiveEntry entry);
-        void FireEntryExtractionEnd(IArchiveEntry entry);
-    }
-}
+    void EnsureEntriesLoaded();
+    void FireEntryExtractionBegin(IArchiveEntry entry);
+    void FireEntryExtractionEnd(IArchiveEntry entry);
+}

src/SharpCompress/Archives/IArchiveFactory.cs

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

src/SharpCompress/Archives/IMultiArchiveFactory.cs

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

src/SharpCompress/Archives/IWritableArchive.cs

@@ -2,14 +2,25 @@ using System;
 using System.IO;
 using SharpCompress.Writers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public interface IWritableArchive : IArchive
 {
-    public interface IWritableArchive : IArchive
-    {
-        void RemoveEntry(IArchiveEntry entry);
+    void RemoveEntry(IArchiveEntry entry);
 
-        IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);
+    IArchiveEntry AddEntry(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null
+    );
 
-        void SaveTo(Stream stream, WriterOptions options);
-    }
-}
+    void SaveTo(Stream stream, WriterOptions options);
+
+    /// <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();
+}

src/SharpCompress/Archives/IWritableArchiveEntry.cs

@@ -1,9 +1,8 @@
-using System.IO;
+using System.IO;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+internal interface IWritableArchiveEntry
 {
-    internal interface IWritableArchiveEntry
-    {
-        Stream Stream { get; }
-    }
-}
+    Stream Stream { get; }
+}

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -2,53 +2,85 @@
 using System.IO;
 using SharpCompress.Writers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class IWritableArchiveExtensions
 {
-    public static class IWritableArchiveExtensions
+    public static void AddEntry(
+        this IWritableArchive writableArchive,
+        string entryPath,
+        string filePath
+    )
     {
-        public static void AddEntry(this IWritableArchive writableArchive,
-                                                     string entryPath, string filePath)
+        var fileInfo = new FileInfo(filePath);
+        if (!fileInfo.Exists)
         {
-            var fileInfo = new FileInfo(filePath);
-            if (!fileInfo.Exists)
-            {
-                throw new FileNotFoundException("Could not AddEntry: " + filePath);
-            }
-            writableArchive.AddEntry(entryPath, new FileInfo(filePath).OpenRead(), true, fileInfo.Length,
-                                     fileInfo.LastWriteTime);
+            throw new FileNotFoundException("Could not AddEntry: " + filePath);
         }
+        writableArchive.AddEntry(
+            entryPath,
+            new FileInfo(filePath).OpenRead(),
+            true,
+            fileInfo.Length,
+            fileInfo.LastWriteTime
+        );
+    }
 
-        public static void SaveTo(this IWritableArchive writableArchive, string filePath, WriterOptions options)
-        {
-            writableArchive.SaveTo(new FileInfo(filePath), options);
-        }
+    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 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)
+    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(path);
-                writableArchive.AddEntry(path.Substring(filePath.Length), fileInfo.OpenRead(), true, fileInfo.Length,
-                                         fileInfo.LastWriteTime);
+                writableArchive.AddEntry(
+                    path.Substring(filePath.Length),
+                    fileInfo.OpenRead(),
+                    true,
+                    fileInfo.Length,
+                    fileInfo.LastWriteTime
+                );
             }
         }
-        public static IArchiveEntry AddEntry(this IWritableArchive writableArchive, string key, FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                throw new ArgumentException("FileInfo does not exist.");
-            }
-            return writableArchive.AddEntry(key, fileInfo.OpenRead(), true, fileInfo.Length, fileInfo.LastWriteTime);
-        }
     }
-}
+
+    public static IArchiveEntry AddEntry(
+        this IWritableArchive writableArchive,
+        string key,
+        FileInfo fileInfo
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            throw new ArgumentException("FileInfo does not exist.");
+        }
+        return writableArchive.AddEntry(
+            key,
+            fileInfo.OpenRead(),
+            true,
+            fileInfo.Length,
+            fileInfo.LastWriteTime
+        );
+    }
+}

src/SharpCompress/Archives/IWriteableArchiveFactory.cs

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

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,39 +6,33 @@ using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+/// <summary>
+/// A rar part based on a FileInfo object
+/// </summary>
+internal class FileInfoRarArchiveVolume : RarVolume
 {
-    /// <summary>
-    /// A rar part based on a FileInfo object
-    /// </summary>
-    internal class FileInfoRarArchiveVolume : RarVolume
+    internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options, int index = 0)
+        : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options), index)
     {
-        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;
-        }
+        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) =>
+        new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
+
+    internal override IEnumerable<RarFilePart> ReadFileParts() => FileParts;
 }

src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs

@@ -1,25 +1,21 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar.Headers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+internal sealed class FileInfoRarFilePart : SeekableFilePart
 {
-    internal class FileInfoRarFilePart : SeekableFilePart
-    {
-        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string password, MarkHeader mh, FileHeader fh, FileInfo fi)
-            : base(mh, fh, volume.Stream, password)
-        {
-            FileInfo = fi;
-        }
+    internal FileInfoRarFilePart(
+        FileInfoRarArchiveVolume volume,
+        string? password,
+        MarkHeader mh,
+        FileHeader fh,
+        FileInfo fi
+    )
+        : base(mh, fh, volume.Index, volume.Stream, password) => FileInfo = fi;
 
-        internal FileInfo FileInfo { get; }
+    internal FileInfo FileInfo { get; }
 
-        internal override string FilePartName
-        {
-            get
-            {
-                return "Rar File: " + FileInfo.FullName
-                       + " File Entry: " + FileHeader.FileName;
-            }
-        }
-    }
+    internal override string FilePartName =>
+        "Rar File: " + FileInfo.FullName + " File Entry: " + FileHeader.FileName;
 }

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

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

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -5,135 +6,174 @@ 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
+namespace SharpCompress.Archives.Rar;
+
+public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 {
-    public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
+    internal Lazy<IRarUnpack> UnpackV2017 { get; } =
+        new(() => new Compressors.Rar.UnpackV2017.Unpack());
+    internal Lazy<IRarUnpack> UnpackV1 { get; } = new(() => new Compressors.Rar.UnpackV1.Unpack());
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="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)
     {
-        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.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
         {
-        }
+            SrcStream.IsVolumes = true;
+            streams[1].Position = 0;
+            SrcStream.Position = 0;
 
-        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
+            return srcStream.Streams.Select(a => new StreamRarArchiveVolume(
+                a,
+                ReaderOptions,
+                idx++
+            ));
+        }
+        else //split mode or single file
         {
-            return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
+            return new StreamRarArchiveVolume(SrcStream, ReaderOptions, idx++).AsEnumerable();
         }
-
-        /// <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)
-        {
-        }
-
-        protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes)
-        {
-            return RarArchiveEntryFactory.GetEntries(this, volumes);
-        }
-
-        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
     }
+
+    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)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsRarFile(stream);
+    }
+
+    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
+    {
+        try
+        {
+            MarkHeader.Read(stream, true, false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    #endregion
 }

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -6,84 +6,100 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
+using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+public class RarArchiveEntry : RarEntry, IArchiveEntry
 {
-    public class RarArchiveEntry : RarEntry, IArchiveEntry
+    private readonly ICollection<RarFilePart> parts;
+    private readonly RarArchive archive;
+    private readonly ReaderOptions readerOptions;
+
+    internal RarArchiveEntry(
+        RarArchive archive,
+        IEnumerable<RarFilePart> parts,
+        ReaderOptions readerOptions
+    )
     {
-        private readonly ICollection<RarFilePart> parts;
-        private readonly RarArchive archive;
+        this.parts = parts.ToList();
+        this.archive = archive;
+        this.readerOptions = readerOptions;
+        IsSolid = FileHeader.IsSolid;
+    }
 
-        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts)
+    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
         {
-            this.parts = parts.ToList();
-            this.archive = archive;
-        }
-
-        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
-            {
-                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 (archive.IsSolid)
-            {
-                throw new InvalidOperationException("Use ExtractAllEntries to extract SOLID archives.");
-            }
-
-            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 
-            { 
-                return parts.Select(fp => fp.FileHeader).Any(fh => !fh.IsSplitAfter); 
-            } 
-        }
-
-        private void CheckIncomplete()
-        {
-            if (!IsComplete)
-            {
-                throw new IncompleteArchiveException("ArchiveEntry is incomplete and cannot perform this operation.");
-            }
+            CheckIncomplete();
+            return BitConverter.ToUInt32(
+                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc,
+                0
+            );
         }
     }
-}
+
+    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."
+            );
+        }
+    }
+}

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

@@ -1,47 +1,52 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using SharpCompress.Common.Rar;
+using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+internal static class RarArchiveEntryFactory
 {
-    internal static class RarArchiveEntryFactory
+    private static IEnumerable<RarFilePart> GetFileParts(IEnumerable<RarVolume> parts)
     {
-        private static IEnumerable<RarFilePart> GetFileParts(IEnumerable<RarVolume> parts)
+        foreach (var rarPart in parts)
         {
-            foreach (RarVolume rarPart in parts)
+            foreach (var fp in rarPart.ReadFileParts())
             {
-                foreach (RarFilePart fp in rarPart.ReadFileParts())
-                {
-                    yield return fp;
-                }
-            }
-        }
-
-        private static IEnumerable<IEnumerable<RarFilePart>> GetMatchedFileParts(IEnumerable<RarVolume> parts)
-        {
-            var groupedParts = new List<RarFilePart>();
-            foreach (RarFilePart fp in GetFileParts(parts))
-            {
-                groupedParts.Add(fp);
-
-                if (!fp.FileHeader.IsSplitAfter)
-                {
-                    yield return groupedParts;
-                    groupedParts = new List<RarFilePart>();
-                }
-            }
-            if (groupedParts.Count > 0)
-            {
-                yield return groupedParts;
-            }
-        }
-
-        internal static IEnumerable<RarArchiveEntry> GetEntries(RarArchive archive,
-                                                                IEnumerable<RarVolume> rarParts)
-        {
-            foreach (var groupedParts in GetMatchedFileParts(rarParts))
-            {
-                yield return new RarArchiveEntry(archive, groupedParts);
+                yield return fp;
             }
         }
     }
-}
+
+    private static IEnumerable<IEnumerable<RarFilePart>> GetMatchedFileParts(
+        IEnumerable<RarVolume> parts
+    )
+    {
+        var groupedParts = new List<RarFilePart>();
+        foreach (var fp in GetFileParts(parts))
+        {
+            groupedParts.Add(fp);
+
+            if (!fp.FileHeader.IsSplitAfter)
+            {
+                yield return groupedParts;
+                groupedParts = new List<RarFilePart>();
+            }
+        }
+        if (groupedParts.Count > 0)
+        {
+            yield return groupedParts;
+        }
+    }
+
+    internal static IEnumerable<RarArchiveEntry> GetEntries(
+        RarArchive archive,
+        IEnumerable<RarVolume> rarParts,
+        ReaderOptions readerOptions
+    )
+    {
+        foreach (var groupedParts in GetMatchedFileParts(rarParts))
+        {
+            yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
+        }
+    }
+}

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -1,142 +1,52 @@
-using System;
-using System.Collections.Generic;
+using System;
 using System.IO;
-using SharpCompress.Common.Rar;
-using SharpCompress.Readers;
-using System.Linq;
-using System.Text;
-using SharpCompress.Common.Rar.Headers;
+using System.Text.RegularExpressions;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+internal static class RarArchiveVolumeFactory
 {
-    internal static class RarArchiveVolumeFactory
+    internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
     {
-        internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, ReaderOptions options)
-        {
-            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;
-            }
-        }
-        
-        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
-        {
-            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
-            yield return part;
+        FileInfo? item = null;
 
-            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;
-            }
+        //new style rar - ..part1 | /part01 | part001 ....
+        var 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
+        {
+            //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);
         }
 
-        private static FileInfo GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart currentFilePart)
-        {
-            if (currentFilePart == null)
-            {
-                return null;
-            }
-            bool oldNumbering = ah.OldNumberingFormat
-                                || currentFilePart.MarkHeader.OldNumberingFormat;
-            if (oldNumbering)
-            {
-                return FindNextFileWithOldNumbering(currentFilePart.FileInfo);
-            }
-            else
-            {
-                return FindNextFileWithNewNumbering(currentFilePart.FileInfo);
-            }
-        }
+        if (item != null && item.Exists)
+            return item;
 
-        private static FileInfo FindNextFileWithOldNumbering(FileInfo currentFileInfo)
-        {
-            // .rar, .r00, .r01, ...
-            string extension = currentFileInfo.Extension;
-
-            StringBuilder 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
-            {
-                int num = 0;
-                if (int.TryParse(extension.Substring(2, 2), out 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);
-            int num = 0;
-            string numString = currentFileInfo.FullName.Substring(startIndex + 5,
-                                                                  currentFileInfo.FullName.IndexOf('.', startIndex + 5) -
-                                                                  startIndex - 5);
-            buffer.Append(".part");
-            if (int.TryParse(numString, out 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);
-        }
+        return null; //no more items
     }
-}
+}

src/SharpCompress/Archives/Rar/SeekableFilePart.cs

@@ -1,31 +1,45 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+internal class SeekableFilePart : RarFilePart
 {
-    internal class SeekableFilePart : RarFilePart
+    private readonly Stream stream;
+    private readonly string? password;
+
+    internal SeekableFilePart(
+        MarkHeader mh,
+        FileHeader fh,
+        int index,
+        Stream stream,
+        string? password
+    )
+        : base(mh, fh, index)
     {
-        private readonly Stream stream;
-        private readonly string password;
-
-        internal SeekableFilePart(MarkHeader mh, FileHeader fh, Stream stream, string password)
-            : base(mh, fh)
-        {
-            this.stream = stream;
-            this.password = password;
-        }
-
-        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;
+        this.stream = stream;
+        this.password = password;
     }
-}
+
+    internal override Stream GetCompressedStream()
+    {
+        stream.Position = FileHeader.DataStartPosition;
+
+        if (FileHeader.R4Salt != null)
+        {
+            var cryptKey = new CryptKey3(password!);
+            return new RarCryptoWrapper(stream, FileHeader.R4Salt, cryptKey);
+        }
+
+        if (FileHeader.Rar5CryptoInfo != null)
+        {
+            var cryptKey = new CryptKey5(password!, FileHeader.Rar5CryptoInfo);
+            return new RarCryptoWrapper(stream, FileHeader.Rar5CryptoInfo.Salt, cryptKey);
+        }
+
+        return stream;
+    }
+
+    internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
+}

src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs

@@ -1,27 +1,19 @@
-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
+namespace SharpCompress.Archives.Rar;
+
+internal class StreamRarArchiveVolume : RarVolume
 {
-    internal class StreamRarArchiveVolume : RarVolume
-    {
-        internal StreamRarArchiveVolume(Stream stream, ReaderOptions options)
-            : base(StreamingMode.Seekable, stream, options)
-        {
-        }
+    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index = 0)
+        : base(StreamingMode.Seekable, stream, options, index) { }
 
-        internal override IEnumerable<RarFilePart> ReadFileParts()
-        {
-            return GetVolumeFileParts();
-        }
+    internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
 
-        internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader)
-        {
-            return new SeekableFilePart(markHeader, fileHeader, Stream, ReaderOptions.Password);
-        }
-    }
-}
+    internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
+        new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
+}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -1,4 +1,6 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -8,213 +10,256 @@ using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.SevenZip
+namespace SharpCompress.Archives.SevenZip;
+
+public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
 {
-    public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
+    private ArchiveDatabase database;
+
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(string filePath, ReaderOptions readerOptions = null)
     {
-        private ArchiveDatabase database;
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static SevenZipArchive Open(string filePath, ReaderOptions readerOptions = null)
-        {
-            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
-        }
+        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(fileInfo, 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(stream, 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()
+            )
+        );
+    }
 
-        internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
-            : base(ArchiveType.SevenZip, fileInfo, 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()
+            )
+        );
+    }
 
-        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
-        {
-            return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
-        }
+    /// <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()
+            )
+        );
+    }
 
-        public static bool IsSevenZipFile(string filePath)
-        {
-            return IsSevenZipFile(new FileInfo(filePath));
-        }
+    /// <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())
+        );
+    }
 
-        public static bool IsSevenZipFile(FileInfo fileInfo)
+    /// <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)
         {
-            if (!fileInfo.Exists)
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsSevenZipFile(stream);
+    }
+
+    internal SevenZipArchive()
+        : base(ArchiveType.SevenZip) { }
+
+    protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(
+        IEnumerable<SevenZipVolume> volumes
+    )
+    {
+        var stream = volumes.Single().Stream;
+        LoadFactory(stream);
+        var entries = new SevenZipArchiveEntry[database._files.Count];
+        for (var i = 0; i < database._files.Count; i++)
+        {
+            var file = database._files[i];
+            entries[i] = new SevenZipArchiveEntry(
+                this,
+                new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding)
+            );
+        }
+        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+        {
+            var isSolid = false;
+            foreach (var entry in group)
             {
-                return false;
-            }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsSevenZipFile(stream);
+                entry.IsSolid = isSolid;
+                isSolid = true; //mark others in this group as solid - same as rar behaviour.
             }
         }
 
-        internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
-            : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
+        return entries;
+    }
+
+    private void LoadFactory(Stream stream)
+    {
+        if (database is null)
         {
-        }
-
-        internal SevenZipArchive()
-            : base(ArchiveType.SevenZip)
-        {
-        }
-
-        protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            foreach (Stream s in streams)
-            {
-                if (!s.CanRead || !s.CanSeek)
-                {
-                    throw new ArgumentException("Stream is not readable and seekable");
-                }
-                SevenZipVolume volume = new SevenZipVolume(s, ReaderOptions);
-                yield return volume;
-            }
-        }
-
-        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 void LoadFactory(Stream stream)
-        {
-            if (database == null)
-            {
-                stream.Position = 0;
-                var reader = new ArchiveReader();
-                reader.Open(stream);
-                database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
-            }
-        }
-
-        public static bool IsSevenZipFile(Stream stream)
-        {
-            try
-            {
-                return SignatureMatch(stream);
-            }
-            catch
-            {
-                return false;
-            }
-        }
-
-        private static readonly byte[] SIGNATURE = {(byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C};
-
-        private static bool SignatureMatch(Stream stream)
-        {
-            BinaryReader reader = new BinaryReader(stream);
-            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 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 == 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;
-            }
+            stream.Position = 0;
+            var reader = new ArchiveReader();
+            reader.Open(stream);
+            database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
         }
     }
+
+    public static bool IsSevenZipFile(Stream stream)
+    {
+        try
+        {
+            return SignatureMatch(stream);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static ReadOnlySpan<byte> SIGNATURE =>
+        new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
+
+    private static bool SignatureMatch(Stream stream)
+    {
+        var reader = new BinaryReader(stream);
+        ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
+        return signatureBytes.SequenceEqual(SIGNATURE);
+    }
+
+    protected override IReader CreateReaderForSolidExtraction() =>
+        new SevenZipReader(ReaderOptions, this);
+
+    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))
+            {
+                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() =>
+            CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
+    }
+
+    private class PasswordProvider : IPasswordProvider
+    {
+        private readonly string _password;
+
+        public PasswordProvider(string password) => _password = password;
+
+        public string CryptoGetTextPassword() => _password;
+    }
 }

src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs

@@ -1,28 +1,21 @@
 using System.IO;
 using SharpCompress.Common.SevenZip;
 
-namespace SharpCompress.Archives.SevenZip
+namespace SharpCompress.Archives.SevenZip;
+
+public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 {
-    public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
-    {
-        internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
-            : base(part)
-        {
-            Archive = archive;
-        }
+    internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
+        : base(part) => Archive = archive;
 
-        public Stream OpenEntryStream()
-        {
-            return FilePart.GetCompressedStream();
-        }
+    public Stream OpenEntryStream() => 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;
+}

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -11,187 +11,228 @@ using SharpCompress.Readers.Tar;
 using SharpCompress.Writers;
 using SharpCompress.Writers.Tar;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
 {
-    public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+    /// <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)
     {
-        /// <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());
-        }
+        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(fileInfo, 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>
-        /// 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(stream, 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()
+            )
+        );
+    }
 
-        public static bool IsTarFile(string filePath)
-        {
-            return IsTarFile(new FileInfo(filePath));
-        }
+    /// <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()
+            )
+        );
+    }
 
-        public static bool IsTarFile(FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                return false;
-            }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsTarFile(stream);
-            }
-        }
+    /// <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(Stream stream)
+    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
+
+    public static bool IsTarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
         {
-            try
-            {
-                TarHeader tarHeader = new TarHeader(new ArchiveEncoding());
-                bool readSucceeded = tarHeader.Read(new BinaryReader(stream));
-                bool isEmptyArchive = tarHeader.Name.Length == 0 && tarHeader.Size == 0 && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
-                return readSucceeded || isEmptyArchive;
-            }
-            catch
-            {
-            }
             return false;
         }
-        
-        /// <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)
-            : base(ArchiveType.Tar, fileInfo, readerOptions)
-        {
-        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsTarFile(stream);
+    }
 
-        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
+    public static bool IsTarFile(Stream stream)
+    {
+        try
         {
-            return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
+            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;
+    }
 
-        /// <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)
-            : base(ArchiveType.Tar, stream, readerOptions)
-        {
-        }
+    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
+    }
 
-        internal TarArchive()
-            : base(ArchiveType.Tar)
-        {
-        }
+    /// <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) { }
 
-        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new TarVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
+    internal TarArchive()
+        : base(ArchiveType.Tar) { }
 
-        protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
+    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
+            )
+        )
         {
-            Stream stream = volumes.Single().Stream;
-            TarHeader previousHeader = null;
-            foreach (TarHeader header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
+            if (header != null)
             {
-                if (header != null)
+                if (header.EntryType == EntryType.LongName)
                 {
-                    if (header.EntryType == EntryType.LongName)
+                    previousHeader = header;
+                }
+                else
+                {
+                    if (previousHeader != null)
                     {
-                        previousHeader = header;
-                    }
-                    else
-                    {
-                        if (previousHeader != null)
+                        var entry = new TarArchiveEntry(
+                            this,
+                            new TarFilePart(previousHeader, stream),
+                            CompressionType.None
+                        );
+
+                        var oldStreamPos = stream.Position;
+
+                        using (var entryStream = entry.OpenEntryStream())
                         {
-                            var entry = new TarArchiveEntry(this, new TarFilePart(previousHeader, stream),
-                                                            CompressionType.None);
+                            using var memoryStream = new MemoryStream();
+                            entryStream.TransferTo(memoryStream);
+                            memoryStream.Position = 0;
+                            var bytes = memoryStream.ToArray();
 
-                            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;
+                            header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
                         }
-                        yield return new TarArchiveEntry(this, new TarFilePart(header, stream), CompressionType.None);
+
+                        stream.Position = oldStreamPos;
+
+                        previousHeader = null;
                     }
+                    yield return new TarArchiveEntry(
+                        this,
+                        new TarFilePart(header, stream),
+                        CompressionType.None
+                    );
                 }
             }
         }
-
-        public static TarArchive Create()
-        {
-            return new TarArchive();
-        }
-
-        protected override TarArchiveEntry CreateEntryInternal(string filePath, Stream source,
-                                                               long size, DateTime? modified, bool closeStream)
-        {
-            return 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))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
-                    }
-                }
-            }
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.Single().Stream;
-            stream.Position = 0;
-            return TarReader.Open(stream);
-        }
+    }
+
+    public static TarArchive Create() => new();
+
+    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))
+        {
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
+        }
+    }
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return TarReader.Open(stream);
     }
 }

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -3,27 +3,20 @@ using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+public class TarArchiveEntry : TarEntry, IArchiveEntry
 {
-    public class TarArchiveEntry : TarEntry, IArchiveEntry
-    {
-        internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
-            : base(part, compressionType)
-        {
-            Archive = archive;
-        }
+    internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
+        : base(part, compressionType) => Archive = archive;
 
-        public virtual Stream OpenEntryStream()
-        {
-            return Parts.Single().GetCompressedStream();
-        }
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
 
-        #region IArchiveEntry Members
+    #region IArchiveEntry Members
 
-        public IArchive Archive { get; }
+    public IArchive Archive { get; }
 
-        public bool IsComplete => true;
+    public bool IsComplete => true;
 
-        #endregion
-    }
-}
+    #endregion
+}

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -1,65 +1,73 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
 {
-    internal class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
+    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)
     {
-        private readonly bool closeStream;
-        private readonly Stream stream;
+        this.stream = stream;
+        Key = path;
+        Size = size;
+        LastModifiedTime = lastModified;
+        this.closeStream = closeStream;
+    }
 
-        internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType,
-                                         string path, long size, DateTime? lastModified, bool closeStream)
-            : base(archive, null, compressionType)
+    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)
         {
-            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 Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream)
-            {
-                stream.Dispose();
-            }
+            stream.Dispose();
         }
     }
-}
+}

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -6,200 +6,300 @@ using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Zip;
 using SharpCompress.Writers;
 using SharpCompress.Writers.Zip;
 
-namespace SharpCompress.Archives.Zip
+namespace SharpCompress.Archives.Zip;
+
+public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
-    public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+#nullable disable
+    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>
+    /// 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)
     {
-        private readonly SeekableZipHeaderFactory headerFactory;
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
 
-        /// <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 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 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(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>
-        /// 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(stream, readerOptions ?? new ReaderOptions());
-        }
-        
-        public static bool IsZipFile(string filePath, string password = null)
-        {
-            return IsZipFile(new FileInfo(filePath), password);
-        }
+    /// <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()
+            )
+        );
+    }
 
-        public static bool IsZipFile(FileInfo fileInfo, string password = null)
+    /// <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)
         {
-            if (!fileInfo.Exists)
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsZipFile(stream, password);
+    }
+
+    public static bool IsZipFile(Stream stream, string? password = null)
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
             {
                 return false;
             }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsZipFile(stream, password);
-            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
         }
-
-        public static bool IsZipFile(Stream stream, string password = null)
+        catch (CryptographicException)
         {
-            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
-            try
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsZipMulti(Stream stream, string? password = null)
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
             {
-                ZipHeader header =
-                    headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-                if (header == null)
+                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
                 {
                     return false;
                 }
-                return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-            }
-            catch (CryptographicException)
-            {
-                return true;
-            }
-            catch
-            {
-                return false;
             }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
         }
-        
-        /// <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)
-            : base(ArchiveType.Zip, fileInfo, readerOptions)
+        catch (CryptographicException)
         {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+            return true;
         }
-
-        protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
+        catch
         {
-            return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
-        }
-
-        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)
-            : base(ArchiveType.Zip, stream, readerOptions)
-        {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
-        }
-
-        protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new ZipVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
-        protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
-        {
-            var volume = volumes.Single();
-            Stream stream = volume.Stream;
-            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(stream))
-            {
-                if (h != null)
-                {
-                    switch (h.ZipHeaderType)
-                    {
-                        case ZipHeaderType.DirectoryEntry:
-                            {
-                                yield return new ZipArchiveEntry(this,
-                                                                 new SeekableZipFilePart(headerFactory,
-                                                                                         h as DirectoryEntryHeader,
-                                                                                         stream));
-                            }
-                            break;
-                        case ZipHeaderType.DirectoryEnd:
-                            {
-                                byte[] bytes = (h as DirectoryEndHeader).Comment;
-                                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))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
-                    }
-                }
-            }
-        }
-
-        protected override ZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                               bool closeStream)
-        {
-            return new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
-        }
-
-        public static ZipArchive Create()
-        {
-            return new ZipArchive();
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.Single().Stream;
-            stream.Position = 0;
-            return ZipReader.Open(stream, ReaderOptions);
+            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)
+            {
+                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++));
+            }
+        }
+
+        //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))
+        {
+            if (h != null)
+            {
+                switch (h.ZipHeaderType)
+                {
+                    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:
+                    {
+                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
+                        volumes.Last().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))
+        {
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+        }
+    }
+
+    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();
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return ZipReader.Open(stream, ReaderOptions, Entries);
+    }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -2,29 +2,22 @@
 using System.Linq;
 using SharpCompress.Common.Zip;
 
-namespace SharpCompress.Archives.Zip
+namespace SharpCompress.Archives.Zip;
+
+public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 {
-    public class ZipArchiveEntry : ZipEntry, IArchiveEntry
-    {
-        internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart part)
-            : base(part)
-        {
-            Archive = archive;
-        }
+    internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
+        : base(part) => Archive = archive;
 
-        public virtual Stream OpenEntryStream()
-        {
-            return Parts.Single().GetCompressedStream();
-        }
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream();
 
-        #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 => (Parts.Single() as SeekableZipFilePart).Comment;
-    }
-}
+    public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
+}

src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs

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

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -1,68 +1,73 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.Zip
+namespace SharpCompress.Archives.Zip;
+
+internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
 {
-    internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
+    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)
     {
-        private readonly bool closeStream;
-        private readonly Stream stream;
-        private bool isDisposed;
+        this.stream = stream;
+        Key = path;
+        Size = size;
+        LastModifiedTime = lastModified;
+        this.closeStream = closeStream;
+    }
 
-        internal ZipWritableArchiveEntry(ZipArchive archive, Stream stream, string path, long size,
-                                         DateTime? lastModified, bool closeStream)
-            : base(archive, null)
+    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)
         {
-            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 Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream && !isDisposed)
-            {
-                stream.Dispose();
-                isDisposed = true;
-            }
+            stream.Dispose();
+            isDisposed = true;
         }
     }
-}
+}

src/SharpCompress/AssemblyInfo.cs

@@ -1,24 +1,3 @@
-using System;
-using System.Reflection;
-using System.Runtime.CompilerServices;
+using System;
 
-[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";
-    }
-}

src/SharpCompress/BufferPool.cs

@@ -0,0 +1,33 @@
+using System.Buffers;
+
+namespace SharpCompress;
+
+internal static class BufferPool
+{
+    /// <summary>
+    ///     gets a buffer from the pool
+    /// </summary>
+    /// <param name="bufferSize">size of the buffer</param>
+    /// <returns>the buffer</returns>
+    public static byte[] Rent(int bufferSize)
+    {
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+        return ArrayPool<byte>.Shared.Rent(bufferSize);
+#else
+        return new byte[bufferSize];
+#endif
+    }
+
+    /// <summary>
+    ///     returns a buffer to the pool
+    /// </summary>
+    /// <param name="buffer">the buffer to return</param>
+    public static void Return(byte[] buffer)
+    {
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+        ArrayPool<byte>.Shared.Return(buffer);
+#else
+        // no-op
+#endif
+    }
+}

src/SharpCompress/Common/ArchiveEncoding.cs

@@ -1,70 +1,55 @@
-using System;
+using System;
 using System.Text;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public class ArchiveEncoding
 {
-    public class ArchiveEncoding
+    /// <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)
     {
-        /// <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()
-        {
-            Default = Encoding.GetEncoding(437);
-            Password = Encoding.GetEncoding(437);
-        }
-
-        static ArchiveEncoding()
-        {
-            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-        }
-
-        public string Decode(byte[] bytes)
-        {
-            return Decode(bytes, 0, bytes.Length);
-        }
-
-        public string Decode(byte[] bytes, int start, int length)
-        {
-            return GetDecoder().Invoke(bytes, start, length);
-        }
-
-        public string DecodeUTF8(byte[] bytes)
-        {
-            return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
-        }
-
-        public byte[] Encode(string str)
-        {
-            return GetEncoding().GetBytes(str);
-        }
-
-        public Encoding GetEncoding()
-        {
-            return Forced ?? Default ?? Encoding.UTF8;
-        }
-
-        public Func<byte[], int, int, string> GetDecoder()
-        {
-            return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
-        }
+        Default = def;
+        Password = password;
     }
+
+#if !NETFRAMEWORK
+    static ArchiveEncoding() => Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
+#endif
+
+    public string Decode(byte[] bytes) => Decode(bytes, 0, bytes.Length);
+
+    public string Decode(byte[] bytes, int start, int length) =>
+        GetDecoder().Invoke(bytes, start, length);
+
+    public string DecodeUTF8(byte[] bytes) => Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+
+    public byte[] Encode(string str) => GetEncoding().GetBytes(str);
+
+    public Encoding GetEncoding() => Forced ?? Default ?? Encoding.UTF8;
+
+    public Func<byte[], int, int, string> GetDecoder() =>
+        CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
 }

src/SharpCompress/Common/ArchiveException.cs

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

src/SharpCompress/Common/ArchiveExtractionEventArgs.cs

@@ -1,14 +1,10 @@
 using System;
 
-namespace SharpCompress.Common
-{
-    public class ArchiveExtractionEventArgs<T> : EventArgs
-    {
-        internal ArchiveExtractionEventArgs(T entry)
-        {
-            Item = entry;
-        }
+namespace SharpCompress.Common;
 
-        public T Item { get; }
-    }
-}
+public class ArchiveExtractionEventArgs<T> : EventArgs
+{
+    internal ArchiveExtractionEventArgs(T entry) => Item = entry;
+
+    public T Item { get; }
+}

src/SharpCompress/Common/ArchiveType.cs

@@ -1,11 +1,10 @@
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public enum ArchiveType
 {
-    public enum ArchiveType
-    {
-        Rar,
-        Zip,
-        Tar,
-        SevenZip,
-        GZip
-    }
-}
+    Rar,
+    Zip,
+    Tar,
+    SevenZip,
+    GZip
+}

src/SharpCompress/Common/CompressedBytesReadEventArgs.cs

@@ -1,17 +1,25 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public sealed class CompressedBytesReadEventArgs : EventArgs
 {
-    public class CompressedBytesReadEventArgs : EventArgs
+    public CompressedBytesReadEventArgs(
+        long compressedBytesRead,
+        long currentFilePartCompressedBytesRead
+    )
     {
-        /// <summary>
-        /// Compressed bytes read for the current entry
-        /// </summary>
-        public long CompressedBytesRead { get; internal set; }
-
-        /// <summary>
-        /// Current file part read for Multipart files (e.g. Rar)
-        /// </summary>
-        public long CurrentFilePartCompressedBytesRead { get; internal set; }
+        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; }
+}

src/SharpCompress/Common/CompressionType.cs

@@ -1,19 +1,20 @@
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public enum CompressionType
 {
-    public enum CompressionType
-    {
-        None,
-        GZip,
-        BZip2,
-        PPMd,
-        Deflate,
-        Rar,
-        LZMA,
-        BCJ,
-        BCJ2,
-        LZip,
-        Xz,
-        Unknown,
-        Deflate64
-    }
-}
+    None,
+    GZip,
+    BZip2,
+    PPMd,
+    Deflate,
+    Rar,
+    LZMA,
+    BCJ,
+    BCJ2,
+    LZip,
+    Xz,
+    Unknown,
+    Deflate64,
+    Shrink,
+    Lzw
+}

src/SharpCompress/Common/CryptographicException.cs

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

src/SharpCompress/Common/Entry.cs

@@ -1,91 +1,90 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public abstract class Entry : IEntry
 {
-    public abstract class Entry : IEntry
-    {
-        /// <summary>
-        /// The File's 32 bit CRC Hash
-        /// </summary>
-        public abstract long Crc { get; }
+    /// <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; }
 
-        /// <inheritdoc/>
-        public override string ToString()
-        {
-            return Key;
-        }
+    public int VolumeIndexFirst => Parts?.FirstOrDefault()?.Index ?? 0;
+    public int VolumeIndexLast => Parts?.LastOrDefault()?.Index ?? 0;
 
-        internal abstract IEnumerable<FilePart> Parts { get; }
-        internal bool IsSolid { get; set; }
+    /// <inheritdoc/>
+    public override string ToString() => Key;
 
-        internal virtual void Close()
-        {
-        }
+    internal abstract IEnumerable<FilePart> Parts { get; }
 
-        /// <summary>
-        /// Entry file attribute.
-        /// </summary>
-        public virtual int? Attrib => throw new NotImplementedException();
-    }
+    public bool IsSolid { get; set; }
+
+    internal virtual void Close() { }
+
+    /// <summary>
+    /// Entry file attribute.
+    /// </summary>
+    public virtual int? Attrib => throw new NotImplementedException();
 }

src/SharpCompress/Common/EntryStream.cs

@@ -1,92 +1,86 @@
-using System;
+using System;
 using System.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public class EntryStream : Stream
 {
-    public class EntryStream : Stream
+    private readonly IReader _reader;
+    private readonly Stream _stream;
+    private bool _completed;
+    private bool _isDisposed;
+
+    internal EntryStream(IReader reader, Stream stream)
     {
-        private readonly IReader _reader;
-        private readonly Stream _stream;
-        private bool _completed;
-        private bool _isDisposed;
+        _reader = reader;
+        _stream = stream;
+    }
 
-        internal EntryStream(IReader reader, Stream stream)
+    /// <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))
         {
-            _reader = reader;
-            _stream = stream;
+            SkipEntry();
         }
-
-        /// <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()
+        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)
         {
-            this.Skip();
             _completed = true;
         }
-
-        protected override void Dispose(bool disposing)
-        {
-            if (!(_completed || _reader.Cancelled))
-            {
-                SkipEntry();
-            }
-            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)
-        {
-            int read = _stream.Read(buffer, offset, count);
-            if (read <= 0)
-            {
-                _completed = true;
-            }
-            return read;
-        }
-
-        public override int ReadByte()
-        {
-            int value = _stream.ReadByte();
-            if (value == -1)
-            {
-                _completed = true;
-            }
-            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();
-        }
+        return read;
     }
-}
+
+    public override int ReadByte()
+    {
+        var value = _stream.ReadByte();
+        if (value == -1)
+        {
+            _completed = true;
+        }
+        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();
+}

src/SharpCompress/Common/ExtractionException.cs

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

src/SharpCompress/Common/ExtractionMethods.cs

@@ -1,93 +1,117 @@
-using System;
+using System;
 using System.IO;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+internal static class ExtractionMethods
 {
-    internal static class ExtractionMethods
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteEntryToDirectory(
+        IEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options,
+        Action<string, ExtractionOptions?> write
+    )
     {
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteEntryToDirectory(IEntry entry, string destinationDirectory,
-                                                 ExtractionOptions options, Action<string, ExtractionOptions> write)
+        string destinationFileName;
+        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
+
+        //check for trailing slash.
+        if (
+            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
+            != Path.DirectorySeparatorChar
+        )
         {
-            string destinationFileName;
-            string file = Path.GetFileName(entry.Key);
-            string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
-
-            options = options ?? new ExtractionOptions()
-                                 {
-                                     Overwrite = true
-                                 };
-
-            if (options.ExtractFullPath)
-            {
-                string folder = Path.GetDirectoryName(entry.Key);
-                string destdir = Path.GetFullPath(
-                                                  Path.Combine(fullDestinationDirectoryPath, folder)
-                                                 );
-
-                if (!Directory.Exists(destdir))
-                {
-                    if (!destdir.StartsWith(fullDestinationDirectoryPath))
-                    {
-                        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))
-                {
-                    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);
-            }
+            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
         }
-        
-        public static void WriteEntryToFile(IEntry entry, string destinationFileName,
-                                            ExtractionOptions options,
-                                            Action<string, FileMode> openAndWrite)
+
+        if (!Directory.Exists(fullDestinationDirectoryPath))
         {
-            if (entry.LinkTarget != null)
-            {
-                if (null == options.WriteSymbolicLink)
-                {
-                    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 = options ?? new ExtractionOptions()
-                                     {
-                                         Overwrite = true
-                                     };
+            throw new ExtractionException(
+                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
+            );
+        }
 
-                if (!options.Overwrite)
+        options ??= new ExtractionOptions() { Overwrite = true };
+
+        var file = Path.GetFileName(entry.Key);
+        if (options.ExtractFullPath)
+        {
+            var folder = Path.GetDirectoryName(entry.Key)!;
+            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+
+            if (!Directory.Exists(destdir))
+            {
+                if (!destdir.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
                 {
-                    fm = FileMode.CreateNew;
+                    throw new ExtractionException(
+                        "Entry is trying to create a directory outside of the destination directory."
+                    );
                 }
 
-                openAndWrite(destinationFileName, fm);
-                entry.PreserveExtractionOptions(destinationFileName, options);
+                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."
+                );
+            }
+            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
+        {
+            var fm = FileMode.Create;
+            options ??= new ExtractionOptions() { Overwrite = true };
+
+            if (!options.Overwrite)
+            {
+                fm = FileMode.CreateNew;
+            }
+
+            openAndWrite(destinationFileName, fm);
+            entry.PreserveExtractionOptions(destinationFileName, options);
+        }
+    }
+}

src/SharpCompress/Common/ExtractionOptions.cs

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

src/SharpCompress/Common/FilePart.cs

@@ -1,20 +1,17 @@
-using System.IO;
+using System.IO;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public abstract class FilePart
 {
-    public abstract class FilePart
-    {
-        protected FilePart(ArchiveEncoding archiveEncoding)
-        {
-            ArchiveEncoding = archiveEncoding;
-        }
+    protected FilePart(ArchiveEncoding archiveEncoding) => ArchiveEncoding = archiveEncoding;
 
-        internal ArchiveEncoding ArchiveEncoding { get; }
+    internal ArchiveEncoding ArchiveEncoding { get; }
 
-        internal abstract string FilePartName { get; }
+    internal abstract string FilePartName { get; }
+    public int Index { get; set; }
 
-        internal abstract Stream GetCompressedStream();
-        internal abstract Stream GetRawStream();
-        internal bool Skipped { get; set; }
-    }
+    internal abstract Stream GetCompressedStream();
+    internal abstract Stream? GetRawStream();
+    internal bool Skipped { get; set; }
 }

src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs

@@ -1,22 +1,28 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public sealed class FilePartExtractionBeginEventArgs : EventArgs
 {
-    public class FilePartExtractionBeginEventArgs : EventArgs
+    public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize)
     {
-        /// <summary>
-        /// File name for the part for the current entry
-        /// </summary>
-        public string Name { get; internal set; }
-
-        /// <summary>
-        /// Uncompressed size of the current entry in the part
-        /// </summary>
-        public long Size { get; internal set; }
-
-        /// <summary>
-        /// Compressed size of the current entry in the part
-        /// </summary>
-        public long CompressedSize { get; internal set; }
+        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; }
+}

src/SharpCompress/Common/FlagUtility.cs

@@ -1,108 +1,86 @@
 using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+internal static class FlagUtility
 {
-    internal static class FlagUtility
+    /// <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)
     {
-        /// <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
+        if (on)
         {
-            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>
-        /// <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);
+            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 => SetFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag), on);
+}

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -1,50 +1,45 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 
-namespace SharpCompress.Common.GZip
+namespace SharpCompress.Common.GZip;
+
+public class GZipEntry : Entry
 {
-    public class GZipEntry : Entry
+    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)
     {
-        private readonly GZipFilePart _filePart;
-
-        internal GZipEntry(GZipFilePart filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override CompressionType CompressionType => CompressionType.GZip;
-
-        public override long Crc => 0;
-
-        public override string Key => _filePart.FilePartName;
-
-        public override string LinkTarget => null;
-
-        public override long CompressedSize => 0;
-
-        public override long Size => 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)
-        {
-            yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
-        }
+        yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
     }
-}
+}

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
@@ -6,114 +6,126 @@ using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 
-namespace SharpCompress.Common.GZip
+namespace SharpCompress.Common.GZip;
+
+internal sealed class GZipFilePart : FilePart
 {
-    internal class GZipFilePart : FilePart
-    {
-        private string _name;
-        private readonly Stream _stream;
+    private string? _name;
+    private readonly Stream _stream;
 
-        internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
+    internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
         : base(archiveEncoding)
+    {
+        _stream = stream;
+        ReadAndValidateGzipHeader();
+        if (stream.CanSeek)
         {
-            ReadAndValidateGzipHeader(stream);
-            EntryStartPosition = stream.Position;
-            _stream = stream;
+            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;
         }
 
-        internal long EntryStartPosition { get; }
-
-        internal DateTime? DateModified { get; private set; }
-
-        internal override string FilePartName => _name;
-
-        internal override Stream GetCompressedStream()
+        if (n != 10)
         {
-            return new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
+            throw new ZlibException("Not a valid GZIP stream.");
         }
 
-        internal override Stream GetRawStream()
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
         {
-            return _stream;
+            throw new ZlibException("Bad GZIP header.");
         }
 
-        private void ReadAndValidateGzipHeader(Stream stream)
+        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
+        DateModified = TarHeader.EPOCH.AddSeconds(timet);
+        if ((header[3] & 0x04) == 0x04)
         {
-            // read the header on the first read
-            byte[] header = new byte[10];
-            int n = stream.Read(header, 0, header.Length);
+            // read and discard extra field
+            n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
 
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
-            {
-                return;
-            }
+            var extraLength = (short)(header[0] + (header[1] * 256));
+            var extra = new byte[extraLength];
 
-            if (n != 10)
+            if (!_stream.ReadFully(extra))
             {
-                throw new ZlibException("Not a valid GZIP stream.");
-            }
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                throw new ZlibException("Bad GZIP header.");
-            }
-
-            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
-            DateModified = TarHeader.EPOCH.AddSeconds(timet);
-            if ((header[3] & 0x04) == 0x04)
-            {
-                // read and discard extra field
-                n = stream.Read(header, 0, 2); // 2-byte length field
-
-                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
-                byte[] extra = new byte[extraLength];
-
-                if (!stream.ReadFully(extra))
-                {
-                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
-                }
-                n = extraLength;
-            }
-            if ((header[3] & 0x08) == 0x08)
-            {
-                _name = ReadZeroTerminatedString(stream);
-            }
-            if ((header[3] & 0x10) == 0x010)
-            {
-                ReadZeroTerminatedString(stream);
-            }
-            if ((header[3] & 0x02) == 0x02)
-            {
-                stream.ReadByte(); // CRC16, ignore
+                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
             }
+            n = extraLength;
         }
-
-        private string ReadZeroTerminatedString(Stream stream)
+        if ((header[3] & 0x08) == 0x08)
         {
-            byte[] buf1 = new byte[1];
-            var list = new List<byte>();
-            bool done = false;
-            do
-            {
-                // workitem 7740
-                int n = stream.Read(buf1, 0, 1);
-                if (n != 1)
-                {
-                    throw new ZlibException("Unexpected EOF reading GZIP header.");
-                }
-                if (buf1[0] == 0)
-                {
-                    done = true;
-                }
-                else
-                {
-                    list.Add(buf1[0]);
-                }
-            }
-            while (!done);
-            byte[] buffer = list.ToArray();
-            return ArchiveEncoding.Decode(buffer);
+            _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
+        {
+            // 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);
+    }
 }

src/SharpCompress/Common/GZip/GZipVolume.cs

@@ -1,23 +1,17 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common.GZip
+namespace SharpCompress.Common.GZip;
+
+public class GZipVolume : Volume
 {
-    public class GZipVolume : Volume
-    {
-        public GZipVolume(Stream stream, ReaderOptions options)
-            : base(stream, options)
-        {
-        }
+    public GZipVolume(Stream stream, ReaderOptions options, int index = 0)
+        : base(stream, options, index) { }
 
-        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;
+}

src/SharpCompress/Common/IEntry.Extensions.cs

@@ -1,46 +1,48 @@
-using System.IO;
-using SharpCompress.Readers;
+using System.IO;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+internal static class EntryExtensions
 {
-    internal static class EntryExtensions
+    internal static void PreserveExtractionOptions(
+        this IEntry entry,
+        string destinationFileName,
+        ExtractionOptions options
+    )
     {
-        internal static void PreserveExtractionOptions(this IEntry entry, string destinationFileName,
-                                                        ExtractionOptions options)
+        if (options.PreserveFileTime || options.PreserveAttributes)
         {
-            if (options.PreserveFileTime || options.PreserveAttributes)
+            var nf = new FileInfo(destinationFileName);
+            if (!nf.Exists)
             {
-                FileInfo nf = new FileInfo(destinationFileName);
-                if (!nf.Exists)
+                return;
+            }
+
+            // update file time to original packed time
+            if (options.PreserveFileTime)
+            {
+                if (entry.CreatedTime.HasValue)
                 {
-                    return;
+                    nf.CreationTime = entry.CreatedTime.Value;
                 }
 
-                // update file time to original packed time
-                if (options.PreserveFileTime)
+                if (entry.LastModifiedTime.HasValue)
                 {
-                    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;
-                    }
+                    nf.LastWriteTime = entry.LastModifiedTime.Value;
                 }
 
-                if (options.PreserveAttributes)
+                if (entry.LastAccessedTime.HasValue)
                 {
-                    if (entry.Attrib.HasValue)
-                    {
-                        nf.Attributes = (FileAttributes)System.Enum.ToObject(typeof(FileAttributes), entry.Attrib.Value);
-                    }
+                    nf.LastAccessTime = entry.LastAccessedTime.Value;
+                }
+            }
+
+            if (options.PreserveAttributes)
+            {
+                if (entry.Attrib.HasValue)
+                {
+                    nf.Attributes = (FileAttributes)
+                        System.Enum.ToObject(typeof(FileAttributes), entry.Attrib.Value);
                 }
             }
         }

src/SharpCompress/Common/IEntry.cs

@@ -1,22 +1,24 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public interface IEntry
 {
-    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; }
-    }
-}
+    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; }
+}

src/SharpCompress/Common/IExtractionListener.cs

@@ -1,8 +1,7 @@
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public interface IExtractionListener
 {
-    internal interface IExtractionListener
-    {
-        void FireFilePartExtractionBegin(string name, long size, long compressedSize);
-        void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes);
-    }
-}
+    void FireFilePartExtractionBegin(string name, long size, long compressedSize);
+    void FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes);
+}

src/SharpCompress/Common/IVolume.cs

@@ -1,8 +1,10 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public interface IVolume : IDisposable
 {
-    public interface IVolume : IDisposable
-    {
-    }
-}
+    int Index { get; }
+
+    string FileName { get; }
+}

src/SharpCompress/Common/IncompleteArchiveException.cs

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

src/SharpCompress/Common/InvalidFormatException.cs

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

src/SharpCompress/Common/MultiVolumeExtractionException.cs

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

src/SharpCompress/Common/MultipartStreamRequiredException.cs

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

src/SharpCompress/Common/OptionsBase.cs

@@ -1,13 +1,11 @@
-
-namespace SharpCompress.Common
-{
-    public class OptionsBase
-    {
-        /// <summary>
-        /// SharpCompress will keep the supplied streams open.  Default is true.
-        /// </summary>
-        public bool LeaveStreamOpen { get; set; } = true;
+namespace SharpCompress.Common;
 
-        public ArchiveEncoding ArchiveEncoding { get; set; } = new ArchiveEncoding();
-    }
-}
+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();
+}

src/SharpCompress/Common/PasswordProtectedException.cs

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

src/SharpCompress/Common/Rar/CryptKey3.cs

@@ -0,0 +1,84 @@
+#nullable disable
+
+using System.Security.Cryptography;
+using System.Text;
+using SharpCompress.Common.Rar.Headers;
+
+namespace SharpCompress.Common.Rar;
+
+internal class CryptKey3 : ICryptKey
+{
+    const int AES_128 = 128;
+
+    private string _password;
+
+    public CryptKey3(string password) => _password = password ?? "";
+
+    public ICryptoTransform Transformer(byte[] salt)
+    {
+        var aesIV = new byte[EncryptionConstV5.SIZE_INITV];
+
+        var rawLength = 2 * _password.Length;
+        var rawPassword = new byte[rawLength + EncryptionConstV5.SIZE_SALT30];
+        var passwordBytes = Encoding.UTF8.GetBytes(_password);
+        for (var i = 0; i < _password.Length; i++)
+        {
+            rawPassword[i * 2] = passwordBytes[i];
+            rawPassword[(i * 2) + 1] = 0;
+        }
+
+        for (var i = 0; i < salt.Length; i++)
+        {
+            rawPassword[i + rawLength] = salt[i];
+        }
+
+        var msgDigest = SHA1.Create();
+        const int noOfRounds = (1 << 18);
+        const int iblock = 3;
+
+        byte[] digest;
+        var data = new byte[(rawPassword.Length + iblock) * noOfRounds];
+
+        //TODO slow code below, find ways to optimize
+        for (var i = 0; i < noOfRounds; i++)
+        {
+            rawPassword.CopyTo(data, i * (rawPassword.Length + iblock));
+
+            data[(i * (rawPassword.Length + iblock)) + rawPassword.Length + 0] = (byte)i;
+            data[(i * (rawPassword.Length + iblock)) + rawPassword.Length + 1] = (byte)(i >> 8);
+            data[(i * (rawPassword.Length + iblock)) + rawPassword.Length + 2] = (byte)(i >> 16);
+
+            if (i % (noOfRounds / EncryptionConstV5.SIZE_INITV) == 0)
+            {
+                digest = msgDigest.ComputeHash(data, 0, (i + 1) * (rawPassword.Length + iblock));
+                aesIV[i / (noOfRounds / EncryptionConstV5.SIZE_INITV)] = digest[19];
+            }
+        }
+        digest = msgDigest.ComputeHash(data);
+        //slow code ends
+
+        var aesKey = new byte[EncryptionConstV5.SIZE_INITV];
+        for (var i = 0; i < 4; i++)
+        {
+            for (var j = 0; j < 4; j++)
+            {
+                aesKey[(i * 4) + j] = (byte)(
+                    (
+                        ((digest[i * 4] * 0x1000000) & 0xff000000)
+                        | (uint)((digest[(i * 4) + 1] * 0x10000) & 0xff0000)
+                        | (uint)((digest[(i * 4) + 2] * 0x100) & 0xff00)
+                        | (uint)(digest[(i * 4) + 3] & 0xff)
+                    ) >> (j * 8)
+                );
+            }
+        }
+
+        var aes = Aes.Create();
+        aes.KeySize = AES_128;
+        aes.Mode = CipherMode.CBC;
+        aes.Padding = PaddingMode.None;
+        aes.Key = aesKey;
+        aes.IV = aesIV;
+        return aes.CreateDecryptor();
+    }
+}

src/SharpCompress/Common/Rar/CryptKey5.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using SharpCompress.Common.Rar.Headers;
+
+namespace SharpCompress.Common.Rar;
+
+internal class CryptKey5 : ICryptKey
+{
+    const int AES_256 = 256;
+    const int DERIVED_KEY_LENGTH = 0x10;
+    const int SHA256_DIGEST_SIZE = 32;
+
+    private string _password;
+    private Rar5CryptoInfo _cryptoInfo;
+    private byte[] _pswCheck = { };
+    private byte[] _hashKey = { };
+
+    public CryptKey5(string password, Rar5CryptoInfo rar5CryptoInfo)
+    {
+        _password = password ?? "";
+        _cryptoInfo = rar5CryptoInfo;
+    }
+
+    public byte[] PswCheck => _pswCheck;
+
+    public byte[] HashKey => _hashKey;
+
+    private static List<byte[]> GenerateRarPBKDF2Key(
+        string password,
+        byte[] salt,
+        int iterations,
+        int keyLength
+    )
+    {
+        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(password));
+        var block = hmac.ComputeHash(salt);
+        var finalHash = (byte[])block.Clone();
+
+        var loop = new int[] { iterations, 17, 17 };
+        var res = new List<byte[]> { };
+
+        for (var x = 0; x < 3; x++)
+        {
+            for (var i = 1; i < loop[x]; i++)
+            {
+                block = hmac.ComputeHash(block);
+                for (var j = 0; j < finalHash.Length; j++)
+                {
+                    finalHash[j] ^= block[j];
+                }
+            }
+
+            res.Add((byte[])finalHash.Clone());
+        }
+
+        return res;
+    }
+
+    public ICryptoTransform Transformer(byte[] salt)
+    {
+        var iterations = (1 << _cryptoInfo.LG2Count); // Adjust the number of iterations as needed
+
+        var salt_rar5 = salt.Concat(new byte[] { 0, 0, 0, 1 });
+        var derivedKey = GenerateRarPBKDF2Key(
+            _password,
+            salt_rar5.ToArray(),
+            iterations,
+            DERIVED_KEY_LENGTH
+        );
+
+        _hashKey = derivedKey[1];
+
+        _pswCheck = new byte[EncryptionConstV5.SIZE_PSWCHECK];
+
+        for (var i = 0; i < SHA256_DIGEST_SIZE; i++)
+        {
+            _pswCheck[i % EncryptionConstV5.SIZE_PSWCHECK] ^= derivedKey[2][i];
+        }
+
+        if (_cryptoInfo.UsePswCheck && !_cryptoInfo.PswCheck.SequenceEqual(_pswCheck))
+        {
+            throw new CryptographicException("The password did not match.");
+        }
+
+        var aes = Aes.Create();
+        aes.KeySize = AES_256;
+        aes.Mode = CipherMode.CBC;
+        aes.Padding = PaddingMode.None;
+        aes.Key = derivedKey[0];
+        aes.IV = _cryptoInfo.InitV;
+        return aes.CreateDecryptor();
+    }
+}

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

@@ -1,30 +1,31 @@
-using SharpCompress.IO;
+using SharpCompress.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+internal class AvHeader : RarHeader
 {
-    internal class AvHeader : RarHeader
+    public AvHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Av)
     {
-        public AvHeader(RarHeader header, RarCrcBinaryReader reader) 
-            : base(header, reader, HeaderType.Av) 
+        if (IsRar5)
         {
-            if (IsRar5) 
-                throw new InvalidFormatException("unexpected rar5 record");
+            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; }
+}

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

@@ -1,57 +1,19 @@
-using SharpCompress.IO;
+#nullable disable
 
-namespace SharpCompress.Common.Rar.Headers
+using System;
+using System.Security.Cryptography;
+using SharpCompress.Common.Rar.Headers;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal class ArchiveCryptHeader : RarHeader
 {
-    internal class ArchiveCryptHeader : RarHeader
-    {
-        
-        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)
-        {
-        }
+    public ArchiveCryptHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Crypt) { }
 
-        protected override void ReadFinish(MarkingBinaryReader reader)
-        {
-            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);
+    public Rar5CryptoInfo CryptInfo = new();
 
-            
-            //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);
-            }
-        }
-    }
-}
+    protected override void ReadFinish(MarkingBinaryReader reader) =>
+        CryptInfo = new Rar5CryptoInfo(reader, false);
+}

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

@@ -1,81 +1,59 @@
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+internal sealed class ArchiveHeader : RarHeader
 {
-    internal class ArchiveHeader : RarHeader
+    public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Archive) { }
+
+    protected override void ReadFinish(MarkingBinaryReader reader)
     {
-        public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader) 
-            : base(header, reader, HeaderType.Archive) 
+        if (IsRar5)
         {
-        }
-
-        protected override void ReadFinish(MarkingBinaryReader reader)
-        {
-            if (IsRar5) 
+            Flags = reader.ReadRarVIntUInt16();
+            if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
             {
-                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();
-                }
+                VolumeNumber = (int)reader.ReadRarVIntUInt32();
             }
+            // later: we may have a locator record if we need it
+            //if (ExtraSize != 0) {
+            //    ReadLocator(reader);
+            //}
         }
-
-        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) 
+        else
         {
-            return (Flags & flag) == flag;
+            Flags = HeaderFlags;
+            HighPosAv = reader.ReadInt16();
+            PosAv = reader.ReadInt32();
+            if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
+            {
+                EncryptionVersion = reader.ReadByte();
+            }
         }
-
-        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 == 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);
+}

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

@@ -1,28 +1,30 @@
-using SharpCompress.IO;
+using SharpCompress.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+internal class CommentHeader : RarHeader
 {
-    internal class CommentHeader : RarHeader
+    protected CommentHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Comment)
     {
-        protected CommentHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.Comment) 
-        { 
-            if (IsRar5) throw new InvalidFormatException("unexpected rar5 record");
-        }
-
-        protected override void ReadFinish(MarkingBinaryReader reader)
+        if (IsRar5)
         {
-            UnpSize = reader.ReadInt16();
-            UnpVersion = reader.ReadByte();
-            UnpMethod = reader.ReadByte();
-            CommCrc = reader.ReadInt16();
+            throw new InvalidFormatException("unexpected rar5 record");
         }
-
-        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; }
+}

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

@@ -1,43 +1,37 @@
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+internal class EndArchiveHeader : RarHeader
 {
-    internal class EndArchiveHeader : RarHeader
+    public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.EndArchive) { }
+
+    protected override void ReadFinish(MarkingBinaryReader reader)
     {
-        public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader) 
-            : base(header, reader, HeaderType.EndArchive) 
+        if (IsRar5)
         {
+            Flags = reader.ReadRarVIntUInt16();
         }
-
-        protected override void ReadFinish(MarkingBinaryReader reader)
+        else
         {
-            if (IsRar5) 
+            Flags = HeaderFlags;
+            if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
             {
-                Flags = reader.ReadRarVIntUInt16();
+                ArchiveCrc = reader.ReadInt32();
             }
-            else
+            if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
             {
-                Flags = HeaderFlags;
-                if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
-                {
-                    ArchiveCrc = reader.ReadInt32();
-                }
-                if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
-                {
-                    VolumeNumber = reader.ReadInt16();
-                }
+                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; }
+}

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

@@ -1,6 +1,12 @@
+#nullable disable
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using SharpCompress.IO;
 #if !Rar2017_64bit
-using nint = System.Int32;
-using nuint = System.UInt32;
 using size_t = System.UInt32;
 #else
 using nint = System.Int64;
@@ -8,436 +14,470 @@ using nuint = System.UInt64;
 using size_t = System.UInt64;
 #endif
 
-using SharpCompress.IO;
-using System;
-using System.IO;
-using System.Text;
+namespace SharpCompress.Common.Rar.Headers;
 
-namespace SharpCompress.Common.Rar.Headers
+internal class FileHeader : RarHeader
 {
-    internal class FileHeader : RarHeader
+    private byte[] _hash;
+
+    public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
+        : base(header, reader, headerType) { }
+
+    protected override void ReadFinish(MarkingBinaryReader reader)
     {
-        private uint _fileCrc;
-
-        public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType) 
-            : base(header, reader, headerType) 
+        if (IsRar5)
         {
+            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());
         }
 
-        protected override void ReadFinish(MarkingBinaryReader reader) 
+        if (HasFlag(FileFlagsV5.HAS_CRC32))
         {
-            if (IsRar5) 
-            {
-                ReadFromReaderV5(reader);
-            } 
-            else 
-            {
-                ReadFromReaderV4(reader);
-            }
+            FileCrc = reader.ReadBytes(4);
         }
 
-        private void ReadFromReaderV5(MarkingBinaryReader reader)
+        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))
         {
-            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)) {
-                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();
-                int n = RemainingHeaderBytes(reader);
-                var type = reader.ReadRarVIntUInt16();
-                switch (type) {
-                    //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
-                        {
-                            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;
-            }
+            throw new InvalidFormatException("rar5 header size / extra size inconsistency");
         }
 
+        const ushort FHEXTRA_CRYPT = 0x01;
+        const ushort FHEXTRA_HASH = 0x02;
+        const ushort FHEXTRA_HTIME = 0x03;
+        // const ushort FHEXTRA_VERSION = 0x04;
+        const ushort FHEXTRA_REDIR = 0x05;
+        // const ushort FHEXTRA_UOWNER = 0x06;
+        // const ushort FHEXTRA_SUBDATA = 0x07;
 
-        private static DateTime ReadExtendedTimeV5(MarkingBinaryReader reader, bool isWindowsTime) 
+        while (RemainingHeaderBytes(reader) > 0)
         {
-            if (isWindowsTime) 
+            var size = reader.ReadRarVIntUInt16();
+            var n = RemainingHeaderBytes(reader);
+            var type = reader.ReadRarVIntUInt16();
+            switch (type)
             {
-                return DateTime.FromFileTime(reader.ReadInt64());
-            } 
-            else 
-            {
-                return Utility.UnixTimeToDateTime(reader.ReadUInt32());
-            }
-        }
+                case FHEXTRA_CRYPT: // file encryption
 
-        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))
+                        Rar5CryptoInfo = new Rar5CryptoInfo(reader, true);
+
+                        if (Rar5CryptoInfo.PswCheck.All(singleByte => singleByte == 0))
                         {
-                            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);
-                            }
+                            Rar5CryptoInfo = null;
+                        }
+                    }
+                    break;
+                case FHEXTRA_HASH:
+
+                    {
+                        const uint FHEXTRA_HASH_BLAKE2 = 0x0;
+                        //                        const uint HASH_BLAKE2 = 0x03;
+                        const int BLAKE2_DIGEST_SIZE = 0x20;
+                        if ((uint)reader.ReadRarVInt() == FHEXTRA_HASH_BLAKE2)
+                        {
+                            //                            var hash = HASH_BLAKE2;
+                            _hash = reader.ReadBytes(BLAKE2_DIGEST_SIZE);
+                        }
+                        // enum HASH_TYPE {HASH_NONE,HASH_RAR14,HASH_CRC32,HASH_BLAKE2};
+                    }
+                    break;
+                case FHEXTRA_HTIME: // 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 FHEXTRA_VERSION: // file version
+                //                        {
+                //
+                //                        }
+                //                        break;
+                case FHEXTRA_REDIR: // file system redirection
+
+                    {
+                        RedirType = reader.ReadRarVIntByte();
+                        RedirFlags = reader.ReadRarVIntByte();
+                        var nn = reader.ReadRarVIntUInt16();
+                        var bb = reader.ReadBytes(nn);
+                        RedirTargetName = ConvertPathV5(Encoding.UTF8.GetString(bb, 0, bb.Length));
+                    }
+                    break;
+                //TODO
+                //                    case FHEXTRA_UOWNER: // unix owner
+                //                        {
+                //
+                //                        }
+                //                        break;
+                //                    case FHEXTRA_SUBDATA: // service data
+                //                        {
+                //
+                //                        }
+                //                        break;
+
+                default:
+                    // skip unknown record types to allow new record types to be added in the future
+                    //Console.WriteLine($"unhandled rar header field type {type}");
+                    break;
+            }
+            // drain any trailing bytes of extra record
+            var did = n - RemainingHeaderBytes(reader);
+            var 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);
+
+        var lowUncompressedSize = reader.ReadUInt32();
+
+        HostOs = reader.ReadByte();
+
+        FileCrc = reader.ReadBytes(4);
+
+        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)
+            {
+                lowUncompressedSize = 0xffffffff;
+                highUncompressedkSize = int.MaxValue;
+            }
+        }
+        CompressedSize = UInt32To64(highCompressedSize, checked((uint)AdditionalDataSize));
+        UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
+
+        nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
+
+        var fileNameBytes = reader.ReadBytes(nameSize);
+
+        const int newLhdSize = 32;
+
+        switch (HeaderCode)
+        {
+            case HeaderCodeV.RAR4_FILE_HEADER:
+
+                {
+                    if (HasFlag(FileFlagsV4.UNICODE))
+                    {
+                        var length = 0;
+                        while (length < fileNameBytes.Length && fileNameBytes[length] != 0)
+                        {
+                            length++;
+                        }
+                        if (length != nameSize)
+                        {
+                            length++;
+                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
                         }
                         else
                         {
                             FileName = ArchiveEncoding.Decode(fileNameBytes);
                         }
-                        FileName = ConvertPathV4(FileName);
                     }
-                    break;
-                case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+                    else
                     {
-                        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);
-                        }
+                        FileName = ArchiveEncoding.Decode(fileNameBytes);
                     }
-                    break;
-            }
+                    FileName = ConvertPathV4(FileName);
+                }
+                break;
+            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
 
-            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)
                 {
-                    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);
+                    var datasize = HeaderSize - newLhdSize - nameSize;
+                    if (HasFlag(FileFlagsV4.SALT))
+                    {
+                        datasize -= EncryptionConstV5.SIZE_SALT30;
+                    }
+                    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;
         }
 
-        private static long UInt32To64(uint x, uint y)
+        if (HasFlag(FileFlagsV4.SALT))
         {
-            long l = x;
-            l <<= 32;
-            return l + y;
+            R4Salt = reader.ReadBytes(EncryptionConstV5.SIZE_SALT30);
         }
-
-        private static DateTime? ProcessExtendedTimeV4(ushort extendedFlags, DateTime? time, MarkingBinaryReader reader, int i)
+        if (HasFlag(FileFlagsV4.EXT_TIME))
         {
-            uint rmode = (uint)extendedFlags >> (3 - i) * 4;
-            if ((rmode & 8) == 0)
+            // 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)
             {
-                return null;
+                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);
             }
-            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 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 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; }
     }
-}
+
+    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)
+        {
+            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));
+        }
+
+        //10^-7 to 10^-3
+        return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
+    }
+
+    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() => FileName;
+
+    private ushort Flags { get; set; }
+
+    private bool HasFlag(ushort flag) => (Flags & flag) == flag;
+
+    internal byte[] FileCrc
+    {
+        get => _hash;
+        private set => _hash = 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; }
+
+    public byte RedirType { get; private set; }
+    public bool IsRedir => RedirType != 0;
+    public byte RedirFlags { get; private set; }
+    public bool IsRedirDirectory => (RedirFlags & RedirFlagV5.DIRECTORY) != 0;
+    public string RedirTargetName { get; private set; }
+
+    // unused for UnpackV1 implementation (limitation)
+    internal size_t WindowSize { get; private set; }
+
+    internal byte[] R4Salt { get; private set; }
+    internal Rar5CryptoInfo Rar5CryptoInfo { get; private set; }
+    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);
+
+    public bool IsEncrypted => IsRar5 ? Rar5CryptoInfo != null : 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; }
+}

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

@@ -1,78 +1,78 @@
 using System.Text;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+/// <summary>
+/// This is for the crazy Rar encoding that I don't understand
+/// </summary>
+internal static class FileNameDecoder
 {
-    /// <summary>
-    /// This is for the crazy Rar encoding that I don't understand
-    /// </summary>
-    internal static class FileNameDecoder
+    internal static int GetChar(byte[] name, int pos) => name[pos] & 0xff;
+
+    internal static string Decode(byte[] name, int encPos)
     {
-        internal static int GetChar(byte[] name, int pos)
-        {
-            return name[pos] & 0xff;
-        }
+        var decPos = 0;
+        var flags = 0;
+        var flagBits = 0;
 
-        internal static string Decode(byte[] name, int encPos)
+        var low = 0;
+        var high = 0;
+        var highByte = GetChar(name, encPos++);
+        var buf = new StringBuilder();
+        while (encPos < name.Length)
         {
-            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)
             {
-                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;
+                flags = GetChar(name, encPos++);
+                flagBits = 8;
             }
-            return buf.ToString();
+            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 buf.ToString();
     }
-}
+}

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

@@ -1,149 +1,173 @@
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+public enum HeaderType : byte
 {
-    internal enum HeaderType : byte
-    {
-        Null,
-        Mark,
-        Archive,
-        File,
-        Service,
-        Comment,
-        Av,
-        Protect,
-        Sign,
-        NewSub,
-        EndArchive,
-        Crypt
-    }
+    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.
-        
-        public const uint FHEXTRA_CRYPT_PSWCHECK = 0x01; // Password check data is present.
-        public const uint FHEXTRA_CRYPT_HASHMAC = 0x02;
-    }
+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 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
-    }
+    public const uint FHEXTRA_CRYPT_PSWCHECK = 0x01; // Password check data is present.
+    public const uint FHEXTRA_CRYPT_HASHMAC = 0x02;
+}
 
-    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 EncryptionConstV5
+{
+    public const int VERSION = 0;
+    public const uint CRYPT5_KDF_LG2_COUNT_MAX = 0x24;
+    public const int SIZE_SALT30 = 0x08;
+    public const int SIZE_SALT50 = 0x10;
+    public const int SIZE_INITV = 0x10;
+    public const int SIZE_PSWCHECK = 0x08;
+    public const int SIZE_PSWCHECK_CSUM = 0x04;
+}
 
-    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 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 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 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 HostOsV5
-    {
-        public const byte WINDOWS = 0;
-        public const byte UNIX = 1;
-    }
+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 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 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;
+}
 
-        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;
+internal static class HostOsV5
+{
+    public const byte WINDOWS = 0;
+    public const byte UNIX = 1;
+}
 
-        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 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 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;
-    }
+    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;
 
-    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;
-    }
+    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 EndArchiveFlagsV5
-    {
-        public const ushort HAS_NEXT_VOLUME = 0x0001;
-    }
-}
+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 EndArchiveFlagsV5
+{
+    public const ushort HAS_NEXT_VOLUME = 0x0001;
+}
+
+internal static class RedirTypeV5
+{
+    public const byte UNIX_SYMLINK = 0x0001;
+    public const byte WIN_SYMLINK = 0x0002;
+    public const byte WIN_JUNCTION = 0x0003;
+    public const byte HARD_LINK = 0x0004;
+    public const byte FILE_COPY = 0x0005;
+}
+
+internal static class RedirFlagV5
+{
+    public const byte DIRECTORY = 0x0001;
+}

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

@@ -1,7 +1,6 @@
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+public interface IRarHeader
 {
-    internal interface IRarHeader 
-    {
-        HeaderType HeaderType { get; }
-    }
-}
+    HeaderType HeaderType { get; }
+}

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

@@ -1,96 +1,132 @@
 using System;
 using System.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+internal class MarkHeader : IRarHeader
 {
-    internal class MarkHeader : IRarHeader
+    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)
     {
-        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) 
+        var b = stream.ReadByte();
+        if (b != -1)
         {
-            var b = stream.ReadByte();
-            if (b != -1) 
-            {
-                return (byte)b;
-            }
-            throw new EndOfStreamException();
+            return (byte)b;
         }
+        throw new EndOfStreamException();
+    }
 
-        public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader) 
+    public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
+    {
+        var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
+        try
         {
-            int maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
-            try
+            var start = -1;
+            var b = GetByte(stream);
+            start++;
+            while (start <= maxScanIndex)
             {
-                int start = -1;
-                var b = GetByte(stream); start++;
-                while (start <= maxScanIndex) 
+                // 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)
                 {
-                    // 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 == 0x61)
                     {
-                        b = GetByte(stream); start++;
-                        if (b == 0x61) 
+                        b = GetByte(stream);
+                        start++;
+                        if (b != 0x72)
                         {
-                            b = GetByte(stream); start++;
-                            if (b != 0x72) 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;
+                            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 == 0x45) 
+                        b = GetByte(stream);
+                        start++;
+                        if (b != 0x21)
                         {
-                            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 
+                            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 == 0x45)
                     {
-                        b = GetByte(stream); start++;
+                        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."
+                        );
                     }
                 }
-            }
-            catch (Exception e)
-            {
-                if (!leaveStreamOpen)
+                else
                 {
-                    stream.Dispose();
+                    b = GetByte(stream);
+                    start++;
                 }
-                throw new InvalidFormatException("Error trying to read rar signature.", e);
             }
-
-            throw new InvalidFormatException("Rar signature not found");
         }
+        catch (Exception e)
+        {
+            if (!leaveStreamOpen)
+            {
+                stream.Dispose();
+            }
+            throw new InvalidFormatException("Error trying to read rar signature.", e);
+        }
+
+        throw new InvalidFormatException("Rar signature not found");
     }
 }

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

@@ -1,55 +1,45 @@
 using System;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+internal sealed class NewSubHeaderType : IEquatable<NewSubHeaderType>
 {
-    internal class NewSubHeaderType : IEquatable<NewSubHeaderType>
+    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 static readonly NewSubHeaderType SUBHEAD_TYPE_CMT = new NewSubHeaderType('C', 'M', 'T');
-
-        //internal static final NewSubHeaderType SUBHEAD_TYPE_ACL = new NewSubHeaderType(new byte[]{'A','C','L'});
-
-        //internal static final NewSubHeaderType SUBHEAD_TYPE_STREAM = new NewSubHeaderType(new byte[]{'S','T','M'});
-
-        //internal static final NewSubHeaderType SUBHEAD_TYPE_UOWNER = new NewSubHeaderType(new byte[]{'U','O','W'});
-
-        //internal static final NewSubHeaderType SUBHEAD_TYPE_AV = new NewSubHeaderType(new byte[]{'A','V'});
-
-        internal static readonly NewSubHeaderType SUBHEAD_TYPE_RR = new NewSubHeaderType('R', 'R');
-
-        //internal static final NewSubHeaderType SUBHEAD_TYPE_OS2EA = new NewSubHeaderType(new byte[]{'E','A','2'});
-
-        //internal static final NewSubHeaderType SUBHEAD_TYPE_BEOSEA = new NewSubHeaderType(new byte[]{'E','A','B','E'});
-
-        private readonly byte[] _bytes;
-
-        private NewSubHeaderType(params char[] chars)
+        _bytes = new byte[chars.Length];
+        for (var i = 0; i < chars.Length; ++i)
         {
-            _bytes = new byte[chars.Length];
-            for (int i = 0; i < chars.Length; ++i)
-            {
-                _bytes[i] = (byte)chars[i];
-            }
-        }
-
-        internal bool Equals(byte[] bytes)
-        {
-            if (_bytes.Length != bytes.Length)
-            {
-                return false;
-            }
-            for (int i = 0; i < bytes.Length; ++i)
-            {
-                if (_bytes[i] != bytes[i])
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        public bool Equals(NewSubHeaderType other)
-        {
-            return Equals(other._bytes);
+            _bytes[i] = (byte)chars[i];
         }
     }
-}
+
+    internal bool Equals(byte[] bytes)
+    {
+        if (_bytes.Length != bytes.Length)
+        {
+            return false;
+        }
+
+        return _bytes.AsSpan().SequenceEqual(bytes);
+    }
+
+    public bool Equals(NewSubHeaderType? other) => other is not null && Equals(other._bytes);
+}

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

@@ -1,28 +1,30 @@
-using SharpCompress.IO;
+using SharpCompress.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+namespace SharpCompress.Common.Rar.Headers;
+
+// ProtectHeader is part of the Recovery Record feature
+internal sealed class ProtectHeader : RarHeader
 {
-    // ProtectHeader is part of the Recovery Record feature
-    internal class ProtectHeader : RarHeader
+    public ProtectHeader(RarHeader header, RarCrcBinaryReader reader)
+        : base(header, reader, HeaderType.Protect)
     {
-        public ProtectHeader(RarHeader header, RarCrcBinaryReader reader) 
-            : base(header, reader, HeaderType.Protect) 
+        if (IsRar5)
         {
-            if (IsRar5) throw new InvalidFormatException("unexpected rar5 record");
+            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);
-        }
-
-        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; }
     }
-}
+
+    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; }
+}

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

@@ -1,130 +1,130 @@
-using System;
+using System;
 using System.IO;
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Rar.Headers
+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
 {
-    // http://www.forensicswiki.org/w/images/5/5b/RARFileStructure.txt
-    // https://www.rarlab.com/technote.htm
-    internal class RarHeader : IRarHeader
+    private readonly HeaderType _headerType;
+    private readonly bool _isRar5;
+
+    internal static RarHeader? TryReadBase(
+        RarCrcBinaryReader reader,
+        bool isRar5,
+        ArchiveEncoding archiveEncoding
+    )
     {
-        private readonly HeaderType _headerType;
-        private readonly bool _isRar5;
-
-        internal static RarHeader TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
+        try
         {
-            try
-            {
-                return new RarHeader(reader, isRar5, archiveEncoding);
-            }
-            catch (EndOfStreamException)
-            {
-                return null;
-            }
+            return new RarHeader(reader, isRar5, archiveEncoding);
         }
-
-        private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding) 
+        catch (EndOfStreamException)
         {
-            _headerType = HeaderType.Null;
-            _isRar5 = isRar5;
-            ArchiveEncoding = archiveEncoding;
-            if (IsRar5) 
-            {
-                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();
-                }
-            }
+            return null;
         }
-
-        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);
-
-            int n = RemainingHeaderBytes(reader);
-            if (n > 0)
-            {
-                reader.ReadBytes(n);
-            }
-
-            VerifyHeaderCrc(reader.GetCrc32());
-        }
-
-        protected int RemainingHeaderBytes(MarkingBinaryReader reader) {
-            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; }
     }
-}
+
+    private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
+    {
+        _headerType = HeaderType.Null;
+        _isRar5 = isRar5;
+        ArchiveEncoding = archiveEncoding;
+        if (IsRar5)
+        {
+            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)
+        {
+            reader.ReadBytes(n);
+        }
+
+        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)
+        {
+            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) => (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; }
+}