Mark for 0.36.0

Add support for the UnixTimeExtraField in Zip files

.config/dotnet-tools.json

@@ -2,10 +2,10 @@
   "version": 1,
   "isRoot": true,
   "tools": {
-    "dotnet-format": {
-      "version": "4.1.131201",
+    "csharpier": {
+      "version": "0.26.7",
       "commands": [
-        "dotnet-format"
+        "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, pull_request]
+on:
+  push:
+    branches:
+      - 'master'
+  pull_request:
+    types: [ opened, synchronize, reopened, ready_for_review ]
 
 jobs:
   build:
@@ -9,16 +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: 5.0.101
-    - run: dotnet run -p build/build.csproj
-    - uses: actions/upload-artifact@v2
+        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/*
-    - uses: actions/upload-artifact@v2
-      with:
-        name: ${{ matrix.os }}-sharpcompress.snupkg
-        path: artifacts/*

.gitignore

@@ -18,3 +18,4 @@ tools
 
 .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>

README.md

@@ -5,7 +5,8 @@ SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1, .N
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
 GitHub Actions Build -
-[![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?
 
@@ -35,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)
@@ -182,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}"
@@ -15,6 +13,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress.Test", "tests
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "build", "build\build.csproj", "{D4D613CB-5E94-47FB-85BE-B8423D20C545}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB42573-7D22-4490-BA12-1B7FB99CE7FB}"
+	ProjectSection(SolutionItems) = preProject
+		Directory.Build.props = Directory.Build.props
+		global.json = global.json
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

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}");
 }
-```
+```

build/Program.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
@@ -6,78 +6,90 @@ using GlobExpressions;
 using static Bullseye.Targets;
 using static SimpleExec.Command;
 
-class Program
-{
-    private const string Clean = "clean";
-    private const string Format = "format";
-    private const string Build = "build";
-    private const string Test = "test";
-    private const string Publish = "publish";
+const string Clean = "clean";
+const string Restore = "restore";
+const string Build = "build";
+const string Test = "test";
+const string Format = "format";
+const string Publish = "publish";
 
-    static void Main(string[] args)
+Target(
+    Clean,
+    ForEach("**/bin", "**/obj"),
+    dir =>
     {
-        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, () =>
+        IEnumerable<string> GetDirectories(string d)
         {
-            Run("dotnet", "tool restore");
-            Run("dotnet", "format --check");
-        });
+            return Glob.Directories(".", d);
+        }
 
-        Target(Build, DependsOn(Format),
-               framework =>
-               {
-                   if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net46")
-                   {
-                       return;
-                   }
-                   Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release");
-               });
+        void RemoveDirectory(string d)
+        {
+            if (Directory.Exists(d))
+            {
+                Console.WriteLine(d);
+                Directory.Delete(d, true);
+            }
+        }
 
-        Target(Test, DependsOn(Build), ForEach("net5.0"),
-               framework =>
-               {
-                   IEnumerable<string> GetFiles(string d)
-                   {
-                       return Glob.Files(".", d);
-                   }
-
-                   foreach (var file in GetFiles("**/*.Test.csproj"))
-                   {
-                       Run("dotnet", $"test {file} -c Release -f {framework}");
-                   }
-               });
-
-        Target(Publish, DependsOn(Test),
-               () =>
-               {
-                   Run("dotnet", "pack src/SharpCompress/SharpCompress.csproj -c Release -o artifacts/");
-               });
-
-        Target("default", DependsOn(Publish), () => Console.WriteLine("Done!"));
-
-        RunTargetsAndExit(args);
+        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

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

@@ -1,5 +1,6 @@
 {
   "sdk": {
-    "version": "5.0.101"
+    "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.
+            Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper());
+
+            // Add odd to even.
+            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_11_01_01));
+
+            // Add high to low.
+            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10));
+
+            return Sse2.ConvertToInt32(vsum);
+        }
+
+        /// <summary>
+        /// Reduces even elements of the vector into one sum.
+        /// </summary>
+        /// <param name="accumulator">The accumulator to reduce.</param>
+        /// <returns>The sum of even elements.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int EvenReduceSum(Vector256<int> accumulator)
+        {
+            Vector128<int> vsum = Sse2.Add(accumulator.GetLower(), accumulator.GetUpper()); // add upper lane to lower lane
+            vsum = Sse2.Add(vsum, Sse2.Shuffle(vsum, 0b_11_10_11_10)); // add high to low
+
+            // Vector128<int>.ToScalar() isn't optimized pre-net5.0 https://github.com/dotnet/runtime/pull/37882
+            return Sse2.ConvertToInt32(vsum);
+        }
+    }
+#endif
+
+    /// <summary>
+    /// The default initial seed value of a Adler32 checksum calculation.
+    /// </summary>
+    public const uint SeedValue = 1U;
+
+    // Largest prime smaller than 65536
+    private const uint BASE = 65521;
+
+    // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
+    private const uint NMAX = 5552;
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+    private const int MinBufferSize = 64;
+
+    private const int BlockSize = 1 << 5;
+
+    // The C# compiler emits this as a compile-time constant embedded in the PE file.
+    private static ReadOnlySpan<byte> Tap1Tap2 =>
+        new byte[]
+        {
+            32,
+            31,
+            30,
+            29,
+            28,
+            27,
+            26,
+            25,
+            24,
+            23,
+            22,
+            21,
+            20,
+            19,
+            18,
+            17, // tap1
+            16,
+            15,
+            14,
+            13,
+            12,
+            11,
+            10,
+            9,
+            8,
+            7,
+            6,
+            5,
+            4,
+            3,
+            2,
+            1 // tap2
+        };
+#endif
+
+    /// <summary>
+    /// Calculates the Adler32 checksum with the bytes taken from the span.
+    /// </summary>
+    /// <param name="buffer">The readonly span of bytes.</param>
+    /// <returns>The <see cref="uint"/>.</returns>
+    [MethodImpl(InliningOptions.ShortMethod)]
+    public static uint Calculate(ReadOnlySpan<byte> buffer) => Calculate(SeedValue, buffer);
+
+    /// <summary>
+    /// Calculates the Adler32 checksum with the bytes taken from the span and seed.
+    /// </summary>
+    /// <param name="adler">The input Adler32 value.</param>
+    /// <param name="buffer">The readonly span of bytes.</param>
+    /// <returns>The <see cref="uint"/>.</returns>
+    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+    public static uint Calculate(uint adler, ReadOnlySpan<byte> buffer)
+    {
+        if (buffer.IsEmpty)
+        {
+            return adler;
+        }
+
+#if SUPPORTS_RUNTIME_INTRINSICS
+        if (Avx2.IsSupported && buffer.Length >= MinBufferSize)
+        {
+            return CalculateAvx2(adler, buffer);
+        }
+
+        if (Ssse3.IsSupported && buffer.Length >= MinBufferSize)
+        {
+            return CalculateSse(adler, buffer);
+        }
+
+        return CalculateScalar(adler, buffer);
+#else
+        return CalculateScalar(adler, buffer);
+#endif
+    }
+
+    // Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
+#if SUPPORTS_RUNTIME_INTRINSICS
+    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+    private static unsafe uint CalculateSse(uint adler, ReadOnlySpan<byte> buffer)
+    {
+        uint s1 = adler & 0xFFFF;
+        uint s2 = (adler >> 16) & 0xFFFF;
+
+        // Process the data in blocks.
+        uint length = (uint)buffer.Length;
+        uint blocks = length / BlockSize;
+        length -= blocks * BlockSize;
+
+        fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
+        {
+            fixed (byte* tapPtr = &MemoryMarshal.GetReference(Tap1Tap2))
+            {
+                byte* localBufferPtr = bufferPtr;
+
+                // _mm_setr_epi8 on x86
+                Vector128<sbyte> tap1 = Sse2.LoadVector128((sbyte*)tapPtr);
+                Vector128<sbyte> tap2 = Sse2.LoadVector128((sbyte*)(tapPtr + 0x10));
+                Vector128<byte> zero = Vector128<byte>.Zero;
+                var ones = Vector128.Create((short)1);
+
+                while (blocks > 0)
+                {
+                    uint n = NMAX / BlockSize; /* The NMAX constraint. */
+                    if (n > blocks)
+                    {
+                        n = blocks;
+                    }
+
+                    blocks -= n;
+
+                    // Process n blocks of data. At most NMAX data bytes can be
+                    // processed before s2 must be reduced modulo BASE.
+                    Vector128<uint> v_ps = Vector128.CreateScalar(s1 * n);
+                    Vector128<uint> v_s2 = Vector128.CreateScalar(s2);
+                    Vector128<uint> v_s1 = Vector128<uint>.Zero;
+
+                    do
+                    {
+                        // Load 32 input bytes.
+                        Vector128<byte> bytes1 = Sse3.LoadDquVector128(localBufferPtr);
+                        Vector128<byte> bytes2 = Sse3.LoadDquVector128(localBufferPtr + 0x10);
+
+                        // Add previous block byte sum to v_ps.
+                        v_ps = Sse2.Add(v_ps, v_s1);
+
+                        // Horizontally add the bytes for s1, multiply-adds the
+                        // bytes by [ 32, 31, 30, ... ] for s2.
+                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1, zero).AsUInt32());
+                        Vector128<short> mad1 = Ssse3.MultiplyAddAdjacent(bytes1, tap1);
+                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1, ones).AsUInt32());
+
+                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2, zero).AsUInt32());
+                        Vector128<short> mad2 = Ssse3.MultiplyAddAdjacent(bytes2, tap2);
+                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2, ones).AsUInt32());
+
+                        localBufferPtr += BlockSize;
+                    } while (--n > 0);
+
+                    v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5));
+
+                    // Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
+                    const byte S2301 = 0b1011_0001; // A B C D -> B A D C
+                    const byte S1032 = 0b0100_1110; // A B C D -> C D A B
+
+                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S1032));
+
+                    s1 += v_s1.ToScalar();
+
+                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S2301));
+                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S1032));
+
+                    s2 = v_s2.ToScalar();
+
+                    // Reduce.
+                    s1 %= BASE;
+                    s2 %= BASE;
+                }
+
+                if (length > 0)
+                {
+                    HandleLeftOver(localBufferPtr, length, ref s1, ref s2);
+                }
+
+                return s1 | (s2 << 16);
+            }
+        }
+    }
+
+    // Based on: https://github.com/zlib-ng/zlib-ng/blob/develop/arch/x86/adler32_avx2.c
+    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+    public static unsafe uint CalculateAvx2(uint adler, ReadOnlySpan<byte> buffer)
+    {
+        uint s1 = adler & 0xFFFF;
+        uint s2 = (adler >> 16) & 0xFFFF;
+        uint length = (uint)buffer.Length;
+
+        fixed (byte* bufferPtr = &MemoryMarshal.GetReference(buffer))
+        {
+            byte* localBufferPtr = bufferPtr;
+
+            Vector256<byte> zero = Vector256<byte>.Zero;
+            var dot3v = Vector256.Create((short)1);
+            var dot2v = Vector256.Create(
+                32,
+                31,
+                30,
+                29,
+                28,
+                27,
+                26,
+                25,
+                24,
+                23,
+                22,
+                21,
+                20,
+                19,
+                18,
+                17,
+                16,
+                15,
+                14,
+                13,
+                12,
+                11,
+                10,
+                9,
+                8,
+                7,
+                6,
+                5,
+                4,
+                3,
+                2,
+                1
+            );
+
+            // Process n blocks of data. At most NMAX data bytes can be
+            // processed before s2 must be reduced modulo BASE.
+            var vs1 = Vector256.CreateScalar(s1);
+            var vs2 = Vector256.CreateScalar(s2);
+
+            while (length >= 32)
+            {
+                int k = length < NMAX ? (int)length : (int)NMAX;
+                k -= k % 32;
+                length -= (uint)k;
+
+                Vector256<uint> vs10 = vs1;
+                Vector256<uint> vs3 = Vector256<uint>.Zero;
+
+                while (k >= 32)
+                {
+                    // Load 32 input bytes.
+                    Vector256<byte> block = Avx.LoadVector256(localBufferPtr);
+
+                    // Sum of abs diff, resulting in 2 x int32's
+                    Vector256<ushort> vs1sad = Avx2.SumAbsoluteDifferences(block, zero);
+
+                    vs1 = Avx2.Add(vs1, vs1sad.AsUInt32());
+                    vs3 = Avx2.Add(vs3, vs10);
+
+                    // sum 32 uint8s to 16 shorts.
+                    Vector256<short> vshortsum2 = Avx2.MultiplyAddAdjacent(block, dot2v);
+
+                    // sum 16 shorts to 8 uint32s.
+                    Vector256<int> vsum2 = Avx2.MultiplyAddAdjacent(vshortsum2, dot3v);
+
+                    vs2 = Avx2.Add(vsum2.AsUInt32(), vs2);
+                    vs10 = vs1;
+
+                    localBufferPtr += BlockSize;
+                    k -= 32;
+                }
+
+                // Defer the multiplication with 32 to outside of the loop.
+                vs3 = Avx2.ShiftLeftLogical(vs3, 5);
+                vs2 = Avx2.Add(vs2, vs3);
+
+                s1 = (uint)Numerics.EvenReduceSum(vs1.AsInt32());
+                s2 = (uint)Numerics.ReduceSum(vs2.AsInt32());
+
+                s1 %= BASE;
+                s2 %= BASE;
+
+                vs1 = Vector256.CreateScalar(s1);
+                vs2 = Vector256.CreateScalar(s2);
+            }
+
+            if (length > 0)
+            {
+                HandleLeftOver(localBufferPtr, length, ref s1, ref s2);
+            }
+
+            return s1 | (s2 << 16);
+        }
+    }
+
+    private static unsafe void HandleLeftOver(
+        byte* localBufferPtr,
+        uint length,
+        ref uint s1,
+        ref uint s2
+    )
+    {
+        if (length >= 16)
+        {
+            s2 += s1 += localBufferPtr[0];
+            s2 += s1 += localBufferPtr[1];
+            s2 += s1 += localBufferPtr[2];
+            s2 += s1 += localBufferPtr[3];
+            s2 += s1 += localBufferPtr[4];
+            s2 += s1 += localBufferPtr[5];
+            s2 += s1 += localBufferPtr[6];
+            s2 += s1 += localBufferPtr[7];
+            s2 += s1 += localBufferPtr[8];
+            s2 += s1 += localBufferPtr[9];
+            s2 += s1 += localBufferPtr[10];
+            s2 += s1 += localBufferPtr[11];
+            s2 += s1 += localBufferPtr[12];
+            s2 += s1 += localBufferPtr[13];
+            s2 += s1 += localBufferPtr[14];
+            s2 += s1 += localBufferPtr[15];
+
+            localBufferPtr += 16;
+            length -= 16;
+        }
+
+        while (length-- > 0)
+        {
+            s2 += s1 += *localBufferPtr++;
+        }
+
+        if (s1 >= BASE)
+        {
+            s1 -= BASE;
+        }
+
+        s2 %= BASE;
+    }
+#endif
+
+    [MethodImpl(InliningOptions.HotPath | InliningOptions.ShortMethod)]
+    private static unsafe uint CalculateScalar(uint adler, ReadOnlySpan<byte> buffer)
+    {
+        uint s1 = adler & 0xFFFF;
+        uint s2 = (adler >> 16) & 0xFFFF;
+        uint k;
+
+        fixed (byte* bufferPtr = buffer)
+        {
+            var localBufferPtr = bufferPtr;
+            uint length = (uint)buffer.Length;
+
+            while (length > 0)
+            {
+                k = length < NMAX ? length : NMAX;
+                length -= k;
+
+                while (k >= 16)
+                {
+                    s2 += s1 += localBufferPtr[0];
+                    s2 += s1 += localBufferPtr[1];
+                    s2 += s1 += localBufferPtr[2];
+                    s2 += s1 += localBufferPtr[3];
+                    s2 += s1 += localBufferPtr[4];
+                    s2 += s1 += localBufferPtr[5];
+                    s2 += s1 += localBufferPtr[6];
+                    s2 += s1 += localBufferPtr[7];
+                    s2 += s1 += localBufferPtr[8];
+                    s2 += s1 += localBufferPtr[9];
+                    s2 += s1 += localBufferPtr[10];
+                    s2 += s1 += localBufferPtr[11];
+                    s2 += s1 += localBufferPtr[12];
+                    s2 += s1 += localBufferPtr[13];
+                    s2 += s1 += localBufferPtr[14];
+                    s2 += s1 += localBufferPtr[15];
+
+                    localBufferPtr += 16;
+                    k -= 16;
+                }
+
+                while (k-- > 0)
+                {
+                    s2 += s1 += *localBufferPtr++;
+                }
+
+                s1 %= BASE;
+                s2 %= BASE;
+            }
+
+            return (s2 << 16) | s1;
+        }
+    }
+}

src/SharpCompress/Algorithms/Alder32.cs

@@ -1,285 +0,0 @@
-// Copyright (c) Six Labors and contributors.
-// Licensed under the GNU Affero General Public License, Version 3.
-
-using System;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-#endif
-
-namespace SharpCompress.Algorithms
-{
-    /// <summary>
-    /// Calculates the 32 bit Adler checksum of a given buffer according to
-    /// RFC 1950. ZLIB Compressed Data Format Specification version 3.3)
-    /// </summary>
-    internal static class Adler32
-    {
-        /// <summary>
-        /// The default initial seed value of a Adler32 checksum calculation.
-        /// </summary>
-        public const uint SeedValue = 1U;
-
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-        private const int MinBufferSize = 64;
-#endif
-
-        // Largest prime smaller than 65536
-        private const uint BASE = 65521;
-
-        // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
-        private const uint NMAX = 5552;
-
-        /// <summary>
-        /// Calculates the Adler32 checksum with the bytes taken from the span.
-        /// </summary>
-        /// <param name="buffer">The readonly span of bytes.</param>
-        /// <returns>The <see cref="uint"/>.</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static uint Calculate(ReadOnlySpan<byte> buffer)
-        {
-            return Calculate(SeedValue, buffer);
-        }
-
-        /// <summary>
-        /// Calculates the Adler32 checksum with the bytes taken from the span and seed.
-        /// </summary>
-        /// <param name="adler">The input Adler32 value.</param>
-        /// <param name="buffer">The readonly span of bytes.</param>
-        /// <returns>The <see cref="uint"/>.</returns>
-        public static uint Calculate(uint adler, ReadOnlySpan<byte> buffer)
-        {
-            if (buffer.IsEmpty)
-            {
-                return SeedValue;
-            }
-
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-            if (Sse3.IsSupported && buffer.Length >= MinBufferSize)
-            {
-                return CalculateSse(adler, buffer);
-            }
-
-            return CalculateScalar(adler, buffer);
-#else
-            return CalculateScalar(adler, buffer);
-#endif
-        }
-
-        // Based on https://github.com/chromium/chromium/blob/master/third_party/zlib/adler32_simd.c
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1
-        private static unsafe uint CalculateSse(uint adler, ReadOnlySpan<byte> buffer)
-        {
-            uint s1 = adler & 0xFFFF;
-            uint s2 = (adler >> 16) & 0xFFFF;
-
-            // Process the data in blocks.
-            const int BLOCK_SIZE = 1 << 5;
-
-            uint length = (uint)buffer.Length;
-            uint blocks = length / BLOCK_SIZE;
-            length -= blocks * BLOCK_SIZE;
-
-            int index = 0;
-            fixed (byte* bufferPtr = &buffer[0])
-            {
-                index += (int)blocks * BLOCK_SIZE;
-                var localBufferPtr = bufferPtr;
-
-                // _mm_setr_epi8 on x86
-                var tap1 = Vector128.Create(32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17);
-                var tap2 = Vector128.Create(16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1);
-                Vector128<byte> zero = Vector128<byte>.Zero;
-                var ones = Vector128.Create((short)1);
-
-                while (blocks > 0)
-                {
-                    uint n = NMAX / BLOCK_SIZE;  /* The NMAX constraint. */
-                    if (n > blocks)
-                    {
-                        n = blocks;
-                    }
-
-                    blocks -= n;
-
-                    // Process n blocks of data. At most NMAX data bytes can be
-                    // processed before s2 must be reduced modulo BASE.
-                    Vector128<int> v_ps = Vector128.CreateScalar(s1 * n).AsInt32();
-                    Vector128<int> v_s2 = Vector128.CreateScalar(s2).AsInt32();
-                    Vector128<int> v_s1 = Vector128<int>.Zero;
-
-                    do
-                    {
-                        // Load 32 input bytes.
-                        Vector128<byte> bytes1 = Sse3.LoadDquVector128(localBufferPtr);
-                        Vector128<byte> bytes2 = Sse3.LoadDquVector128(localBufferPtr + 16);
-
-                        // Add previous block byte sum to v_ps.
-                        v_ps = Sse2.Add(v_ps, v_s1);
-
-                        // Horizontally add the bytes for s1, multiply-adds the
-                        // bytes by [ 32, 31, 30, ... ] for s2.
-                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes1, zero).AsInt32());
-                        Vector128<short> mad1 = Ssse3.MultiplyAddAdjacent(bytes1, tap1);
-                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad1, ones));
-
-                        v_s1 = Sse2.Add(v_s1, Sse2.SumAbsoluteDifferences(bytes2, zero).AsInt32());
-                        Vector128<short> mad2 = Ssse3.MultiplyAddAdjacent(bytes2, tap2);
-                        v_s2 = Sse2.Add(v_s2, Sse2.MultiplyAddAdjacent(mad2, ones));
-
-                        localBufferPtr += BLOCK_SIZE;
-                    }
-                    while (--n > 0);
-
-                    v_s2 = Sse2.Add(v_s2, Sse2.ShiftLeftLogical(v_ps, 5));
-
-                    // Sum epi32 ints v_s1(s2) and accumulate in s1(s2).
-                    const byte S2301 = 0b1011_0001;  // A B C D -> B A D C
-                    const byte S1032 = 0b0100_1110;  // A B C D -> C D A B
-
-                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S2301));
-                    v_s1 = Sse2.Add(v_s1, Sse2.Shuffle(v_s1, S1032));
-
-                    s1 += (uint)v_s1.ToScalar();
-
-                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S2301));
-                    v_s2 = Sse2.Add(v_s2, Sse2.Shuffle(v_s2, S1032));
-
-                    s2 = (uint)v_s2.ToScalar();
-
-                    // Reduce.
-                    s1 %= BASE;
-                    s2 %= BASE;
-                }
-            }
-
-            ref byte bufferRef = ref MemoryMarshal.GetReference(buffer);
-
-            if (length > 0)
-            {
-                if (length >= 16)
-                {
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    length -= 16;
-                }
-
-                while (length-- > 0)
-                {
-                    s2 += s1 += Unsafe.Add(ref bufferRef, index++);
-                }
-
-                if (s1 >= BASE)
-                {
-                    s1 -= BASE;
-                }
-
-                s2 %= BASE;
-            }
-
-            return s1 | (s2 << 16);
-        }
-#endif
-
-        private static uint CalculateScalar(uint adler, ReadOnlySpan<byte> buffer)
-        {
-            uint s1 = adler & 0xFFFF;
-            uint s2 = (adler >> 16) & 0xFFFF;
-            uint k;
-
-            ref byte bufferRef = ref MemoryMarshal.GetReference<byte>(buffer);
-            uint length = (uint)buffer.Length;
-            int index = 0;
-
-            while (length > 0)
-            {
-                k = length < NMAX ? length : NMAX;
-                length -= k;
-
-                while (k >= 16)
-                {
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    s1 += Unsafe.Add(ref bufferRef, index++);
-                    s2 += s1;
-                    k -= 16;
-                }
-
-                if (k != 0)
-                {
-                    do
-                    {
-                        s1 += Unsafe.Add(ref bufferRef, index++);
-                        s2 += s1;
-                    }
-                    while (--k != 0);
-                }
-
-                s1 %= BASE;
-                s2 %= BASE;
-            }
-
-            return (s2 << 16) | s1;
-        }
-    }
-}

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;
-
-        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;
-
-        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
-        {
-            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));
-        }
-
-
-        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
-
-        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
-        {
-            Type = type;
-            ReaderOptions = readerOptions;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
-        }
+        Type = type;
+        ReaderOptions = srcStream.ReaderOptions;
+        SrcStream = srcStream;
+        lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
+        lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+    }
 
 #nullable disable
-        internal AbstractArchive(ArchiveType type)
-        {
-            Type = type;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
-        }
+    internal AbstractArchive(ArchiveType type)
+    {
+        Type = type;
+        lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
+        lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+    }
+
 #nullable enable
 
-        public ArchiveType Type { get; }
+    public ArchiveType Type { get; }
 
-        void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry)
+    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
+        EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
+    void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) =>
+        EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+
+    private static Stream CheckStreams(Stream stream)
+    {
+        if (!stream.CanSeek || !stream.CanRead)
         {
-            EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+            throw new ArgumentException("Archive streams must be Readable and Seekable");
         }
+        return stream;
+    }
 
-        void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry)
+    /// <summary>
+    /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
+    /// </summary>
+    public virtual ICollection<TEntry> Entries => lazyEntries;
+
+    /// <summary>
+    /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
+    /// </summary>
+    public ICollection<TVolume> Volumes => lazyVolumes;
+
+    /// <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)
         {
-            EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
+            lazyVolumes.ForEach(v => v.Dispose());
+            lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+            SrcStream?.Dispose();
+
+            disposed = true;
         }
+    }
 
-        private static Stream CheckStreams(Stream stream)
-        {
-            if (!stream.CanSeek || !stream.CanRead)
-            {
-                throw new ArgumentException("Archive streams must be Readable and Seekable");
-            }
-            return stream;
-        }
+    void IArchiveExtractionListener.EnsureEntriesLoaded()
+    {
+        lazyEntries.EnsureFullyLoaded();
+        lazyVolumes.EnsureFullyLoaded();
+    }
 
-        /// <summary>
-        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
-        /// </summary>
-        public virtual ICollection<TEntry> Entries => lazyEntries;
-
-        /// <summary>
-        /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
-        /// </summary>
-        public ICollection<TVolume> Volumes => lazyVolumes;
-
-        /// <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(IEnumerable<Stream> streams);
-        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)
-            {
-                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(
+    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(
+    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>
+    /// Use this method to extract all entries in an archive in order.
+    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
+    /// extracted sequentially for the best performance.
+    ///
+    /// This method will load all entry information from the archive.
+    ///
+    /// WARNING: this will reuse the underlying stream for the archive.  Errors may
+    /// occur if this is used at the same time as other extraction methods on this instance.
+    /// </summary>
+    /// <returns></returns>
+    public IReader ExtractAllEntries()
+    {
+        ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
+        return CreateReaderForSolidExtraction();
+    }
+
+    protected abstract IReader CreateReaderForSolidExtraction();
+
+    /// <summary>
+    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
+    /// </summary>
+    public virtual bool IsSolid => false;
+
+    /// <summary>
+    /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
+    /// </summary>
+    public bool IsComplete
+    {
+        get
         {
             ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-            return CreateReaderForSolidExtraction();
-        }
-
-        protected abstract IReader CreateReaderForSolidExtraction();
-
-        /// <summary>
-        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-        /// </summary>
-        public virtual bool IsSolid => false;
-
-        /// <summary>
-        /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
-        /// </summary>
-        public bool IsComplete
-        {
-            get
-            {
-                ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-                return Entries.All(x => x.IsComplete);
-            }
+            return Entries.All(x => x.IsComplete);
         }
     }
 }

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -1,170 +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 class RebuildPauseDisposable : IDisposable
-        {
-            private readonly AbstractWritableArchive<TEntry, TVolume> archive;
-
-            public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume> archive)
-            {
-                this.archive = archive;
-                archive.pauseRebuilding = true;
-            }
-
-            public void Dispose()
-            {
-                archive.pauseRebuilding = false;
-                archive.RebuildModifiedCollection();
-            }
-        }
-        private readonly List<TEntry> newEntries = new List<TEntry>();
-        private readonly List<TEntry> removedEntries = new List<TEntry>();
-
-        private readonly List<TEntry> modifiedEntries = new List<TEntry>();
-        private bool hasModifications;
-        private bool pauseRebuilding;
-
-        internal AbstractWritableArchive(ArchiveType type)
-            : base(type)
+        private readonly AbstractWritableArchive<TEntry, TVolume> archive;
+
+        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;
-            }
-        }
-
-        public IDisposable PauseEntryRebuilding()
-        {
-            return 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 { 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.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());
+            archive.pauseRebuilding = false;
+            archive.RebuildModifiedCollection();
         }
     }
+
+    private readonly List<TEntry> newEntries = new List<TEntry>();
+    private readonly List<TEntry> removedEntries = new List<TEntry>();
+
+    private readonly List<TEntry> modifiedEntries = new List<TEntry>();
+    private bool hasModifications;
+    private bool pauseRebuilding;
+
+    internal AbstractWritableArchive(ArchiveType type)
+        : base(type) { }
+
+    internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
+        : base(type, srcStream) { }
+
+    public override ICollection<TEntry> Entries
+    {
+        get
+        {
+            if (hasModifications)
+            {
+                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,146 +1,241 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Archives.Dmg;
-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 static 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 ??= 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 (DmgArchive.IsDmgFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return DmgArchive.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, Dmg");
+            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)
         {
-            return type switch
-            {
-                ArchiveType.Zip => ZipArchive.Create(),
-                ArchiveType.Tar => TarArchive.Create(),
-                ArchiveType.GZip => GZipArchive.Create(),
-                _ => throw new NotSupportedException("Cannot create Archives of type: " + type)
-            };
+            throw new InvalidOperationException("No files to open");
         }
 
-        /// <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 fileInfo = filesArray[0];
+        if (filesArray.Length == 1)
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), options);
+            return Open(fileInfo, 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)
-        {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            options ??= new ReaderOptions { LeaveStreamOpen = false };
+        fileInfo.CheckNotNull(nameof(fileInfo));
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
 
-            using var stream = fileInfo.OpenRead();
-            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 (DmgArchive.IsDmgFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return DmgArchive.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, Dmg");
+        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");
         }
 
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
-                                            ExtractionOptions? options = null)
+        var firstStream = streamsArray[0];
+        if (streamsArray.Length == 1)
         {
-            using IArchive archive = Open(sourceArchive);
-            foreach (IArchiveEntry entry in archive.Entries)
+            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))
             {
-                entry.WriteToDirectory(destinationDirectory, options);
+                stream.Seek(startPosition, SeekOrigin.Begin);
+
+                return factory;
+            }
+        }
+
+        var extensions = string.Join(", ", factories.Select(item => item.Name));
+
+        throw new InvalidOperationException(
+            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
+        );
+    }
+
+    public static bool IsArchive(string filePath, out ArchiveType? type)
+    {
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        using Stream s = File.OpenRead(filePath);
+        return IsArchive(s, out type);
+    }
+
+    public static bool IsArchive(Stream stream, out ArchiveType? type)
+    {
+        type = null;
+        stream.CheckNotNull(nameof(stream));
+
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in Factory.Factories)
+        {
+            stream.Position = startPosition;
+
+            if (factory.IsArchive(stream, null))
+            {
+                type = factory.KnownArchiveType;
+                return true;
+            }
+        }
+
+        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>())
+        {
+            var i = 1;
+            var part = factory.GetFilePart(i++, part1);
+
+            if (part != null)
+            {
+                yield return part;
+                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
+                {
+                    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 ...
+        Match m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
+        if (m.Success)
+            item = new FileInfo(
+                Path.Combine(
+                    part1.DirectoryName!,
+                    String.Concat(
+                        m.Groups[1].Value,
+                        (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0')
+                    )
+                )
+            );
+
+        if (item != null && item.Exists)
+            return item;
+        return null;
+    }
+}

src/SharpCompress/Archives/Dmg/DmgArchive.cs

@@ -1,117 +0,0 @@
-using SharpCompress.Common;
-using SharpCompress.Common.Dmg;
-using SharpCompress.Common.Dmg.Headers;
-using SharpCompress.Common.Dmg.HFS;
-using SharpCompress.Readers;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-
-namespace SharpCompress.Archives.Dmg
-{
-    public class DmgArchive : AbstractArchive<DmgArchiveEntry, DmgVolume>
-    {
-        private readonly string _fileName;
-
-        internal DmgArchive(FileInfo fileInfo, ReaderOptions readerOptions)
-            : base(ArchiveType.Dmg, fileInfo, readerOptions)
-        {
-            _fileName = fileInfo.FullName;
-        }
-
-        internal DmgArchive(Stream stream, ReaderOptions readerOptions)
-            : base(ArchiveType.Dmg, stream.AsEnumerable(), readerOptions)
-        {
-            _fileName = string.Empty;
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-            => new DmgReader(ReaderOptions, this, _fileName);
-
-        protected override IEnumerable<DmgArchiveEntry> LoadEntries(IEnumerable<DmgVolume> volumes)
-            => volumes.Single().LoadEntries();
-
-        protected override IEnumerable<DmgVolume> LoadVolumes(FileInfo file)
-            => new DmgVolume(this, file.OpenRead(), file.FullName, ReaderOptions).AsEnumerable();
-
-        protected override IEnumerable<DmgVolume> LoadVolumes(IEnumerable<Stream> streams)
-            => new DmgVolume(this, streams.Single(), string.Empty, ReaderOptions).AsEnumerable();
-
-        public static bool IsDmgFile(FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists) return false;
-
-            using var stream = fileInfo.OpenRead();
-            return IsDmgFile(stream);
-        }
-
-        public static bool IsDmgFile(Stream stream)
-        {
-            long headerPos = stream.Length - DmgHeader.HeaderSize;
-            if (headerPos < 0) return false;
-            stream.Position = headerPos;
-
-            return DmgHeader.TryRead(stream, out _);
-        }
-
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static DmgArchive 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 DmgArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-        {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new DmgArchive(fileInfo, readerOptions ?? new ReaderOptions());
-        }
-
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        public static DmgArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-        {
-            stream.CheckNotNull(nameof(stream));
-            return new DmgArchive(stream, readerOptions ?? new ReaderOptions());
-        }
-
-        private sealed class DmgReader : AbstractReader<DmgEntry, DmgVolume>
-        {
-            private readonly DmgArchive _archive;
-            private readonly string _fileName;
-            private readonly Stream? _partitionStream;
-
-            public override DmgVolume Volume { get; }
-
-            internal DmgReader(ReaderOptions readerOptions, DmgArchive archive, string fileName)
-                : base(readerOptions, ArchiveType.Dmg)
-            {
-                _archive = archive;
-                _fileName = fileName;
-                Volume = archive.Volumes.Single();
-
-                using var compressedStream = DmgUtil.LoadHFSPartitionStream(Volume.Stream, Volume.Header);
-                _partitionStream = compressedStream?.Decompress();
-            }
-
-            protected override IEnumerable<DmgEntry> GetEntries(Stream stream)
-            {
-                if (_partitionStream is null) return Array.Empty<DmgArchiveEntry>();
-                else return HFSUtil.LoadEntriesFromPartition(_partitionStream, _fileName, _archive);
-            }
-        }
-    }
-}

src/SharpCompress/Archives/Dmg/DmgArchiveEntry.cs

@@ -1,32 +0,0 @@
-using SharpCompress.Common.Dmg;
-using SharpCompress.Common.Dmg.HFS;
-using System;
-using System.IO;
-
-namespace SharpCompress.Archives.Dmg
-{
-    public sealed class DmgArchiveEntry : DmgEntry, IArchiveEntry
-    {
-        private readonly Stream? _stream;
-
-        public bool IsComplete { get; } = true;
-
-        public IArchive Archive { get; }
-
-        internal DmgArchiveEntry(Stream? stream, DmgArchive archive, HFSCatalogRecord record, string path, DmgFilePart part)
-            : base(record, path, stream?.Length ?? 0, part)
-        {
-            _stream = stream;
-            Archive = archive;
-        }
-
-        public Stream OpenEntryStream()
-        {
-            if (IsDirectory)
-                throw new NotSupportedException("Directories cannot be opened as stream");
-
-            _stream!.Position = 0;
-            return _stream;
-        }
-    }
-}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -1,181 +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 GZipArchive();
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal GZipArchive(SourceStream srcStream)
+        : base(ArchiveType.Tar, srcStream) { }
+
+    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
+    {
+        srcStream.LoadAllParts();
+        var idx = 0;
+        return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, idx++));
+    }
+
+    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
+
+    public static bool IsGZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
         {
-            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
-            Span<byte> header = stackalloc 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 = (GZipFilePart)Parts.Single();
-            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,4 +1,4 @@
-#nullable disable
+#nullable disable
 
 using System;
 using System.Collections.Generic;
@@ -6,63 +6,68 @@ using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.GZip
+namespace SharpCompress.Archives.GZip;
+
+internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
 {
-    internal sealed 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,63 +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.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-            var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
-            streamListener.EnsureEntriesLoaded();
-            streamListener.FireEntryExtractionBegin(archiveEntry);
-            streamListener.FireFilePartExtractionBegin(archiveEntry.Key, archiveEntry.Size, archiveEntry.CompressedSize);
-            var entryStream = archiveEntry.OpenEntryStream();
-            if (entryStream is null)
-            {
-                return;
-            }
-            using (entryStream)
-            {
-                using (Stream s = new ListeningStream(streamListener, entryStream))
-                {
-                    s.TransferTo(streamToWriteTo);
-                }
-            }
-            streamListener.FireEntryExtractionEnd(archiveEntry);
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory,
-                                            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.WriteEntryToDirectory(entry, destinationDirectory, options,
-                                              entry.WriteToFile);
+            return;
         }
-
-        /// <summary>
-        /// Extract to specific file
-        /// </summary>
-        public static void WriteToFile(this IArchiveEntry entry,
-                                       string destinationFileName,
-                                       ExtractionOptions? options = null)
+        using (entryStream)
         {
-
-            ExtractionMethods.WriteEntryToFile(entry, destinationFileName, options,
-                                               (x, fm) =>
-                                               {
-                                                   using (FileStream fs = File.Open(destinationFileName, fm))
-                                                   {
-                                                       entry.WriteTo(fs);
-                                                   }
-                                               });
+            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,20 +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();
-    }
-}
+    /// <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,56 +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())
         {
-            using (writableArchive.PauseEntryRebuilding())
+            foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
             {
-                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);
-                }
+                var fileInfo = new FileInfo(path);
+                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 sealed class FileInfoRarFilePart : SeekableFilePart
-    {
-        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string? password, MarkHeader mh, FileHeader fh, FileInfo fi)
-            : base(mh, fh, volume.Stream, password)
-        {
-            FileInfo = fi;
-        }
+    internal 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

@@ -5,136 +5,173 @@ 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 Lazy<IRarUnpack>(() => new Compressors.Rar.UnpackV2017.Unpack());
+    internal Lazy<IRarUnpack> UnpackV1 { get; } =
+        new Lazy<IRarUnpack>(() => new Compressors.Rar.UnpackV1.Unpack());
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal RarArchive(SourceStream srcStream)
+        : base(ArchiveType.Rar, srcStream) { }
+
+    protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
+        RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
+
+    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream srcStream)
     {
-        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, ReaderOptions);
-        }
-
-        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

@@ -8,81 +8,98 @@ 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;
-        private readonly ReaderOptions readerOptions;
+        this.parts = parts.ToList();
+        this.archive = archive;
+        this.readerOptions = readerOptions;
+        IsSolid = FileHeader.IsSolid;
+    }
 
-        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts, ReaderOptions readerOptions)
+    public override CompressionType CompressionType => CompressionType.Rar;
+
+    public IArchive Archive => archive;
+
+    internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();
+
+    internal override FileHeader FileHeader => parts.First().FileHeader;
+
+    public override long Crc
+    {
+        get
         {
-            this.parts = parts.ToList();
-            this.archive = archive;
-            this.readerOptions = readerOptions;
-        }
-
-        public override CompressionType CompressionType => CompressionType.Rar;
-
-        public IArchive Archive => archive;
-
-        internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();
-
-        internal override FileHeader FileHeader => parts.First().FileHeader;
-
-        public override long Crc
-        {
-            get
-            {
-                CheckIncomplete();
-                return parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc;
-            }
-        }
-
-        public override long Size
-        {
-            get
-            {
-                CheckIncomplete();
-                return parts.First().FileHeader.UncompressedSize;
-            }
-        }
-
-        public override long CompressedSize
-        {
-            get
-            {
-                CheckIncomplete();
-                return parts.Aggregate(0L, (total, fp) => total + fp.FileHeader.CompressedSize);
-            }
-        }
-
-        public Stream OpenEntryStream()
-        {
-            if (IsRarV3)
-            {
-                return new RarStream(archive.UnpackV1.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
-            }
-
-            return new RarStream(archive.UnpackV2017.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
-        }
-
-        public bool IsComplete
-        {
-            get
-            {
-                var headers = parts.Select(x => x.FileHeader);
-                return !headers.First().IsSplitBefore && !headers.Last().IsSplitAfter;
-            }
-        }
-
-        private void CheckIncomplete()
-        {
-            if (!readerOptions.DisableCheckIncomplete && !IsComplete)
-            {
-                throw new IncompleteArchiveException("ArchiveEntry is incomplete and cannot perform this operation.");
-            }
+            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,49 +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,
-                                                                ReaderOptions readerOptions)
-        {
-            foreach (var groupedParts in GetMatchedFileParts(rarParts))
-            {
-                yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
+                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,140 +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)
+        FileInfo? item = null;
+
+        //new style rar - ..part1 | /part01 | part001 ....
+        Match m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
+        if (m.Success)
+            item = new FileInfo(
+                Path.Combine(
+                    part1.DirectoryName!,
+                    String.Concat(
+                        m.Groups[1].Value,
+                        (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'),
+                        m.Groups[3].Value
+                    )
+                )
+            );
+        else
         {
-            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;
-            }
+            //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);
         }
 
-        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
-        {
-            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
-            yield return part;
+        if (item != null && item.Exists)
+            return item;
 
-            ArchiveHeader ah = part.ArchiveHeader;
-            if (!ah.IsVolume)
-            {
-                yield break; //if file isn't volume then there is no reason to look
-            }
-            fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
-            //we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
-            while (fileInfo != null && fileInfo.Exists)
-            {
-                part = new FileInfoRarArchiveVolume(fileInfo, options);
-
-                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
-                yield return part;
-            }
-        }
-
-        private static FileInfo? GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart? currentFilePart)
-        {
-            if (currentFilePart is null)
-            {
-                return null;
-            }
-            bool oldNumbering = ah.OldNumberingFormat
-                                || currentFilePart.MarkHeader.OldNumberingFormat;
-            if (oldNumbering)
-            {
-                return FindNextFileWithOldNumbering(currentFilePart.FileInfo);
-            }
-            else
-            {
-                return FindNextFileWithNewNumbering(currentFilePart.FileInfo);
-            }
-        }
-
-        private static FileInfo FindNextFileWithOldNumbering(FileInfo currentFileInfo)
-        {
-            // .rar, .r00, .r01, ...
-            string extension = currentFileInfo.Extension;
-
-            var buffer = new StringBuilder(currentFileInfo.FullName.Length);
-            buffer.Append(currentFileInfo.FullName.Substring(0,
-                                                             currentFileInfo.FullName.Length - extension.Length));
-            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) == 0)
-            {
-                buffer.Append(".r00");
-            }
-            else
-            {
-                if (int.TryParse(extension.Substring(2, 2), out int num))
-                {
-                    num++;
-                    buffer.Append(".r");
-                    if (num < 10)
-                    {
-                        buffer.Append('0');
-                    }
-                    buffer.Append(num);
-                }
-                else
-                {
-                    ThrowInvalidFileName(currentFileInfo);
-                }
-            }
-            return new FileInfo(buffer.ToString());
-        }
-
-        private static FileInfo FindNextFileWithNewNumbering(FileInfo currentFileInfo)
-        {
-            // part1.rar, part2.rar, ...
-            string extension = currentFileInfo.Extension;
-            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) != 0)
-            {
-                throw new ArgumentException("Invalid extension, expected 'rar': " + currentFileInfo.FullName);
-            }
-            int startIndex = currentFileInfo.FullName.LastIndexOf(".part");
-            if (startIndex < 0)
-            {
-                ThrowInvalidFileName(currentFileInfo);
-            }
-            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
-            buffer.Append(currentFileInfo.FullName, 0, startIndex);
-            string numString = currentFileInfo.FullName.Substring(startIndex + 5,
-                                                                  currentFileInfo.FullName.IndexOf('.', startIndex + 5) -
-                                                                  startIndex - 5);
-            buffer.Append(".part");
-            if (int.TryParse(numString, out int num))
-            {
-                num++;
-                for (int i = 0; i < numString.Length - num.ToString().Length; i++)
-                {
-                    buffer.Append('0');
-                }
-                buffer.Append(num);
-            }
-            else
-            {
-                ThrowInvalidFileName(currentFileInfo);
-            }
-            buffer.Append(".rar");
-            return new FileInfo(buffer.ToString());
-        }
-
-        private static void ThrowInvalidFileName(FileInfo fileInfo)
-        {
-            throw new ArgumentException("Filename invalid or next archive could not be found:"
-                                        + fileInfo.FullName);
-        }
+        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,4 @@
-#nullable disable
+#nullable disable
 
 using System;
 using System.Collections.Generic;
@@ -10,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 is 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 ReadOnlySpan<byte> SIGNATURE => new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
-
-        private static bool SignatureMatch(Stream stream)
-        {
-            BinaryReader reader = new BinaryReader(stream);
-            ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
-            return signatureBytes.SequenceEqual(SIGNATURE);
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            return new SevenZipReader(ReaderOptions, this);
-        }
-
-        public override bool IsSolid { get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; } }
-
-        public override long TotalSize
-        {
-            get
-            {
-                int i = Entries.Count;
-                return database._packSizes.Aggregate(0L, (total, packSize) => total + packSize);
-            }
-        }
-
-        private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
-        {
-            private readonly SevenZipArchive archive;
-            private CFolder currentFolder;
-            private Stream currentStream;
-            private CFileItem currentItem;
-
-            internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-                : base(readerOptions, ArchiveType.SevenZip)
-            {
-                this.archive = archive;
-            }
-
-            public override SevenZipVolume Volume => archive.Volumes.Single();
-
-            protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
-            {
-                List<SevenZipArchiveEntry> entries = archive.Entries.ToList();
-                stream.Position = 0;
-                foreach (var dir in entries.Where(x => x.IsDirectory))
-                {
-                    yield return dir;
-                }
-                foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
-                {
-                    currentFolder = group.Key;
-                    if (group.Key is null)
-                    {
-                        currentStream = Stream.Null;
-                    }
-                    else
-                    {
-                        currentStream = archive.database.GetFolderStream(stream, currentFolder, new PasswordProvider(Options.Password));
-                    }
-                    foreach (var entry in group)
-                    {
-                        currentItem = entry.FilePart.Header;
-                        yield return entry;
-                    }
-                }
-            }
-
-            protected override EntryStream GetEntryStream()
-            {
-                return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
-            }
-        }
-
-        private class PasswordProvider : IPasswordProvider
-        {
-            private readonly string _password;
-
-            public PasswordProvider(string password)
-            {
-                _password = password;
-            }
-
-            public string CryptoGetTextPassword()
-            {
-                return _password;
-            }
+            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;
         }
+        using Stream stream = fileInfo.OpenRead();
+        return IsTarFile(stream);
+    }
 
-        /// <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)
+    public static bool IsTarFile(Stream stream)
+    {
+        try
         {
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+            var readSucceeded = tarHeader.Read(new BinaryReader(stream));
+            var isEmptyArchive =
+                tarHeader.Name.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
         }
+        catch { }
+        return false;
+    }
 
-        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
-        {
-            return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
-        }
+    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
+    {
+        SrcStream.LoadAllParts(); //request all streams
+        var idx = 0;
+        return new TarVolume(srcStream, ReaderOptions, idx++).AsEnumerable(); //simple single volume or split, multivolume not supported
+    }
 
-        /// <summary>
-        /// 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)
-        {
-        }
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal TarArchive(SourceStream srcStream)
+        : base(ArchiveType.Tar, srcStream) { }
 
-        internal TarArchive()
-            : base(ArchiveType.Tar)
-        {
-        }
+    internal TarArchive()
+        : base(ArchiveType.Tar) { }
 
-        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
+    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
+            )
+        )
         {
-            return new TarVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
-        protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
-        {
-            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 TarArchive();
+
+    protected override TarArchiveEntry CreateEntryInternal(
+        string filePath,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    ) =>
+        new TarWritableArchiveEntry(
+            this,
+            source,
+            CompressionType.Unknown,
+            filePath,
+            size,
+            modified,
+            closeStream
+        );
+
+    protected override void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<TarArchiveEntry> newEntries
+    )
+    {
+        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
+        {
+            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,4 +1,4 @@
-#nullable disable
+#nullable disable
 
 using System;
 using System.Collections.Generic;
@@ -6,62 +6,68 @@ using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
 {
-    internal sealed 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,201 +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;
+    private readonly SeekableZipHeaderFactory headerFactory;
+
 #nullable enable
 
-        /// <summary>
-        /// Gets or sets the compression level applied to files added to the archive,
-        /// if the compression method is set to deflate
-        /// </summary>
-        public CompressionLevel DeflateCompressionLevel { get; set; }
+    /// <summary>
+    /// Gets or sets the compression level applied to files added to the archive,
+    /// if the compression method is set to deflate
+    /// </summary>
+    public CompressionLevel DeflateCompressionLevel { get; set; }
 
-        /// <summary>
-        /// Constructor 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)
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="srcStream"></param>
+    /// <param name="options"></param>
+    internal ZipArchive(SourceStream srcStream)
+        : base(ArchiveType.Zip, srcStream) =>
+        headerFactory = new SeekableZipHeaderFactory(
+            srcStream.ReaderOptions.Password,
+            srcStream.ReaderOptions.ArchiveEncoding
+        );
+
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    {
+        filePath.CheckNotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.CheckNotNull(nameof(fileInfo));
+        return new ZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.CheckNotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.CheckNotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.CheckNotNull(nameof(stream));
+        return new ZipArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static bool IsZipFile(string filePath, string? password = null) =>
+        IsZipFile(new FileInfo(filePath), password);
+
+    public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+    {
+        if (!fileInfo.Exists)
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+            return false;
         }
+        using Stream stream = fileInfo.OpenRead();
+        return IsZipFile(stream, password);
+    }
 
-        /// <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)
+    public static bool IsZipFile(Stream stream, string? password = null)
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
         {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new ZipArchive(fileInfo, 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);
-        }
-
-        public static bool IsZipFile(FileInfo fileInfo, string? password = null)
-        {
-            if (!fileInfo.Exists)
+            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 is 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,
-                                                                                         (DirectoryEntryHeader)h,
-                                                                                         stream));
-                            }
-                            break;
-                        case ZipHeaderType.DirectoryEnd:
-                            {
-                                byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                                volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                                yield break;
-                            }
-                    }
-                }
-            }
-        }
-
-        public void SaveTo(Stream stream)
-        {
-            SaveTo(stream, new WriterOptions(CompressionType.Deflate));
-        }
-
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<ZipArchiveEntry> oldEntries,
-                                       IEnumerable<ZipArchiveEntry> newEntries)
-        {
-            using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
-            {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    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 ZipArchive();
+
+    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 => ((SeekableZipFilePart)Parts.Single()).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
+        Match m = Regex.Match(part1.Name, @"^(.*\.)(zipx?|zx?[0-9]+)$", RegexOptions.IgnoreCase);
+        if (m.Success)
+            item = new FileInfo(
+                Path.Combine(
+                    part1.DirectoryName!,
+                    String.Concat(
+                        m.Groups[1].Value,
+                        Regex.Replace(m.Groups[2].Value, @"[^xz]", ""),
+                        index.ToString().PadLeft(2, '0')
+                    )
+                )
+            );
+        else //split - 001, 002 ...
+            return ArchiveVolumeFactory.GetFilePart(index, part1);
+
+        if (item != null && item.Exists)
+            return item;
+
+        return null; //no more items
+    }
+}

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/Common/ArchiveEncoding.cs

@@ -1,76 +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; }
+        Default = def;
+        Password = password;
+    }
 
-        /// <summary>
-        /// ArchiveEncoding used by encryption schemes which don't comply with RFC 2898.
-        /// </summary>
-        public Encoding Password { get; set; }
-
-        /// <summary>
-        /// Set this encoding when you want to force it for all encoding operations.
-        /// </summary>
-        public Encoding? Forced { get; set; }
-
-        /// <summary>
-        /// Set this when you want to use a custom method for all decoding operations.
-        /// </summary>
-        /// <returns>string Func(bytes, index, length)</returns>
-        public Func<byte[], int, int, string>? CustomDecoder { get; set; }
-
-        public ArchiveEncoding()
-        : this(Encoding.Default, Encoding.Default)
-        {
-        }
-        public ArchiveEncoding(Encoding def, Encoding password)
-        {
-            Default = def;
-            Password = password;
-        }
-
-#if !NET461
-        static ArchiveEncoding()
-        {
-            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
-        }
+#if !NETFRAMEWORK
+    static ArchiveEncoding() => Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
 #endif
 
-        public string Decode(byte[] bytes)
-        {
-            return Decode(bytes, 0, bytes.Length);
-        }
+    public string Decode(byte[] bytes) => Decode(bytes, 0, bytes.Length);
 
-        public string Decode(byte[] bytes, int start, int length)
-        {
-            return GetDecoder().Invoke(bytes, start, length);
-        }
+    public string Decode(byte[] bytes, int start, int length) =>
+        GetDecoder().Invoke(bytes, start, length);
 
-        public string DecodeUTF8(byte[] bytes)
-        {
-            return Encoding.UTF8.GetString(bytes, 0, bytes.Length);
-        }
+    public string DecodeUTF8(byte[] bytes) => Encoding.UTF8.GetString(bytes, 0, bytes.Length);
 
-        public byte[] Encode(string str)
-        {
-            return GetEncoding().GetBytes(str);
-        }
+    public byte[] Encode(string str) => GetEncoding().GetBytes(str);
 
-        public Encoding GetEncoding()
-        {
-            return Forced ?? Default ?? Encoding.UTF8;
-        }
+    public Encoding GetEncoding() => Forced ?? Default ?? Encoding.UTF8;
 
-        public Func<byte[], int, int, string> GetDecoder()
-        {
-            return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
-        }
-    }
+    public Func<byte[], int, int, string> GetDecoder() =>
+        CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
 }

src/SharpCompress/Common/ArchiveException.cs

@@ -1,17 +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, Exception inner)
-            : base(message, inner)
-        {
-        }
-    }
-}
+    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,12 +1,10 @@
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public enum ArchiveType
 {
-    public enum ArchiveType
-    {
-        Rar,
-        Zip,
-        Tar,
-        SevenZip,
-        GZip,
-        Dmg
-    }
-}
+    Rar,
+    Zip,
+    Tar,
+    SevenZip,
+    GZip
+}

src/SharpCompress/Common/CompressedBytesReadEventArgs.cs

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

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/Dmg/DmgBlockDataStream.cs

@@ -1,323 +0,0 @@
-using SharpCompress.Common.Dmg.Headers;
-using SharpCompress.Compressors;
-using SharpCompress.Compressors.ADC;
-using SharpCompress.Compressors.BZip2;
-using SharpCompress.Compressors.Deflate;
-using SharpCompress.IO;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace SharpCompress.Common.Dmg
-{
-    internal sealed class DmgBlockDataStream : Stream
-    {
-        private readonly Stream _baseStream;
-        private readonly DmgHeader _header;
-        private readonly BlkxTable _table;
-        private long _position;
-        private bool _isEnded;
-        private int _chunkIndex;
-        private Stream? _chunkStream;
-        private long _chunkPos;
-        
-        public override bool CanRead => true;
-        public override bool CanWrite => false;
-        public override bool CanSeek => true;
-        public override long Length { get; }
-
-        public override long Position
-        {
-            get => _position;
-            set
-            {
-                if ((value < 0) || (value > Length)) throw new ArgumentOutOfRangeException(nameof(value));
-
-                if (value == Length)
-                {
-                    // End of the stream
-
-                    _position = Length;
-                    _isEnded = true;
-                    _chunkIndex = -1;
-                    _chunkStream = null;
-                }
-                else if (value != _position)
-                {
-                    _position = value;
-
-                    // We can only seek over entire chunks at a time because some chunks may be compressed.
-                    // So we first find the chunk that we are now in, then we read to the exact position inside that chunk.
-
-                    for (int i = 0; i < _table.Chunks.Count; i++)
-                    {
-                        var chunk = _table.Chunks[i];
-                        if (IsChunkValid(chunk) && (chunk.UncompressedOffset <= (ulong)_position)
-                            && ((chunk.UncompressedOffset + chunk.UncompressedLength) > (ulong)_position))
-                        {
-                            if (i == _chunkIndex)
-                            {
-                                // We are still in the same chunk, so if the new position is
-                                // behind the previous one we can just read to the new position.
-
-                                long offset = (long)chunk.UncompressedOffset + _chunkPos;
-                                if (offset <= _position)
-                                {
-                                    long skip = _position - offset;
-                                    _chunkStream!.Skip(skip);
-                                    _chunkPos += skip;
-                                    break;
-                                }
-                            }
-
-                            _chunkIndex = i;
-                            _chunkStream = GetChunkStream();
-                            _chunkPos = 0;
-
-                            // If the chunk happens to not be compressed this read will still result in a fast seek
-                            if ((ulong)_position != chunk.UncompressedOffset)
-                            {
-                                long skip = _position - (long)chunk.UncompressedOffset;
-                                _chunkStream.Skip(skip);
-                                _chunkPos = skip;
-                            }
-
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        public DmgBlockDataStream(Stream baseStream, DmgHeader header, BlkxTable table)
-        {
-            if (!baseStream.CanRead) throw new ArgumentException("Requires a readable stream", nameof(baseStream));
-            if (!baseStream.CanSeek) throw new ArgumentException("Requires a seekable stream", nameof(baseStream));
-
-            _baseStream = baseStream;
-            _header = header;
-            _table = table;
-
-            Length = 0;
-            foreach (var chunk in table.Chunks)
-            {
-                if (IsChunkValid(chunk))
-                    Length += (long)chunk.UncompressedLength;
-            }
-
-            _position = 0;
-            _chunkIndex = -1;
-            _chunkIndex = GetNextChunk();
-            _isEnded = _chunkIndex < 0;
-            if (!_isEnded) _chunkStream = GetChunkStream();
-            _chunkPos = 0;
-        }
-
-        private static bool IsChunkValid(BlkxChunk chunk)
-        {
-            return chunk.Type switch
-            {
-                BlkxChunkType.Zero => true,
-                BlkxChunkType.Uncompressed => true,
-                BlkxChunkType.Ignore => true,
-                BlkxChunkType.AdcCompressed => true,
-                BlkxChunkType.ZlibCompressed => true,
-                BlkxChunkType.Bz2Compressed => true,
-                _ => false
-            };
-        }
-
-        private int GetNextChunk()
-        {
-            int index = _chunkIndex;
-            bool isValid = false;
-            while (!isValid)
-            {
-                index++;
-                if (index >= _table.Chunks.Count) return -1;
-
-                var chunk = _table.Chunks[index];
-                if (chunk.Type == BlkxChunkType.Last) return -1;
-
-                isValid = IsChunkValid(chunk);
-            }
-            return index;
-        }
-
-        private Stream GetChunkStream()
-        {
-            if (_chunkIndex < 0)
-                throw new InvalidOperationException("Invalid chunk index");
-
-            var chunk = _table.Chunks[_chunkIndex];
-
-            // For our purposes, ignore behaves the same as zero
-            if ((chunk.Type == BlkxChunkType.Zero) || (chunk.Type == BlkxChunkType.Ignore))
-                return new ConstantStream(0, (long)chunk.UncompressedLength);
-
-            // We first create a sub-stream on the region of the base stream where the
-            // (possibly compressed) data is physically located at.
-            var subStream = new SeekableSubStream(_baseStream,
-                (long)(_header.DataForkOffset + _table.DataOffset + chunk.CompressedOffset),
-                (long)chunk.CompressedLength);
-
-            // Then we nest that sub-stream into the apropriate compressed stream.
-            return chunk.Type switch
-            {
-                BlkxChunkType.Uncompressed => subStream,
-                BlkxChunkType.AdcCompressed => new ADCStream(subStream, CompressionMode.Decompress),
-                BlkxChunkType.ZlibCompressed => new ZlibStream(subStream, CompressionMode.Decompress),
-                BlkxChunkType.Bz2Compressed => new BZip2Stream(subStream, CompressionMode.Decompress, false),
-                _ => throw new InvalidOperationException("Invalid chunk type")
-            };
-        }
-
-        // Decompresses the entire stream in memory for faster extraction.
-        // This is about two orders of magnitude faster than decompressing
-        // on-the-fly while extracting, but also eats RAM for breakfest.
-        public Stream Decompress()
-        {
-            // We have to load all the chunks into separate memory streams first
-            // because otherwise the decompression threads would block each other
-            // and actually be slower than just a single decompression thread.
-
-            var rawStreams = new Stream?[_table.Chunks.Count];
-            for (int i = 0; i < rawStreams.Length; i++)
-            {
-                var chunk = _table.Chunks[i];
-                if (IsChunkValid(chunk))
-                {
-                    if ((chunk.Type == BlkxChunkType.Zero) || (chunk.Type == BlkxChunkType.Ignore))
-                    {
-                        rawStreams[i] = new ConstantStream(0, (long)chunk.UncompressedLength);
-                    }
-                    else
-                    {
-                        var subStream = new SeekableSubStream(_baseStream,
-                        (long)(_header.DataForkOffset + _table.DataOffset + chunk.CompressedOffset),
-                        (long)chunk.CompressedLength);
-
-                        var memStream = new MemoryStream();
-                        subStream.CopyTo(memStream);
-                        memStream.Position = 0;
-                        rawStreams[i] = memStream;
-                    }
-                }
-                else
-                {
-                    rawStreams[i] = null;
-                }
-            }
-
-            // Now we can decompress the chunks multithreaded
-
-            var streams = new Stream?[_table.Chunks.Count];
-            Parallel.For(0, streams.Length, i =>
-            {
-                var rawStream = rawStreams[i];
-                if (rawStream is not null)
-                {
-                    var chunk = _table.Chunks[i];
-                    if ((chunk.Type == BlkxChunkType.Zero)
-                     || (chunk.Type == BlkxChunkType.Ignore)
-                     || (chunk.Type == BlkxChunkType.Uncompressed))
-                    {
-                        streams[i] = rawStream;
-                    }
-                    else
-                    {
-                        Stream compStream = chunk.Type switch
-                        {
-                            BlkxChunkType.AdcCompressed => new ADCStream(rawStream, CompressionMode.Decompress),
-                            BlkxChunkType.ZlibCompressed => new ZlibStream(rawStream, CompressionMode.Decompress),
-                            BlkxChunkType.Bz2Compressed => new BZip2Stream(rawStream, CompressionMode.Decompress, false),
-                            _ => throw new InvalidOperationException("Invalid chunk type")
-                        };
-
-                        var memStream = new MemoryStream();
-                        compStream.CopyTo(memStream);
-                        compStream.Dispose();
-
-                        memStream.Position = 0;
-                        streams[i] = memStream;
-                    }
-
-                    rawStream.Dispose();
-                    rawStreams[i] = null;
-                }
-                else
-                {
-                    streams[i] = null;
-                }
-            });
-
-            return new CompositeStream((IEnumerable<Stream>)streams.Where(s => s is not null));
-        }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_isEnded) return 0;
-
-            int readCount = _chunkStream!.Read(buffer, offset, count);
-            _chunkPos += readCount;
-
-            while (readCount < count)
-            {
-                // Current chunk has ended, so we have to continue reading from the next chunk.
-
-                _chunkIndex = GetNextChunk();
-                if (_chunkIndex < 0)
-                {
-                    // We have reached the last chunk
-
-                    _isEnded = true;
-                    _chunkPos = 0;
-                    _position += readCount;
-                    return readCount;
-                }
-
-                _chunkStream = GetChunkStream();
-                int rc = _chunkStream.Read(buffer, offset + readCount, count - readCount);
-                _chunkPos = rc;
-                readCount += rc;
-            }
-
-            _position += readCount;
-            return readCount;
-        }
-
-        public override void Flush()
-        { }
-
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            switch (origin)
-            {
-                case SeekOrigin.Begin:
-                    Position = offset;
-                    break;
-
-                case SeekOrigin.Current:
-                    Position += offset;
-                    break;
-
-                case SeekOrigin.End:
-                    Position = Length - offset;
-                    break;
-            }
-
-            return Position;
-        }
-
-        public override void SetLength(long value)
-            => throw new NotSupportedException();
-
-        public override void Write(byte[] buffer, int offset, int count)
-            => throw new NotSupportedException();
-
-        protected override void Dispose(bool disposing)
-        { }
-    }
-}

src/SharpCompress/Common/Dmg/DmgEntry.cs

@@ -1,52 +0,0 @@
-using SharpCompress.Common.Dmg.HFS;
-using System;
-using System.Collections.Generic;
-
-namespace SharpCompress.Common.Dmg
-{
-    public abstract class DmgEntry : Entry
-    {
-        public override string Key { get; }
-        public override bool IsDirectory { get; }
-        public override long Size { get; }
-        public override long CompressedSize { get; }
-        public override CompressionType CompressionType { get; }
-        public override DateTime? LastModifiedTime { get; }
-        public override DateTime? CreatedTime { get; }
-        public override DateTime? LastAccessedTime { get; }
-        public override DateTime? ArchivedTime { get; }
-        
-        public override long Crc { get; } = 0; // Not stored
-        public override string? LinkTarget { get; } = null;
-        public override bool IsEncrypted { get; } = false;
-        public override bool IsSplitAfter { get; } = false;
-
-        internal override IEnumerable<FilePart> Parts { get; }
-
-        internal DmgEntry(HFSCatalogRecord record, string path, long size, DmgFilePart part)
-        {
-            Key = path;
-            IsDirectory = record.Type == HFSCatalogRecordType.Folder;
-            Size = CompressedSize = size;              // There is no way to get the actual compressed size or the compression type of
-            CompressionType = CompressionType.Unknown; // a file in a DMG archive since the files are nested inside the HFS partition.
-            Parts = part.AsEnumerable();
-
-            if (IsDirectory)
-            {
-                var folder = (HFSCatalogFolder)record;
-                LastModifiedTime = (folder.AttributeModDate > folder.ContentModDate) ? folder.AttributeModDate : folder.ContentModDate;
-                CreatedTime = folder.CreateDate;
-                LastAccessedTime = folder.AccessDate;
-                ArchivedTime = folder.BackupDate;
-            }
-            else
-            {
-                var file = (HFSCatalogFile)record;
-                LastModifiedTime = (file.AttributeModDate > file.ContentModDate) ? file.AttributeModDate : file.ContentModDate;
-                CreatedTime = file.CreateDate;
-                LastAccessedTime = file.AccessDate;
-                ArchivedTime = file.BackupDate;
-            }
-        }
-    }
-}

src/SharpCompress/Common/Dmg/DmgFilePart.cs

@@ -1,21 +0,0 @@
-using System.IO;
-
-namespace SharpCompress.Common.Dmg
-{
-    internal sealed class DmgFilePart : FilePart
-    {
-        private readonly Stream _stream;
-
-        internal override string FilePartName { get; }
-
-        public DmgFilePart(Stream stream, string fileName)
-            : base(new ArchiveEncoding())
-        {
-            _stream = stream;
-            FilePartName = fileName;
-        }
-
-        internal override Stream GetCompressedStream() => _stream;
-        internal override Stream? GetRawStream() => null;
-    }
-}

src/SharpCompress/Common/Dmg/DmgUtil.cs

@@ -1,183 +0,0 @@
-using SharpCompress.Common.Dmg.Headers;
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
-using System.Text;
-using System.Xml.Linq;
-
-namespace SharpCompress.Common.Dmg
-{
-    internal static class DmgUtil
-    {
-        private const string MalformedXmlMessage = "Malformed XML block";
-
-        private static T[] ParseArray<T>(in XElement parent, in Func<XElement, T> parseElement)
-        {
-            var list = new List<T>();
-
-            foreach (var node in parent.Elements())
-                list.Add(parseElement(node));
-
-            return list.ToArray();
-        }
-
-        private static Dictionary<string, T> ParseDict<T>(in XElement parent, in Func<XElement, T> parseValue)
-        {
-            var dict = new Dictionary<string, T>();
-
-            string? key = null;
-            foreach (var node in parent.Elements())
-            {
-                if (string.Equals(node.Name.LocalName, "key", StringComparison.Ordinal))
-                {
-                    key = node.Value;
-                }
-                else if (key is not null)
-                {
-                    var value = parseValue(node);
-                    dict.Add(key, value);
-                    key = null;
-                }
-            }
-
-            return dict;
-        }
-
-        private static Dictionary<string, Dictionary<string, Dictionary<string, string>[]>> ParsePList(in XDocument doc)
-        {
-            var dictNode = doc.Root?.Element("dict");
-            if (dictNode is null) throw new InvalidFormatException(MalformedXmlMessage);
-
-            static Dictionary<string, string> ParseObject(XElement parent)
-                => ParseDict(parent, node => node.Value);
-
-            static Dictionary<string, string>[] ParseObjectArray(XElement parent)
-                => ParseArray(parent, ParseObject);
-
-            static Dictionary<string, Dictionary<string, string>[]> ParseSubDict(XElement parent)
-                => ParseDict(parent, ParseObjectArray);
-
-            return ParseDict(dictNode, ParseSubDict);
-        }
-
-        private static BlkxData CreateDataFromDict(in Dictionary<string, string> dict)
-        {
-            static bool TryParseHex(string? s, out uint value)
-            {
-                value = 0;
-                if (string.IsNullOrEmpty(s)) return false;
-
-                if (s!.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
-                    s = s.Substring(2);
-
-                return uint.TryParse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out value);
-            }
-
-            if (!dict.TryGetValue("ID", out string? idStr) || !int.TryParse(idStr, out int id))
-                throw new InvalidFormatException(MalformedXmlMessage);
-            if (!dict.TryGetValue("Name", out string? name))
-                throw new InvalidFormatException(MalformedXmlMessage);
-            if (!dict.TryGetValue("Attributes", out string? attribStr) || !TryParseHex(attribStr, out uint attribs))
-                throw new InvalidFormatException(MalformedXmlMessage);
-            if (!dict.TryGetValue("Data", out string? base64Data) || string.IsNullOrEmpty(base64Data))
-                throw new InvalidFormatException(MalformedXmlMessage);
-
-            try
-            {
-                var data = Convert.FromBase64String(base64Data);
-                if (!BlkxTable.TryRead(data, out var table))
-                    throw new InvalidFormatException("Invalid BLKX table");
-
-                return new BlkxData(id, name, attribs, table!);
-            }
-            catch (FormatException ex)
-            {
-                throw new InvalidFormatException(MalformedXmlMessage, ex);
-            }
-        }
-
-        public static DmgBlockDataStream? LoadHFSPartitionStream(Stream baseStream, DmgHeader header)
-        {
-            if ((header.XMLOffset + header.XMLLength) >= (ulong)baseStream.Length)
-                throw new IncompleteArchiveException("XML block incomplete");
-            if ((header.DataForkOffset + header.DataForkLength) >= (ulong)baseStream.Length)
-                throw new IncompleteArchiveException("Data block incomplete");
-
-            baseStream.Position = (long)header.XMLOffset;
-            var xmlBuffer = new byte[header.XMLLength];
-            baseStream.Read(xmlBuffer, 0, (int)header.XMLLength);
-            var xml = Encoding.ASCII.GetString(xmlBuffer);
-
-            var doc = XDocument.Parse(xml);
-            var pList = ParsePList(doc);
-            if (!pList.TryGetValue("resource-fork", out var resDict) || !resDict.TryGetValue("blkx", out var blkxDicts))
-                throw new InvalidFormatException(MalformedXmlMessage);
-
-            var objs = new BlkxData[blkxDicts.Length];
-            for (int i = 0; i < objs.Length; i++)
-                objs[i] = CreateDataFromDict(blkxDicts[i]);
-
-            // Index 0 is the protective MBR partition
-            // Index 1 is the GPT header
-            // Index 2 is the GPT partition table
-
-            try
-            {
-                var headerData = objs[1];
-                using var headerStream = new DmgBlockDataStream(baseStream, header, headerData.Table);
-                if (!GptHeader.TryRead(headerStream, out var gptHeader))
-                    throw new InvalidFormatException("Invalid GPT header");
-
-                var tableData = objs[2];
-                using var tableStream = new DmgBlockDataStream(baseStream, header, tableData.Table);
-                var gptTable = new GptPartitionEntry[gptHeader!.EntriesCount];
-                for (int i = 0; i < gptHeader.EntriesCount; i++)
-                    gptTable[i] = GptPartitionEntry.Read(tableStream);
-
-                foreach (var entry in gptTable)
-                {
-                    if (entry.TypeGuid == PartitionFormat.AppleHFS)
-                    {
-                        BlkxData? partitionData = null;
-                        for (int i = 3; i < objs.Length; i++)
-                        {
-                            if (objs[i].Name.StartsWith(entry.Name, StringComparison.Ordinal))
-                            {
-                                partitionData = objs[i];
-                                break;
-                            }
-                        }
-
-                        if (partitionData is null)
-                            throw new InvalidFormatException($"Missing partition {entry.Name}");
-
-                        return new DmgBlockDataStream(baseStream, header, partitionData.Table);
-                    }
-                }
-
-                return null;
-            }
-            catch (EndOfStreamException ex)
-            {
-                throw new IncompleteArchiveException("Partition incomplete", ex);
-            }
-        }
-
-        private sealed class BlkxData
-        {
-            public int Id { get; }
-            public string Name { get; }
-            public uint Attributes { get; }
-            public BlkxTable Table { get; }
-
-            public BlkxData(int id, string name, uint attributes, BlkxTable table)
-            {
-                Id = id;
-                Name = name;
-                Attributes = attributes;
-                Table = table;
-            }
-        }
-    }
-}

src/SharpCompress/Common/Dmg/DmgVolume.cs

@@ -1,38 +0,0 @@
-using SharpCompress.Archives.Dmg;
-using SharpCompress.Common.Dmg.Headers;
-using SharpCompress.Common.Dmg.HFS;
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg
-{
-    public class DmgVolume : Volume
-    {
-        private readonly DmgArchive _archive;
-        private readonly string _fileName;
-
-        internal DmgHeader Header { get; }
-
-        public DmgVolume(DmgArchive archive, Stream stream, string fileName, Readers.ReaderOptions readerOptions)
-            : base(stream, readerOptions)
-        {
-            _archive = archive;
-            _fileName = fileName;
-
-            long pos = stream.Length - DmgHeader.HeaderSize;
-            if (pos < 0) throw new InvalidFormatException("Invalid DMG volume");
-            stream.Position = pos;
-
-            if (DmgHeader.TryRead(stream, out var header)) Header = header!;
-            else throw new InvalidFormatException("Invalid DMG volume");
-        }
-
-        internal IEnumerable<DmgArchiveEntry> LoadEntries()
-        {
-            var partitionStream = DmgUtil.LoadHFSPartitionStream(Stream, Header);
-            if (partitionStream is null) return Array.Empty<DmgArchiveEntry>();
-            else return HFSUtil.LoadEntriesFromPartition(partitionStream, _fileName, _archive);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSCatalogRecord.cs

@@ -1,336 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSCatalogKey : HFSStructBase, IEquatable<HFSCatalogKey>, IComparable<HFSCatalogKey>, IComparable
-    {
-        private readonly StringComparer _comparer;
-
-        public uint ParentId { get; }
-
-        public string Name { get; }
-
-        private static StringComparer GetComparer(HFSKeyCompareType compareType, bool isHFSX)
-        {
-            if (isHFSX)
-            {
-                return compareType switch
-                {
-                    HFSKeyCompareType.CaseFolding => StringComparer.InvariantCultureIgnoreCase,
-                    HFSKeyCompareType.BinaryCompare => StringComparer.Ordinal,
-                    _ => StringComparer.InvariantCultureIgnoreCase
-                };
-            }
-            else
-            {
-                return StringComparer.InvariantCultureIgnoreCase;
-            }
-        }
-
-        public HFSCatalogKey(uint parentId, string name, HFSKeyCompareType compareType, bool isHFSX)
-        {
-            ParentId = parentId;
-            Name = name;
-            _comparer = GetComparer(compareType, isHFSX);
-        }
-
-        public HFSCatalogKey(byte[] key, HFSKeyCompareType compareType, bool isHFSX)
-        {
-            ReadOnlySpan<byte> data = key.AsSpan();
-            ParentId = ReadUInt32(ref data);
-            Name = ReadString(ref data, true);
-            _comparer = GetComparer(compareType, isHFSX);
-        }
-
-        public bool Equals(HFSCatalogKey? other)
-        {
-            if (other is null) return false;
-            else return (ParentId == other.ParentId) && _comparer.Equals(Name, other.Name);
-        }
-
-        public override bool Equals(object? obj)
-        {
-            if (obj is HFSCatalogKey other) return Equals(other);
-            else return false;
-        }
-
-        public int CompareTo(HFSCatalogKey? other)
-        {
-            if (other is null) return 1;
-
-            int result = ParentId.CompareTo(other.ParentId);
-            if (result == 0) result = _comparer.Compare(Name, other.Name);
-            return result;
-        }
-
-        public int CompareTo(object? obj)
-        {
-            if (obj is null) return 1;
-            else if (obj is HFSCatalogKey other) return CompareTo(other);
-            else throw new ArgumentException("Object is not of type CatalogKey", nameof(obj));
-        }
-
-        public override int GetHashCode()
-            => ParentId.GetHashCode() ^ _comparer.GetHashCode(Name);
-
-        public static bool operator ==(HFSCatalogKey? left, HFSCatalogKey? right)
-        {
-            if (left is null) return right is null;
-            else return left.Equals(right);
-        }
-
-        public static bool operator !=(HFSCatalogKey? left, HFSCatalogKey? right)
-        {
-            if (left is null) return right is not null;
-            else return !left.Equals(right);
-        }
-
-        public static bool operator <(HFSCatalogKey? left, HFSCatalogKey? right)
-        {
-            if (left is null) return right is not null;
-            else return left.CompareTo(right) < 0;
-        }
-
-        public static bool operator >(HFSCatalogKey? left, HFSCatalogKey? right)
-        {
-            if (left is null) return false;
-            else return left.CompareTo(right) > 0;
-        }
-
-        public static bool operator <=(HFSCatalogKey? left, HFSCatalogKey? right)
-        {
-            if (left is null) return true;
-            else return left.CompareTo(right) <= 0;
-        }
-
-        public static bool operator >=(HFSCatalogKey? left, HFSCatalogKey? right)
-        {
-            if (left is null) return right is null;
-            else return left.CompareTo(right) >= 0;
-        }
-    }
-
-    internal enum HFSCatalogRecordType : ushort
-    {
-        Folder = 0x0001,
-        File = 0x0002,
-        FolderThread = 0x0003,
-        FileThread = 0x0004
-    }
-
-    internal abstract class HFSCatalogRecord : HFSStructBase
-    {
-        public HFSCatalogRecordType Type { get; }
-
-        protected HFSCatalogRecord(HFSCatalogRecordType type)
-            => Type = type;
-
-        public static bool TryRead(ref ReadOnlySpan<byte> data, HFSKeyCompareType compareType, bool isHFSX, out HFSCatalogRecord? record)
-        {
-            record = null;
-
-            ushort rawType = ReadUInt16(ref data);
-            if (!Enum.IsDefined(typeof(HFSCatalogRecordType), rawType)) return false;
-
-            var type = (HFSCatalogRecordType)rawType;
-            switch (type)
-            {
-                case HFSCatalogRecordType.Folder:
-                    record = HFSCatalogFolder.Read(ref data);
-                    return true;
-
-                case HFSCatalogRecordType.File:
-                    record = HFSCatalogFile.Read(ref data);
-                    return true;
-
-                case HFSCatalogRecordType.FolderThread:
-                    record = HFSCatalogThread.Read(ref data, false, compareType, isHFSX);
-                    return true;
-
-                case HFSCatalogRecordType.FileThread:
-                    record = HFSCatalogThread.Read(ref data, true, compareType, isHFSX);
-                    return true;
-            }
-
-            return false;
-        }
-    }
-
-    internal sealed class HFSCatalogFolder : HFSCatalogRecord
-    {
-        public uint Valence { get; }
-        public uint FolderId { get; }
-        public DateTime CreateDate { get; }
-        public DateTime ContentModDate { get; }
-        public DateTime AttributeModDate { get; }
-        public DateTime AccessDate { get; }
-        public DateTime BackupDate { get; }
-        public HFSPermissions Permissions { get; }
-        public HFSFolderInfo Info { get; }
-        public uint TextEncoding { get; }
-
-        private HFSCatalogFolder(
-            uint valence,
-            uint folderId,
-            DateTime createDate,
-            DateTime contentModDate,
-            DateTime attributeModDate,
-            DateTime accessDate,
-            DateTime backupDate,
-            HFSPermissions permissions,
-            HFSFolderInfo info,
-            uint textEncoding)
-            : base(HFSCatalogRecordType.Folder)
-        {
-            Valence = valence;
-            FolderId = folderId;
-            CreateDate = createDate;
-            ContentModDate = contentModDate;
-            AttributeModDate = attributeModDate;
-            AccessDate = accessDate;
-            BackupDate = backupDate;
-            Permissions = permissions;
-            Info = info;
-            TextEncoding = textEncoding;
-        }
-
-        public static HFSCatalogFolder Read(ref ReadOnlySpan<byte> data)
-        {
-            _ = ReadUInt16(ref data); // reserved
-            uint valence = ReadUInt32(ref data);
-            uint folderId = ReadUInt32(ref data);
-            var createDate = ReadDate(ref data);
-            var contentModDate = ReadDate(ref data);
-            var attributeModDate = ReadDate(ref data);
-            var accessDate = ReadDate(ref data);
-            var backupDate = ReadDate(ref data);
-            var permissions = HFSPermissions.Read(ref data);
-            var info = HFSFolderInfo.Read(ref data);
-            uint textEncoding = ReadUInt32(ref data);
-            _ = ReadUInt32(ref data); // reserved
-
-            return new HFSCatalogFolder(
-                valence,
-                folderId,
-                createDate,
-                contentModDate,
-                attributeModDate,
-                accessDate,
-                backupDate,
-                permissions,
-                info,
-                textEncoding);
-        }
-    }
-
-    internal enum HFSFileFlags : ushort
-    {
-        LockedBit = 0x0000,
-        LockedMask = 0x0001,
-        ThreadExistsBit = 0x0001,
-        ThreadExistsMask = 0x0002
-    }
-
-    internal sealed class HFSCatalogFile : HFSCatalogRecord
-    {
-        public HFSFileFlags Flags { get; }
-        public uint FileId { get; }
-        public DateTime CreateDate { get; }
-        public DateTime ContentModDate { get; }
-        public DateTime AttributeModDate { get; }
-        public DateTime AccessDate { get; }
-        public DateTime BackupDate { get; }
-        public HFSPermissions Permissions { get; }
-        public HFSFileInfo Info { get; }
-        public uint TextEncoding { get; }
-
-        public HFSForkData DataFork { get; }
-        public HFSForkData ResourceFork { get; }
-
-        private HFSCatalogFile(
-            HFSFileFlags flags,
-            uint fileId,
-            DateTime createDate,
-            DateTime contentModDate,
-            DateTime attributeModDate,
-            DateTime accessDate,
-            DateTime backupDate,
-            HFSPermissions permissions,
-            HFSFileInfo info,
-            uint textEncoding,
-            HFSForkData dataFork,
-            HFSForkData resourceFork)
-            :base(HFSCatalogRecordType.File)
-        {
-            Flags = flags;
-            FileId = fileId;
-            CreateDate = createDate;
-            ContentModDate = contentModDate;
-            AttributeModDate = attributeModDate;
-            AccessDate = accessDate;
-            BackupDate = backupDate;
-            Permissions = permissions;
-            Info = info;
-            TextEncoding = textEncoding;
-            DataFork = dataFork;
-            ResourceFork = resourceFork;
-        }
-
-        public static HFSCatalogFile Read(ref ReadOnlySpan<byte> data)
-        {
-            var flags = (HFSFileFlags)ReadUInt16(ref data);
-            _ = ReadUInt32(ref data); // reserved
-            uint fileId = ReadUInt32(ref data);
-            var createDate = ReadDate(ref data);
-            var contentModDate = ReadDate(ref data);
-            var attributeModDate = ReadDate(ref data);
-            var accessDate = ReadDate(ref data);
-            var backupDate = ReadDate(ref data);
-            var permissions = HFSPermissions.Read(ref data);
-            var info = HFSFileInfo.Read(ref data);
-            uint textEncoding = ReadUInt32(ref data);
-            _ = ReadUInt32(ref data); // reserved
-
-            var dataFork = HFSForkData.Read(ref data);
-            var resourceFork = HFSForkData.Read(ref data);
-
-            return new HFSCatalogFile(
-                flags,
-                fileId,
-                createDate,
-                contentModDate,
-                attributeModDate,
-                accessDate,
-                backupDate,
-                permissions,
-                info,
-                textEncoding,
-                dataFork,
-                resourceFork);
-        }
-    }
-
-    internal sealed class HFSCatalogThread : HFSCatalogRecord
-    {
-        public uint ParentId { get; }
-        public string NodeName { get; }
-        public HFSCatalogKey CatalogKey { get; }
-
-        private HFSCatalogThread(uint parentId, string nodeName, bool isFile, HFSKeyCompareType compareType, bool isHFSX)
-            : base(isFile ? HFSCatalogRecordType.FileThread : HFSCatalogRecordType.FolderThread)
-        {
-            ParentId = parentId;
-            NodeName = nodeName;
-            CatalogKey = new HFSCatalogKey(ParentId, NodeName, compareType, isHFSX);
-        }
-
-        public static HFSCatalogThread Read(ref ReadOnlySpan<byte> data, bool isFile, HFSKeyCompareType compareType, bool isHFSX)
-        {
-            _ = ReadInt16(ref data); // reserved
-            uint parentId = ReadUInt32(ref data);
-            string nodeName = ReadString(ref data, true);
-
-            return new HFSCatalogThread(parentId, nodeName, isFile, compareType, isHFSX);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSExtentDescriptor.cs

@@ -1,31 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSExtentDescriptor : HFSStructBase
-    {
-        public uint StartBlock { get; }
-        public uint BlockCount { get; }
-
-        private HFSExtentDescriptor(uint startBlock, uint blockCount)
-        {
-            StartBlock = startBlock;
-            BlockCount = blockCount;
-        }
-
-        public static HFSExtentDescriptor Read(Stream stream)
-        {
-            return new HFSExtentDescriptor(
-                ReadUInt32(stream),
-                ReadUInt32(stream));
-        }
-
-        public static HFSExtentDescriptor Read(ref ReadOnlySpan<byte> data)
-        {
-            return new HFSExtentDescriptor(
-                ReadUInt32(ref data),
-                ReadUInt32(ref data));
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSExtentRecord.cs

@@ -1,115 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSExtentKey : HFSStructBase, IEquatable<HFSExtentKey>, IComparable<HFSExtentKey>, IComparable
-    {
-        public byte ForkType { get; }
-        public uint FileId { get; }
-        public uint StartBlock { get; }
-
-        public HFSExtentKey(byte forkType, uint fileId, uint startBlock)
-        {
-            ForkType = forkType;
-            FileId = fileId;
-            StartBlock = startBlock;
-        }
-
-        public HFSExtentKey(byte[] key)
-        {
-            ReadOnlySpan<byte> data = key.AsSpan();
-            ForkType = ReadUInt8(ref data);
-            _ = ReadUInt8(ref data); // padding
-            FileId = ReadUInt32(ref data);
-            StartBlock = ReadUInt32(ref data);
-        }
-
-        public bool Equals(HFSExtentKey? other)
-        {
-            if (other is null) return false;
-            else return (ForkType == other.ForkType) && (FileId == other.FileId) && (StartBlock == other.StartBlock);
-        }
-
-        public override bool Equals(object? obj)
-        {
-            if (obj is HFSExtentKey other) return Equals(other);
-            else return false;
-        }
-
-        public int CompareTo(HFSExtentKey? other)
-        {
-            if (other is null) return 1;
-
-            int result = FileId.CompareTo(other.FileId);
-            if (result == 0) result = ForkType.CompareTo(other.ForkType);
-            if (result == 0) result = StartBlock.CompareTo(other.StartBlock);
-            return result;
-        }
-
-        public int CompareTo(object? obj)
-        {
-            if (obj is null) return 1;
-            else if (obj is HFSExtentKey other) return CompareTo(other);
-            else throw new ArgumentException("Object is not of type ExtentKey", nameof(obj));
-        }
-
-        public override int GetHashCode()
-            => ForkType.GetHashCode() ^ FileId.GetHashCode() ^ StartBlock.GetHashCode();
-
-        public static bool operator ==(HFSExtentKey? left, HFSExtentKey? right)
-        {
-            if (left is null) return right is null;
-            else return left.Equals(right);
-        }
-
-        public static bool operator !=(HFSExtentKey? left, HFSExtentKey? right)
-        {
-            if (left is null) return right is not null;
-            else return !left.Equals(right);
-        }
-
-        public static bool operator <(HFSExtentKey? left, HFSExtentKey? right)
-        {
-            if (left is null) return right is not null;
-            else return left.CompareTo(right) < 0;
-        }
-
-        public static bool operator >(HFSExtentKey? left, HFSExtentKey? right)
-        {
-            if (left is null) return false;
-            else return left.CompareTo(right) > 0;
-        }
-
-        public static bool operator <=(HFSExtentKey? left, HFSExtentKey? right)
-        {
-            if (left is null) return true;
-            else return left.CompareTo(right) <= 0;
-        }
-
-        public static bool operator >=(HFSExtentKey? left, HFSExtentKey? right)
-        {
-            if (left is null) return right is null;
-            else return left.CompareTo(right) >= 0;
-        }
-    }
-
-    internal sealed class HFSExtentRecord : HFSStructBase
-    {
-        private const int ExtentCount = 8;
-
-        public IReadOnlyList<HFSExtentDescriptor> Extents { get; }
-
-        private HFSExtentRecord(IReadOnlyList<HFSExtentDescriptor> extents)
-            => Extents = extents;
-
-        public static HFSExtentRecord Read(ref ReadOnlySpan<byte> data)
-        {
-            var extents = new HFSExtentDescriptor[ExtentCount];
-            for (int i = 0; i < ExtentCount; i++)
-                extents[i] = HFSExtentDescriptor.Read(ref data);
-
-            return new HFSExtentRecord(extents);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSFinderInfo.cs

@@ -1,145 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal struct HFSPoint
-    {
-        public short V;
-        public short H;
-    }
-
-    internal struct HFSRect
-    {
-        public short Top;
-        public short Left;
-        public short Bottom;
-        public short Right;
-    }
-
-    [Flags]
-    internal enum HFSFinderFlags : ushort
-    {
-        None = 0x0000,
-
-        IsOnDesk = 0x0001,      /* Files and folders (System 6) */
-        Color = 0x000E,         /* Files and folders */
-        IsShared = 0x0040,      /* Files only (Applications only) If */
-                                /* clear, the application needs */
-                                /* to write to its resource fork, */
-                                /* and therefore cannot be shared */
-                                /* on a server */
-        HasNoINITs = 0x0080,    /* Files only (Extensions/Control */
-                                /* Panels only) */
-                                /* This file contains no INIT resource */
-        HasBeenInited = 0x0100, /* Files only.  Clear if the file */
-                                /* contains desktop database resources */
-                                /* ('BNDL', 'FREF', 'open', 'kind'...) */
-                                /* that have not been added yet.  Set */
-                                /* only by the Finder. */
-                                /* Reserved for folders */
-        HasCustomIcon = 0x0400, /* Files and folders */
-        IsStationery = 0x0800,  /* Files only */
-        NameLocked = 0x1000,    /* Files and folders */
-        HasBundle = 0x2000,     /* Files only */
-        IsInvisible = 0x4000,   /* Files and folders */
-        IsAlias = 0x8000        /* Files only */
-    }
-
-    [Flags]
-    internal enum HFSExtendedFinderFlags : ushort
-    {
-        None = 0x0000,
-
-        ExtendedFlagsAreInvalid = 0x8000, /* The other extended flags */
-                                          /* should be ignored */
-        HasCustomBadge = 0x0100,          /* The file or folder has a */
-                                          /* badge resource */
-        HasRoutingInfo = 0x0004           /* The file contains routing */
-                                          /* info resource */
-    }
-
-    internal sealed class HFSFileInfo : HFSStructBase
-    {
-        public string FileType { get; }             /* The type of the file */
-        public string FileCreator { get; }          /* The file's creator */
-        public HFSFinderFlags FinderFlags { get; }
-        public HFSPoint Location { get; }           /* File's location in the folder. */
-        public HFSExtendedFinderFlags ExtendedFinderFlags { get; }
-        public int PutAwayFolderId { get; }
-
-        private HFSFileInfo(
-            string fileType,
-            string fileCreator,
-            HFSFinderFlags finderFlags,
-            HFSPoint location,
-            HFSExtendedFinderFlags extendedFinderFlags,
-            int putAwayFolderId)
-        {
-            FileType = fileType;
-            FileCreator = fileCreator;
-            FinderFlags = finderFlags;
-            Location = location;
-            ExtendedFinderFlags = extendedFinderFlags;
-            PutAwayFolderId = putAwayFolderId;
-        }
-
-        public static HFSFileInfo Read(ref ReadOnlySpan<byte> data)
-        {
-            string fileType = ReadOSType(ref data);
-            string fileCreator = ReadOSType(ref data);
-            var finderFlags = (HFSFinderFlags)ReadUInt16(ref data);
-            var location = ReadPoint(ref data);
-            _ = ReadUInt16(ref data); // reserved
-            data = data.Slice(4 * sizeof(short)); // reserved
-            var extendedFinderFlags = (HFSExtendedFinderFlags)ReadUInt16(ref data);
-            _ = ReadInt16(ref data); // reserved
-            int putAwayFolderId = ReadInt32(ref data);
-
-            return new HFSFileInfo(fileType, fileCreator, finderFlags, location, extendedFinderFlags, putAwayFolderId);
-        }
-    }
-
-    internal sealed class HFSFolderInfo : HFSStructBase
-    {
-        public HFSRect WindowBounds { get; }    /* The position and dimension of the */
-                                                /* folder's window */
-        public HFSFinderFlags FinderFlags { get; }
-        public HFSPoint Location { get; }       /* Folder's location in the parent */
-                                                /* folder. If set to {0, 0}, the Finder */
-                                                /* will place the item automatically */
-        public HFSPoint ScrollPosition { get; } /* Scroll position (for icon views) */
-        public HFSExtendedFinderFlags ExtendedFinderFlags { get; }
-        public int PutAwayFolderId { get; }
-
-        private HFSFolderInfo(
-            HFSRect windowBounds,
-            HFSFinderFlags finderFlags,
-            HFSPoint location,
-            HFSPoint scrollPosition,
-            HFSExtendedFinderFlags extendedFinderFlags,
-            int putAwayFolderId)
-        {
-            WindowBounds = windowBounds;
-            FinderFlags = finderFlags;
-            Location = location;
-            ScrollPosition = scrollPosition;
-            ExtendedFinderFlags = extendedFinderFlags;
-            PutAwayFolderId = putAwayFolderId;
-        }
-
-        public static HFSFolderInfo Read(ref ReadOnlySpan<byte> data)
-        {
-            var windowBounds = ReadRect(ref data);
-            var finderFlags = (HFSFinderFlags)ReadUInt16(ref data);
-            var location = ReadPoint(ref data);
-            _ = ReadUInt16(ref data); // reserved
-            var scrollPosition = ReadPoint(ref data);
-            _ = ReadInt32(ref data); // reserved
-            var extendedFinderFlags = (HFSExtendedFinderFlags)ReadUInt16(ref data);
-            _ = ReadInt16(ref data); // reserved
-            int putAwayFolderId = ReadInt32(ref data);
-
-            return new HFSFolderInfo(windowBounds, finderFlags, location, scrollPosition, extendedFinderFlags, putAwayFolderId);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSForkData.cs

@@ -1,50 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSForkData : HFSStructBase
-    {
-        private const int ExtentCount = 8;
-
-        public ulong LogicalSize { get; }
-        public uint ClumpSize { get; }
-        public uint TotalBlocks { get; }
-        public IReadOnlyList<HFSExtentDescriptor> Extents { get; }
-
-        private HFSForkData(ulong logicalSize, uint clumpSize, uint totalBlocks, IReadOnlyList<HFSExtentDescriptor> extents)
-        {
-            LogicalSize = logicalSize;
-            ClumpSize = clumpSize;
-            TotalBlocks = totalBlocks;
-            Extents = extents;
-        }
-
-        public static HFSForkData Read(Stream stream)
-        {
-            ulong logicalSize = ReadUInt64(stream);
-            uint clumpSize = ReadUInt32(stream);
-            uint totalBlocks = ReadUInt32(stream);
-
-            var extents = new HFSExtentDescriptor[ExtentCount];
-            for (int i = 0; i < ExtentCount; i++)
-                extents[i] = HFSExtentDescriptor.Read(stream);
-
-            return new HFSForkData(logicalSize, clumpSize, totalBlocks, extents);
-        }
-
-        public static HFSForkData Read(ref ReadOnlySpan<byte> data)
-        {
-            ulong logicalSize = ReadUInt64(ref data);
-            uint clumpSize = ReadUInt32(ref data);
-            uint totalBlocks = ReadUInt32(ref data);
-
-            var extents = new HFSExtentDescriptor[ExtentCount];
-            for (int i = 0; i < ExtentCount; i++)
-                extents[i] = HFSExtentDescriptor.Read(ref data);
-
-            return new HFSForkData(logicalSize, clumpSize, totalBlocks, extents);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSForkStream.cs

@@ -1,196 +0,0 @@
-using SharpCompress.IO;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSForkStream : Stream
-    {
-        private readonly Stream _baseStream;
-        private readonly HFSVolumeHeader _volumeHeader;
-        private readonly IReadOnlyList<HFSExtentDescriptor> _extents;
-        private long _position;
-        private bool _isEnded;
-        private int _extentIndex;
-        private Stream? _extentStream;
-
-        public override bool CanRead => true;
-        public override bool CanWrite => false;
-        public override bool CanSeek => true;
-        public override long Length { get; }
-
-        public override long Position
-        {
-            get => _position;
-            set
-            {
-                if ((value < 0) || (value > Length)) throw new ArgumentOutOfRangeException(nameof(value));
-
-                if (value == Length)
-                {
-                    // End of the stream
-
-                    _position = Length;
-                    _isEnded = true;
-                    _extentIndex = -1;
-                    _extentStream = null;
-                }
-                else if (value != _position)
-                {
-                    _position = value;
-
-                    // We first have to determine in which extent we are now, then we seek to the exact position in that extent.
-
-                    long offsetInExtent = _position;
-                    for (int i = 0; i < _extents.Count; i++)
-                    {
-                        var extent = _extents[i];
-                        long extentSize = extent.BlockCount * _volumeHeader.BlockSize;
-                        if (extentSize < offsetInExtent)
-                        {
-                            if (i == _extentIndex)
-                            {
-                                // We are in the same extent so just seek to the correct position
-                                _extentStream!.Position = offsetInExtent;
-                            }
-                            else
-                            {
-                                _extentIndex = i;
-                                _extentStream = GetExtentStream();
-                                _extentStream.Position = offsetInExtent;
-                            }
-
-                            break;
-                        }
-                        else
-                        {
-                            offsetInExtent -= extentSize;
-                        }
-                    }
-                }
-            }
-        }
-
-        public HFSForkStream(Stream baseStream, HFSVolumeHeader volumeHeader, HFSForkData forkData)
-        {
-            _baseStream = baseStream;
-            _volumeHeader = volumeHeader;
-            _extents = forkData.Extents;
-            Length = (long)forkData.LogicalSize;
-
-            _position = 0;
-            _extentIndex = -1;
-            _extentIndex = GetNextExtent();
-            _isEnded = _extentIndex < 0;
-            if (!_isEnded) _extentStream = GetExtentStream();
-        }
-
-        public HFSForkStream(
-            Stream baseStream, HFSVolumeHeader volumeHeader, HFSForkData forkData, uint fileId,
-            IReadOnlyDictionary<HFSExtentKey, HFSExtentRecord> extents)
-        {
-            _baseStream = baseStream;
-            _volumeHeader = volumeHeader;
-            Length = (long)forkData.LogicalSize;
-
-            uint blocks = (uint)forkData.Extents.Sum(e => e.BlockCount);
-            var totalExtents = new List<HFSExtentDescriptor>(forkData.Extents);
-            _extents = totalExtents;
-
-            var nextKey = new HFSExtentKey(0, fileId, blocks);
-            while (extents.TryGetValue(nextKey, out var record))
-            {
-                blocks += (uint)record.Extents.Sum(e => e.BlockCount);
-                totalExtents.AddRange(record.Extents);
-
-                nextKey = new HFSExtentKey(0, fileId, blocks);
-            }
-
-            _position = 0;
-            _extentIndex = -1;
-            _extentIndex = GetNextExtent();
-            _isEnded = _extentIndex < 0;
-            if (!_isEnded) _extentStream = GetExtentStream();
-        }
-
-        private int GetNextExtent()
-        {
-            int index = _extentIndex + 1;
-            if (index >= _extents.Count) return -1;
-
-            var extent = _extents[index];
-            if ((extent.StartBlock == 0) && (extent.BlockCount == 0)) return -1;
-            return index;
-        }
-
-        private Stream GetExtentStream()
-        {
-            if (_extentIndex < 0)
-                throw new InvalidOperationException("Invalid extent index");
-
-            var extent = _extents[_extentIndex];
-            return new HFSExtentStream(_baseStream, _volumeHeader, extent);
-        }
-
-        public override void Flush()
-        { }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            if (_isEnded) return 0;
-
-            count = (int)Math.Min(count, Length - Position);
-            int readCount = _extentStream!.Read(buffer, offset, count);
-            while (readCount < count)
-            {
-                _extentIndex = GetNextExtent();
-                if (_extentIndex < 0)
-                {
-                    _isEnded = true;
-                    return readCount;
-                }
-
-                _extentStream = GetExtentStream();
-                readCount += _extentStream.Read(buffer, offset + readCount, count - readCount);
-            }
-
-            _position += readCount;
-            return readCount;
-        }
-
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            switch (origin)
-            {
-                case SeekOrigin.Begin:
-                    Position = offset;
-                    break;
-
-                case SeekOrigin.Current:
-                    Position += offset;
-                    break;
-
-                case SeekOrigin.End:
-                    Position = Length - offset;
-                    break;
-            }
-
-            return Position;
-        }
-
-        public override void SetLength(long value)
-            => throw new NotSupportedException();
-
-        public override void Write(byte[] buffer, int offset, int count)
-            => throw new NotSupportedException();
-
-        private sealed class HFSExtentStream : SeekableSubStream
-        {
-            public HFSExtentStream(Stream stream, HFSVolumeHeader volumeHeader, HFSExtentDescriptor extent)
-                : base(stream, (long)extent.StartBlock * volumeHeader.BlockSize, (long)extent.BlockCount * volumeHeader.BlockSize)
-            { }
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSKeyedRecord.cs

@@ -1,91 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal abstract class HFSKeyedRecord : HFSStructBase
-    {
-        private readonly HFSKeyCompareType _compareType;
-        private readonly bool _isHFSX;
-        private HFSCatalogKey? _catalogKey;
-        private HFSExtentKey? _extentKey;
-
-        public byte[] Key { get; }
-
-        public HFSCatalogKey GetCatalogKey() => _catalogKey ??= new HFSCatalogKey(Key, _compareType, _isHFSX);
-
-        public HFSExtentKey GetExtentKey() => _extentKey ??= new HFSExtentKey(Key);
-
-        protected HFSKeyedRecord(byte[] key, HFSKeyCompareType compareType, bool isHFSX)
-        {
-            Key = key;
-            _compareType = compareType;
-            _isHFSX = isHFSX;
-        }
-    }
-
-    internal sealed class HFSPointerRecord : HFSKeyedRecord
-    {
-        public uint NodeNumber { get; }
-
-        private HFSPointerRecord(byte[] key, uint nodeNumber, HFSKeyCompareType compareType, bool isHFSX)
-            : base(key, compareType, isHFSX)
-        {
-            NodeNumber = nodeNumber;
-        }
-
-        public static HFSPointerRecord Read(ref ReadOnlySpan<byte> data, HFSTreeHeaderRecord headerRecord, bool isHFSX)
-        {
-            bool isBigKey = headerRecord.Attributes.HasFlag(HFSTreeAttributes.BigKeys);
-            ushort keyLength = isBigKey ? ReadUInt16(ref data) : ReadUInt8(ref data);
-            if (!headerRecord.Attributes.HasFlag(HFSTreeAttributes.VariableIndexKeys)) keyLength = headerRecord.MaxKeyLength;
-            int keySize = (isBigKey ? 2 : 1) + keyLength;
-
-            var key = new byte[keyLength];
-            data.Slice(0, keyLength).CopyTo(key);
-            data = data.Slice(keyLength);
-
-            // data is always aligned to 2 bytes
-            if (keySize % 2 == 1) data = data.Slice(1);
-
-            uint nodeNumber = ReadUInt32(ref data);
-
-            return new HFSPointerRecord(key, nodeNumber, headerRecord.KeyCompareType, isHFSX);
-        }
-    }
-
-    internal sealed class HFSDataRecord : HFSKeyedRecord
-    {
-        public byte[] Data { get; }
-
-        private HFSDataRecord(byte[] key, byte[] data, HFSKeyCompareType compareType, bool isHFSX)
-            : base(key, compareType, isHFSX)
-        {
-            Data = data;
-        }
-
-        public static HFSDataRecord Read(ref ReadOnlySpan<byte> data, int size, HFSTreeHeaderRecord headerRecord, bool isHFSX)
-        {
-            bool isBigKey = headerRecord.Attributes.HasFlag(HFSTreeAttributes.BigKeys);
-            ushort keyLength = isBigKey ? ReadUInt16(ref data) : ReadUInt8(ref data);
-            int keySize = (isBigKey ? 2 : 1) + keyLength;
-            size -= keySize;
-
-            var key = new byte[keyLength];
-            data.Slice(0, keyLength).CopyTo(key);
-            data = data.Slice(keyLength);
-
-            // data is always aligned to 2 bytes
-            if (keySize % 2 == 1)
-            {
-                data = data.Slice(1);
-                size--;
-            }
-
-            var structData = new byte[size];
-            data.Slice(0, size).CopyTo(structData);
-            data = data.Slice(size);
-
-            return new HFSDataRecord(key, structData, headerRecord.KeyCompareType, isHFSX);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSPermissions.cs

@@ -1,35 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSPermissions : HFSStructBase
-    {
-        public uint OwnerID { get; }
-        public uint GroupID { get; }
-        public byte AdminFlags { get; }
-        public byte OwnerFlags { get; }
-        public ushort FileMode { get; }
-        public uint Special { get; }
-
-        private HFSPermissions(uint ownerID, uint groupID, byte adminFlags, byte ownerFlags, ushort fileMode, uint special)
-        {
-            OwnerID = ownerID;
-            GroupID = groupID;
-            AdminFlags = adminFlags;
-            OwnerFlags = ownerFlags;
-            FileMode = fileMode;
-            Special = special;
-        }
-
-        public static HFSPermissions Read(ref ReadOnlySpan<byte> data)
-        {
-            return new HFSPermissions(
-                ReadUInt32(ref data),
-                ReadUInt32(ref data),
-                ReadUInt8(ref data),
-                ReadUInt8(ref data),
-                ReadUInt16(ref data),
-                ReadUInt32(ref data));
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSStructBase.cs

@@ -1,187 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.IO;
-using System.Text;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal abstract class HFSStructBase
-    {
-        private const int StringSize = 510;
-        private const int OSTypeSize = 4;
-        private static readonly DateTime Epoch = new DateTime(1904, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        private static readonly byte[] _buffer = new byte[StringSize];
-
-        protected static byte ReadUInt8(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(byte)) != sizeof(byte))
-                throw new EndOfStreamException();
-
-            return _buffer[0];
-        }
-
-        protected static ushort ReadUInt16(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(ushort)) != sizeof(ushort))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadUInt16BigEndian(_buffer);
-        }
-
-        protected static short ReadInt16(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(short)) != sizeof(short))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadInt16BigEndian(_buffer);
-        }
-
-        protected static uint ReadUInt32(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(uint)) != sizeof(uint))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadUInt32BigEndian(_buffer);
-        }
-
-        protected static int ReadInt32(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(int)) != sizeof(int))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadInt32BigEndian(_buffer);
-        }
-
-        protected static ulong ReadUInt64(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(ulong)) != sizeof(ulong))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadUInt64BigEndian(_buffer);
-        }
-
-        protected static long ReadInt64(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(long)) != sizeof(long))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadInt64BigEndian(_buffer);
-        }
-
-        protected static string ReadString(Stream stream)
-        {
-            ushort length = ReadUInt16(stream);
-            if (stream.Read(_buffer, 0, StringSize) != StringSize)
-                throw new EndOfStreamException();
-            return Encoding.Unicode.GetString(_buffer, 0, Math.Min(length * 2, StringSize));
-        }
-
-        protected static DateTime ReadDate(Stream stream)
-        {
-            uint seconds = ReadUInt32(stream);
-            var span = TimeSpan.FromSeconds(seconds);
-            return Epoch + span;
-        }
-
-        protected static byte ReadUInt8(ref ReadOnlySpan<byte> data)
-        {
-            byte val = data[0];
-            data = data.Slice(sizeof(byte));
-            return val;
-        }
-
-        protected static ushort ReadUInt16(ref ReadOnlySpan<byte> data)
-        {
-            ushort val = BinaryPrimitives.ReadUInt16BigEndian(data);
-            data = data.Slice(sizeof(ushort));
-            return val;
-        }
-
-        protected static short ReadInt16(ref ReadOnlySpan<byte> data)
-        {
-            short val = BinaryPrimitives.ReadInt16BigEndian(data);
-            data = data.Slice(sizeof(short));
-            return val;
-        }
-
-        protected static uint ReadUInt32(ref ReadOnlySpan<byte> data)
-        {
-            uint val = BinaryPrimitives.ReadUInt32BigEndian(data);
-            data = data.Slice(sizeof(uint));
-            return val;
-        }
-
-        protected static int ReadInt32(ref ReadOnlySpan<byte> data)
-        {
-            int val = BinaryPrimitives.ReadInt32BigEndian(data);
-            data = data.Slice(sizeof(int));
-            return val;
-        }
-
-        protected static ulong ReadUInt64(ref ReadOnlySpan<byte> data)
-        {
-            ulong val = BinaryPrimitives.ReadUInt64BigEndian(data);
-            data = data.Slice(sizeof(ulong));
-            return val;
-        }
-
-        protected static long ReadInt64(ref ReadOnlySpan<byte> data)
-        {
-            long val = BinaryPrimitives.ReadInt64BigEndian(data);
-            data = data.Slice(sizeof(long));
-            return val;
-        }
-
-        protected static string ReadString(ref ReadOnlySpan<byte> data, bool truncate)
-        {
-            int length = ReadUInt16(ref data);
-            if (truncate)
-            {
-                length = Math.Min(length * 2, StringSize);
-                data.Slice(0, length).CopyTo(_buffer);
-                data = data.Slice(length);
-                return Encoding.BigEndianUnicode.GetString(_buffer, 0, length);
-            }
-            else
-            {
-                data.Slice(0, StringSize).CopyTo(_buffer);
-                data = data.Slice(StringSize);
-                return Encoding.BigEndianUnicode.GetString(_buffer, 0, Math.Min(length * 2, StringSize));
-            }
-        }
-
-        protected static DateTime ReadDate(ref ReadOnlySpan<byte> data)
-        {
-            uint seconds = ReadUInt32(ref data);
-            var span = TimeSpan.FromSeconds(seconds);
-            return Epoch + span;
-        }
-
-        protected static string ReadOSType(ref ReadOnlySpan<byte> data)
-        {
-            data.Slice(0, OSTypeSize).CopyTo(_buffer);
-            data = data.Slice(OSTypeSize);
-            return Encoding.ASCII.GetString(_buffer, 0, OSTypeSize).NullTerminate();
-        }
-
-        protected static HFSPoint ReadPoint(ref ReadOnlySpan<byte> data)
-        {
-            return new HFSPoint()
-            {
-                V = ReadInt16(ref data),
-                H = ReadInt16(ref data)
-            };
-        }
-
-        protected static HFSRect ReadRect(ref ReadOnlySpan<byte> data)
-        {
-            return new HFSRect()
-            {
-                Top = ReadInt16(ref data),
-                Left = ReadInt16(ref data),
-                Bottom = ReadInt16(ref data),
-                Right = ReadInt16(ref data)
-            };
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSTreeHeaderRecord.cs

@@ -1,108 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal enum HFSTreeType : byte
-    {
-        HFS = 0,         // control file
-        User = 128,      // user btree type starts from 128
-        Reserved = 255
-    }
-
-    internal enum HFSKeyCompareType : byte
-    {
-        CaseFolding = 0xCF,	  // case-insensitive
-        BinaryCompare = 0xBC  // case-sensitive
-    }
-
-    [Flags]
-    internal enum HFSTreeAttributes : uint
-    {
-        None = 0x00000000,
-        BadClose = 0x00000001,
-        BigKeys = 0x00000002,
-        VariableIndexKeys = 0x00000004
-    }
-
-    internal sealed class HFSTreeHeaderRecord : HFSStructBase
-    {
-        public ushort TreeDepth;
-        public uint RootNode;
-        public uint LeafRecords;
-        public uint FirstLeafNode;
-        public uint LastLeafNode;
-        public ushort NodeSize;
-        public ushort MaxKeyLength;
-        public uint TotalNodes;
-        public uint FreeNodes;
-        public uint ClumpSize;
-        public HFSTreeType TreeType;
-        public HFSKeyCompareType KeyCompareType;
-        public HFSTreeAttributes Attributes;
-
-        private HFSTreeHeaderRecord(
-            ushort treeDepth,
-            uint rootNode,
-            uint leafRecords,
-            uint firstLeafNode,
-            uint lastLeafNode,
-            ushort nodeSize,
-            ushort maxKeyLength,
-            uint totalNodes,
-            uint freeNodes,
-            uint clumpSize,
-            HFSTreeType treeType,
-            HFSKeyCompareType keyCompareType,
-            HFSTreeAttributes attributes)
-        {
-            TreeDepth = treeDepth;
-            RootNode = rootNode;
-            LeafRecords = leafRecords;
-            FirstLeafNode = firstLeafNode;
-            LastLeafNode = lastLeafNode;
-            NodeSize = nodeSize;
-            MaxKeyLength = maxKeyLength;
-            TotalNodes = totalNodes;
-            FreeNodes = freeNodes;
-            ClumpSize = clumpSize;
-            TreeType = treeType;
-            KeyCompareType = keyCompareType;
-            Attributes = attributes;
-        }
-
-        public static HFSTreeHeaderRecord Read(Stream stream)
-        {
-            ushort treeDepth = ReadUInt16(stream);
-            uint rootNode = ReadUInt32(stream);
-            uint leafRecords = ReadUInt32(stream);
-            uint firstLeafNode = ReadUInt32(stream);
-            uint lastLeafNode = ReadUInt32(stream);
-            ushort nodeSize = ReadUInt16(stream);
-            ushort maxKeyLength = ReadUInt16(stream);
-            uint totalNodes = ReadUInt32(stream);
-            uint freeNodes = ReadUInt32(stream);
-            _ = ReadUInt16(stream); // reserved
-            uint clumpSize = ReadUInt32(stream);
-            var treeType = (HFSTreeType)ReadUInt8(stream);
-            var keyCompareType = (HFSKeyCompareType)ReadUInt8(stream);
-            var attributes = (HFSTreeAttributes)ReadUInt32(stream);
-            for (int i = 0; i < 16; i++) _ = ReadUInt32(stream); // reserved
-
-            return new HFSTreeHeaderRecord(
-                treeDepth,
-                rootNode,
-                leafRecords,
-                firstLeafNode,
-                lastLeafNode,
-                nodeSize,
-                maxKeyLength,
-                totalNodes,
-                freeNodes,
-                clumpSize,
-                treeType,
-                keyCompareType,
-                attributes);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSTreeNode.cs

@@ -1,167 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal abstract class HFSTreeNode : HFSStructBase
-    {
-        private static byte[]? _buffer = null;
-
-        public HFSTreeNodeDescriptor Descriptor { get; }
-
-        protected HFSTreeNode(HFSTreeNodeDescriptor descriptor)
-            => Descriptor = descriptor;
-
-        public static bool TryRead(Stream stream, HFSTreeHeaderRecord headerRecord, bool isHFSX, out HFSTreeNode? node)
-        {
-            node = null;
-
-            if (!HFSTreeNodeDescriptor.TryRead(stream, out var descriptor)) return false;
-
-            int size = (int)headerRecord.NodeSize - HFSTreeNodeDescriptor.Size;
-            if ((_buffer is null) || (_buffer.Length < size))
-                _buffer = new byte[size * 2];
-
-            if (stream.Read(_buffer, 0, size) != size)
-                throw new EndOfStreamException();
-            ReadOnlySpan<byte> data = _buffer.AsSpan(0, size);
-
-            switch (descriptor!.Kind)
-            {
-                case HFSTreeNodeKind.Leaf:
-                    node = HFSLeafTreeNode.Read(descriptor, data, headerRecord, isHFSX);
-                    return true;
-
-                case HFSTreeNodeKind.Index:
-                    node = HFSIndexTreeNode.Read(descriptor, data, headerRecord, isHFSX);
-                    return true;
-
-                case HFSTreeNodeKind.Map:
-                    node = HFSMapTreeNode.Read(descriptor, data);
-                    return true;
-            }
-
-            return false;
-        }
-    }
-
-    internal sealed class HFSHeaderTreeNode : HFSTreeNode
-    {
-        private const int UserDataSize = 128;
-
-        public HFSTreeHeaderRecord HeaderRecord { get; }
-
-        public IReadOnlyList<byte> UserData { get; }
-
-        public IReadOnlyList<byte> Map { get; }
-
-        private HFSHeaderTreeNode(
-            HFSTreeNodeDescriptor descriptor,
-            HFSTreeHeaderRecord headerRecord,
-            IReadOnlyList<byte> userData,
-            IReadOnlyList<byte> map)
-            : base(descriptor)
-        {
-            HeaderRecord = headerRecord;
-            UserData = userData;
-            Map = map;
-        }
-
-        public static HFSHeaderTreeNode Read(HFSTreeNodeDescriptor descriptor, Stream stream)
-        {
-            if (descriptor.Kind != HFSTreeNodeKind.Header)
-                throw new ArgumentException("Descriptor does not define a header node");
-
-            var headerRecord = HFSTreeHeaderRecord.Read(stream);
-            var userData = new byte[UserDataSize];
-            if (stream.Read(userData, 0, UserDataSize) != UserDataSize)
-                throw new EndOfStreamException();
-
-            int mapSize = (int)(headerRecord.NodeSize - 256);
-            var map = new byte[mapSize];
-            if (stream.Read(map, 0, mapSize) != mapSize)
-                throw new EndOfStreamException();
-
-            // offset values (not required for header node)
-            _ = ReadUInt16(stream);
-            _ = ReadUInt16(stream);
-            _ = ReadUInt16(stream);
-            _ = ReadUInt16(stream);
-
-            return new HFSHeaderTreeNode(descriptor, headerRecord, userData, map);
-        }
-    }
-
-    internal sealed class HFSMapTreeNode : HFSTreeNode
-    {
-        public IReadOnlyList<byte> Map { get; }
-
-        private HFSMapTreeNode(HFSTreeNodeDescriptor descriptor, IReadOnlyList<byte> map)
-            : base(descriptor)
-        {
-            Map = map;
-        }
-
-        public static HFSMapTreeNode Read(HFSTreeNodeDescriptor descriptor, ReadOnlySpan<byte> data)
-        {
-            int mapSize = data.Length - 6;
-            var map = new byte[mapSize];
-            data.Slice(0, mapSize).CopyTo(map);
-
-            return new HFSMapTreeNode(descriptor, map);
-        }
-    }
-
-    internal sealed class HFSIndexTreeNode : HFSTreeNode
-    {
-        public IReadOnlyList<HFSPointerRecord> Records { get; }
-
-        private HFSIndexTreeNode(HFSTreeNodeDescriptor descriptor, IReadOnlyList<HFSPointerRecord> records)
-            : base(descriptor)
-        {
-            Records = records;
-        }
-
-        public static HFSIndexTreeNode Read(HFSTreeNodeDescriptor descriptor, ReadOnlySpan<byte> data, HFSTreeHeaderRecord headerRecord, bool isHFSX)
-        {
-            int recordCount = descriptor.NumRecords;
-            var records = new HFSPointerRecord[recordCount];
-            for (int i = 0; i < recordCount; i++)
-                records[i] = HFSPointerRecord.Read(ref data, headerRecord, isHFSX);
-            return new HFSIndexTreeNode(descriptor, records);
-        }
-    }
-
-    internal sealed class HFSLeafTreeNode : HFSTreeNode
-    {
-        public IReadOnlyList<HFSDataRecord> Records { get; }
-
-        private HFSLeafTreeNode(HFSTreeNodeDescriptor descriptor, IReadOnlyList<HFSDataRecord> records)
-            : base(descriptor)
-        {
-            Records = records;
-        }
-
-        public static HFSLeafTreeNode Read(HFSTreeNodeDescriptor descriptor, ReadOnlySpan<byte> data, HFSTreeHeaderRecord headerRecord, bool isHFSX)
-        {
-            int recordCount = descriptor.NumRecords;
-            var recordOffsets = new int[recordCount + 1];
-            for (int i = 0; i < recordOffsets.Length; i++)
-            {
-                var offsetData = data.Slice(data.Length - (2 * i) - 2);
-                ushort offset = ReadUInt16(ref offsetData);
-                recordOffsets[i] = offset;
-            }
-
-            var records = new HFSDataRecord[recordCount];
-            for (int i = 0; i < recordCount; i++)
-            {
-                int size = recordOffsets[i + 1] - recordOffsets[i];
-                records[i] = HFSDataRecord.Read(ref data, size, headerRecord, isHFSX);
-            }
-
-            return new HFSLeafTreeNode(descriptor, records);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSTreeNodeDescriptor.cs

@@ -1,55 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal enum HFSTreeNodeKind : sbyte
-    {
-        Leaf = -1,
-        Index = 0,
-        Header = 1,
-        Map = 2
-    }
-
-    internal sealed class HFSTreeNodeDescriptor : HFSStructBase
-    {
-        public const int Size = 14;
-
-        public uint FLink { get; }
-        public uint BLink { get; }
-        public HFSTreeNodeKind Kind { get; }
-        public byte Height { get; }
-        public ushort NumRecords { get; }
-
-        private HFSTreeNodeDescriptor(uint fLink, uint bLink, HFSTreeNodeKind kind, byte height, ushort numRecords)
-        {
-            FLink = fLink;
-            BLink = bLink;
-            Kind = kind;
-            Height = height;
-            NumRecords = numRecords;
-        }
-
-        public static bool TryRead(Stream stream, out HFSTreeNodeDescriptor? descriptor)
-        {
-            descriptor = null;
-
-            uint fLink = ReadUInt32(stream);
-            uint bLink = ReadUInt32(stream);
-
-            sbyte rawKind = (sbyte)ReadUInt8(stream);
-            if (!Enum.IsDefined(typeof(HFSTreeNodeKind), rawKind)) return false;
-            var kind = (HFSTreeNodeKind)rawKind;
-
-            byte height = ReadUInt8(stream);
-            if (((kind == HFSTreeNodeKind.Header) || (kind == HFSTreeNodeKind.Map)) && (height != 0)) return false;
-            if ((kind == HFSTreeNodeKind.Leaf) && (height != 1)) return false;
-
-            ushort numRecords = ReadUInt16(stream);
-            _ = ReadUInt16(stream); // reserved
-
-            descriptor = new HFSTreeNodeDescriptor(fLink, bLink, kind, height, numRecords);
-            return true;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSUtil.cs

@@ -1,206 +0,0 @@
-using SharpCompress.Archives.Dmg;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal static class HFSUtil
-    {
-        private const string CorruptHFSMessage = "Corrupt HFS volume";
-
-        private static (HFSHeaderTreeNode, IReadOnlyList<HFSTreeNode>) ReadTree(Stream stream, bool isHFSX)
-        {
-            if (!HFSTreeNodeDescriptor.TryRead(stream, out var headerDesc))
-                throw new InvalidFormatException(CorruptHFSMessage);
-            var header = HFSHeaderTreeNode.Read(headerDesc!, stream);
-
-            var nodes = new HFSTreeNode[header.HeaderRecord.TotalNodes];
-            nodes[0] = header;
-
-            for (int i = 1; i < nodes.Length; i++)
-            {
-                if (!HFSTreeNode.TryRead(stream, header.HeaderRecord, isHFSX, out var node))
-                    throw new InvalidFormatException(CorruptHFSMessage);
-
-                nodes[i] = node!;
-            }
-
-            return (header, nodes);
-        }
-
-        private static void EnumerateExtentsTree(
-            IReadOnlyList<HFSTreeNode> extentsTree,
-            IDictionary<HFSExtentKey, HFSExtentRecord> records,
-            int parentIndex)
-        {
-            var parent = extentsTree[parentIndex];
-            if (parent is HFSLeafTreeNode leafNode)
-            {
-                foreach (var record in leafNode.Records)
-                {
-                    ReadOnlySpan<byte> data = record.Data.AsSpan();
-                    var recordData = HFSExtentRecord.Read(ref data);
-                    var key = record.GetExtentKey();
-                    records.Add(key, recordData);
-                }
-            }
-            else if (parent is HFSIndexTreeNode indexNode)
-            {
-                foreach (var record in indexNode.Records)
-                    EnumerateExtentsTree(extentsTree, records, (int)record.NodeNumber);
-            }
-            else
-            {
-                throw new InvalidFormatException(CorruptHFSMessage);
-            }
-        }
-
-        private static IReadOnlyDictionary<HFSExtentKey, HFSExtentRecord> LoadExtents(IReadOnlyList<HFSTreeNode> extentsTree, int rootIndex)
-        {
-            var records = new Dictionary<HFSExtentKey, HFSExtentRecord>();
-            if (rootIndex == 0) return records;
-
-            EnumerateExtentsTree(extentsTree, records, rootIndex);
-            return records;
-        }
-
-        private static void EnumerateCatalogTree(
-            HFSHeaderTreeNode catalogHeader,
-            IReadOnlyList<HFSTreeNode> catalogTree,
-            IDictionary<HFSCatalogKey, HFSCatalogRecord> records,
-            IDictionary<uint, HFSCatalogThread> threads,
-            int parentIndex,
-            bool isHFSX)
-        {
-            var parent = catalogTree[parentIndex];
-            if (parent is HFSLeafTreeNode leafNode)
-            {
-                foreach (var record in leafNode.Records)
-                {
-                    ReadOnlySpan<byte> data = record.Data.AsSpan();
-                    if (HFSCatalogRecord.TryRead(ref data, catalogHeader.HeaderRecord.KeyCompareType, isHFSX, out var recordData))
-                    {
-                        var key = record.GetCatalogKey();
-                        if ((recordData!.Type == HFSCatalogRecordType.FileThread) || (recordData!.Type == HFSCatalogRecordType.FolderThread))
-                        {
-                            threads.Add(key.ParentId, (HFSCatalogThread)recordData);
-                        }
-                        else
-                        {
-                            records.Add(key, recordData);
-                        }
-                    }
-                    else
-                    {
-                        throw new InvalidFormatException(CorruptHFSMessage);
-                    }
-                }
-            }
-            else if (parent is HFSIndexTreeNode indexNode)
-            {
-                foreach (var record in indexNode.Records)
-                    EnumerateCatalogTree(catalogHeader, catalogTree, records, threads, (int)record.NodeNumber, isHFSX);
-            }
-            else
-            {
-                throw new InvalidFormatException(CorruptHFSMessage);
-            }
-        }
-
-        private static (HFSCatalogKey, HFSCatalogRecord) GetRecord(uint id, IDictionary<HFSCatalogKey, HFSCatalogRecord> records, IDictionary<uint, HFSCatalogThread> threads)
-        {
-            if (threads.TryGetValue(id, out var thread))
-            {
-                if (records.TryGetValue(thread.CatalogKey, out var record))
-                    return (thread.CatalogKey, record!);
-            }
-
-            throw new InvalidFormatException(CorruptHFSMessage);
-        }
-
-        private static string SanitizePath(string path)
-        {
-            var sb = new StringBuilder(path.Length);
-            foreach (char c in path)
-            {
-                if (!char.IsControl(c))
-                    sb.Append(c);
-            }
-            return sb.ToString();
-        }
-
-        private static string GetPath(HFSCatalogKey key, IDictionary<HFSCatalogKey, HFSCatalogRecord> records, IDictionary<uint, HFSCatalogThread> threads)
-        {
-            if (key.ParentId == 1)
-            {
-                return key.Name;
-            }
-            else
-            {
-                var (parentKey, _) = GetRecord(key.ParentId, records, threads);
-                var path = Path.Combine(GetPath(parentKey, records, threads), key.Name);
-                return SanitizePath(path);
-            }
-        }
-
-        private static IEnumerable<DmgArchiveEntry> LoadEntriesFromCatalogTree(
-            Stream partitionStream,
-            DmgFilePart filePart,
-            HFSVolumeHeader volumeHeader,
-            HFSHeaderTreeNode catalogHeader,
-            IReadOnlyList<HFSTreeNode> catalogTree,
-            IReadOnlyDictionary<HFSExtentKey, HFSExtentRecord> extents,
-            DmgArchive archive,
-            int rootIndex)
-        {
-            if (rootIndex == 0) return Array.Empty<DmgArchiveEntry>();
-
-            var records = new Dictionary<HFSCatalogKey, HFSCatalogRecord>();
-            var threads = new Dictionary<uint, HFSCatalogThread>();
-            EnumerateCatalogTree(catalogHeader, catalogTree, records, threads, rootIndex, volumeHeader.IsHFSX);
-
-            var entries = new List<DmgArchiveEntry>();
-            foreach (var kvp in records)
-            {
-                var key = kvp.Key;
-                var record = kvp.Value;
-
-                string path = GetPath(key, records, threads);
-                var stream = (record is HFSCatalogFile file) ? new HFSForkStream(partitionStream, volumeHeader, file.DataFork, file.FileId, extents) : null;
-                var entry = new DmgArchiveEntry(stream, archive, record, path, filePart);
-                entries.Add(entry);
-            }
-
-            return entries;
-        }
-
-        public static IEnumerable<DmgArchiveEntry> LoadEntriesFromPartition(Stream partitionStream, string fileName, DmgArchive archive)
-        {
-            if (!HFSVolumeHeader.TryRead(partitionStream, out var volumeHeader))
-                throw new InvalidFormatException(CorruptHFSMessage);
-            var filePart = new DmgFilePart(partitionStream, fileName);
-
-            var extentsFile = volumeHeader!.ExtentsFile;
-            var extentsStream = new HFSForkStream(partitionStream, volumeHeader, extentsFile);
-            var (extentsHeader, extentsTree) = ReadTree(extentsStream, volumeHeader.IsHFSX);
-
-            var extents = LoadExtents(extentsTree, (int)extentsHeader.HeaderRecord.RootNode);
-
-            var catalogFile = volumeHeader!.CatalogFile;
-            var catalogStream = new HFSForkStream(partitionStream, volumeHeader, catalogFile);
-            var (catalogHeader, catalogTree) = ReadTree(catalogStream, volumeHeader.IsHFSX);
-
-            return LoadEntriesFromCatalogTree(
-                partitionStream,
-                filePart,
-                volumeHeader,
-                catalogHeader,
-                catalogTree,
-                extents,
-                archive,
-                (int)catalogHeader.HeaderRecord.RootNode);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/HFS/HFSVolumeHeader.cs

@@ -1,179 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.HFS
-{
-    internal sealed class HFSVolumeHeader : HFSStructBase
-    {
-        private const ushort SignaturePlus = 0x482B;
-        private const ushort SignatureX = 0x4858;
-        private const int FinderInfoCount = 8;
-
-        public bool IsHFSX { get; }
-        public ushort Version { get; }
-        public uint Attributes { get; }
-        public uint LastMountedVersion { get; }
-        public uint JournalInfoBlock { get; }
-
-        public DateTime CreateDate { get; }
-        public DateTime ModifyDate { get; }
-        public DateTime BackupDate { get; }
-        public DateTime CheckedDate { get; }
-
-        public uint FileCount { get; }
-        public uint FolderCount { get; }
-
-        public uint BlockSize { get; }
-        public uint TotalBlocks { get; }
-        public uint FreeBlocks { get; }
-
-        public uint NextAllocation { get; }
-        public uint RsrcClumpSize { get; }
-        public uint DataClumpSize { get; }
-        public uint NextCatalogID { get; }
-
-        public uint WriteCount { get; }
-        public ulong EncodingsBitmap { get; }
-
-        public IReadOnlyList<uint> FinderInfo { get; }
-
-        public HFSForkData AllocationFile { get; }
-        public HFSForkData ExtentsFile { get; }
-        public HFSForkData CatalogFile { get; }
-        public HFSForkData AttributesFile { get; }
-        public HFSForkData StartupFile { get; }
-
-        public HFSVolumeHeader(
-            bool isHFSX,
-            ushort version,
-            uint attributes,
-            uint lastMountedVersion,
-            uint journalInfoBlock,
-            DateTime createDate,
-            DateTime modifyDate,
-            DateTime backupDate,
-            DateTime checkedDate,
-            uint fileCount,
-            uint folderCount,
-            uint blockSize,
-            uint totalBlocks,
-            uint freeBlocks,
-            uint nextAllocation,
-            uint rsrcClumpSize,
-            uint dataClumpSize,
-            uint nextCatalogID,
-            uint writeCount,
-            ulong encodingsBitmap,
-            IReadOnlyList<uint> finderInfo,
-            HFSForkData allocationFile,
-            HFSForkData extentsFile,
-            HFSForkData catalogFile,
-            HFSForkData attributesFile,
-            HFSForkData startupFile)
-        {
-            IsHFSX = isHFSX;
-            Version = version;
-            Attributes = attributes;
-            LastMountedVersion = lastMountedVersion;
-            JournalInfoBlock = journalInfoBlock;
-            CreateDate = createDate;
-            ModifyDate = modifyDate;
-            BackupDate = backupDate;
-            CheckedDate = checkedDate;
-            FileCount = fileCount;
-            FolderCount = folderCount;
-            BlockSize = blockSize;
-            TotalBlocks = totalBlocks;
-            FreeBlocks = freeBlocks;
-            NextAllocation = nextAllocation;
-            RsrcClumpSize = rsrcClumpSize;
-            DataClumpSize = dataClumpSize;
-            NextCatalogID = nextCatalogID;
-            WriteCount = writeCount;
-            EncodingsBitmap = encodingsBitmap;
-            FinderInfo = finderInfo;
-            AllocationFile = allocationFile;
-            ExtentsFile = extentsFile;
-            CatalogFile = catalogFile;
-            AttributesFile = attributesFile;
-            StartupFile = startupFile;
-        }
-
-        private static IReadOnlyList<uint> ReadFinderInfo(Stream stream)
-        {
-            var finderInfo = new uint[FinderInfoCount];
-            for (int i = 0; i < FinderInfoCount; i++)
-                finderInfo[i] = ReadUInt32(stream);
-            return finderInfo;
-        }
-
-        public static bool TryRead(Stream stream, out HFSVolumeHeader? header)
-        {
-            header = null;
-            stream.Skip(1024); // reserved bytes
-
-            bool isHFSX;
-            ushort sig = ReadUInt16(stream);
-            if (sig == SignaturePlus) isHFSX = false;
-            else if (sig == SignatureX) isHFSX = true;
-            else return false;
-
-            ushort version = ReadUInt16(stream);
-            uint attributes = ReadUInt32(stream);
-            uint lastMountedVersion = ReadUInt32(stream);
-            uint journalInfoBlock = ReadUInt32(stream);
-            DateTime createDate = ReadDate(stream);
-            DateTime modifyDate = ReadDate(stream);
-            DateTime backupDate = ReadDate(stream);
-            DateTime checkedDate = ReadDate(stream);
-            uint fileCount = ReadUInt32(stream);
-            uint folderCount = ReadUInt32(stream);
-            uint blockSize = ReadUInt32(stream);
-            uint totalBlocks = ReadUInt32(stream);
-            uint freeBlocks = ReadUInt32(stream);
-            uint nextAllocation = ReadUInt32(stream);
-            uint rsrcClumpSize = ReadUInt32(stream);
-            uint dataClumpSize = ReadUInt32(stream);
-            uint nextCatalogID = ReadUInt32(stream);
-            uint writeCount = ReadUInt32(stream);
-            ulong encodingsBitmap = ReadUInt64(stream);
-            IReadOnlyList<uint> finderInfo = ReadFinderInfo(stream);
-            HFSForkData allocationFile = HFSForkData.Read(stream);
-            HFSForkData extentsFile = HFSForkData.Read(stream);
-            HFSForkData catalogFile = HFSForkData.Read(stream);
-            HFSForkData attributesFile = HFSForkData.Read(stream);
-            HFSForkData startupFile = HFSForkData.Read(stream);
-
-            header = new HFSVolumeHeader(
-                isHFSX,
-                version,
-                attributes,
-                lastMountedVersion,
-                journalInfoBlock,
-                createDate,
-                modifyDate,
-                backupDate,
-                checkedDate,
-                fileCount,
-                folderCount,
-                blockSize,
-                totalBlocks,
-                freeBlocks,
-                nextAllocation,
-                rsrcClumpSize,
-                dataClumpSize,
-                nextCatalogID,
-                writeCount,
-                encodingsBitmap,
-                finderInfo,
-                allocationFile,
-                extentsFile,
-                catalogFile,
-                attributesFile,
-                startupFile);
-
-            return true;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/BlkxChunk.cs

@@ -1,49 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal enum BlkxChunkType : uint
-    {
-        Zero = 0x00000000u,
-        Uncompressed = 0x00000001u,
-        Ignore = 0x00000002u,
-        AdcCompressed = 0x80000004u,
-        ZlibCompressed = 0x80000005u,
-        Bz2Compressed = 0x80000006u,
-        Comment = 0x7FFFFFFEu,
-        Last = 0xFFFFFFFFu,
-    }
-
-    internal sealed class BlkxChunk : DmgStructBase
-    {
-        private const int SectorSize = 512;
-
-        public BlkxChunkType Type { get; }      // Compression type used or chunk type
-        public uint Comment { get; }            // "+beg" or "+end", if EntryType is comment (0x7FFFFFFE). Else reserved.
-        public ulong UncompressedOffset { get; }      // Start sector of this chunk
-        public ulong UncompressedLength { get; }       // Number of sectors in this chunk
-        public ulong CompressedOffset { get; }  // Start of chunk in data fork
-        public ulong CompressedLength { get; }  // Count of bytes of chunk, in data fork
-
-        private BlkxChunk(BlkxChunkType type, uint comment, ulong sectorNumber, ulong sectorCount, ulong compressedOffset, ulong compressedLength)
-        {
-            Type = type;
-            Comment = comment;
-            UncompressedOffset = sectorNumber * SectorSize;
-            UncompressedLength = sectorCount * SectorSize;
-            CompressedOffset = compressedOffset;
-            CompressedLength = compressedLength;
-        }
-
-        public static bool TryRead(ref ReadOnlySpan<byte> data, out BlkxChunk? chunk)
-        {
-            chunk = null;
-
-            var type = (BlkxChunkType)ReadUInt32(ref data);
-            if (!Enum.IsDefined(typeof(BlkxChunkType), type)) return false;
-
-            chunk = new BlkxChunk(type, ReadUInt32(ref data), ReadUInt64(ref data), ReadUInt64(ref data), ReadUInt64(ref data), ReadUInt64(ref data));
-            return true;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/BlkxTable.cs

@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal sealed class BlkxTable : DmgStructBase
-    {
-        private const uint Signature = 0x6d697368u;
-
-        public uint Version { get; }             // Current version is 1
-        public ulong SectorNumber { get; }       // Starting disk sector in this blkx descriptor
-        public ulong SectorCount { get; }        // Number of disk sectors in this blkx descriptor
-
-        public ulong DataOffset { get; }
-        public uint BuffersNeeded { get; }
-        public uint BlockDescriptors { get; }    // Number of descriptors
-
-        public UdifChecksum Checksum { get; }
-
-        public IReadOnlyList<BlkxChunk> Chunks { get; }
-
-        private BlkxTable(
-            uint version,
-            ulong sectorNumber,
-            ulong sectorCount,
-            ulong dataOffset,
-            uint buffersNeeded,
-            uint blockDescriptors,
-            UdifChecksum checksum,
-            IReadOnlyList<BlkxChunk> chunks)
-        {
-            Version = version;
-            SectorNumber = sectorNumber;
-            SectorCount = sectorCount;
-            DataOffset = dataOffset;
-            BuffersNeeded = buffersNeeded;
-            BlockDescriptors = blockDescriptors;
-            Checksum = checksum;
-            Chunks = chunks;
-        }
-
-        public static bool TryRead(in byte[] buffer, out BlkxTable? header)
-        {
-            header = null;
-
-            ReadOnlySpan<byte> data = buffer.AsSpan();
-
-            uint sig = ReadUInt32(ref data);
-            if (sig != Signature) return false;
-
-            uint version = ReadUInt32(ref data);
-            ulong sectorNumber = ReadUInt64(ref data);
-            ulong sectorCount = ReadUInt64(ref data);
-
-            ulong dataOffset = ReadUInt64(ref data);
-            uint buffersNeeded = ReadUInt32(ref data);
-            uint blockDescriptors = ReadUInt32(ref data);
-
-            data = data.Slice(6 * sizeof(uint)); // reserved
-
-            var checksum = UdifChecksum.Read(ref data);
-
-            uint chunkCount = ReadUInt32(ref data);
-            var chunks = new BlkxChunk[chunkCount];
-            for (int i = 0; i < chunkCount; i++)
-            {
-                if (!BlkxChunk.TryRead(ref data, out var chunk)) return false;
-                chunks[i] = chunk!;
-            }
-
-            header = new BlkxTable(version, sectorNumber, sectorCount, dataOffset, buffersNeeded, blockDescriptors, checksum, chunks);
-            return true;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/DmgHeader.cs

@@ -1,138 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal sealed class DmgHeader : DmgStructBase
-    {
-        public const int HeaderSize = 512;
-        private const uint Signature = 0x6B6F6C79u;
-        private const int UuidSize = 16; // 128 bit
-
-        public uint Version { get; }                     // Current version is 4
-        public uint Flags { get; }                       // Flags
-        public ulong RunningDataForkOffset { get; }      //
-        public ulong DataForkOffset { get; }             // Data fork offset (usually 0, beginning of file)
-        public ulong DataForkLength { get; }             // Size of data fork (usually up to the XMLOffset, below)
-        public ulong RsrcForkOffset { get; }             // Resource fork offset, if any
-        public ulong RsrcForkLength { get; }             // Resource fork length, if any
-        public uint SegmentNumber { get; }               // Usually 1, may be 0
-        public uint SegmentCount { get; }                // Usually 1, may be 0
-        public IReadOnlyList<byte> SegmentID { get; }    // 128-bit GUID identifier of segment (if SegmentNumber !=0)
-
-        public UdifChecksum DataChecksum { get; }
-
-        public ulong XMLOffset { get; }                  // Offset of property list in DMG, from beginning
-        public ulong XMLLength { get; }                  // Length of property list
-
-        public UdifChecksum Checksum { get; }
-        
-        public uint ImageVariant { get; }                // Commonly 1
-        public ulong SectorCount { get; }                // Size of DMG when expanded, in sectors
-
-        private DmgHeader(
-            uint version,
-            uint flags,
-            ulong runningDataForkOffset,
-            ulong dataForkOffset,
-            ulong dataForkLength,
-            ulong rsrcForkOffset,
-            ulong rsrcForkLength,
-            uint segmentNumber,
-            uint segmentCount,
-            IReadOnlyList<byte> segmentID,
-            UdifChecksum dataChecksum,
-            ulong xMLOffset,
-            ulong xMLLength,
-            UdifChecksum checksum,
-            uint imageVariant,
-            ulong sectorCount)
-        {
-            Version = version;
-            Flags = flags;
-            RunningDataForkOffset = runningDataForkOffset;
-            DataForkOffset = dataForkOffset;
-            DataForkLength = dataForkLength;
-            RsrcForkOffset = rsrcForkOffset;
-            RsrcForkLength = rsrcForkLength;
-            SegmentNumber = segmentNumber;
-            SegmentCount = segmentCount;
-            SegmentID = segmentID;
-            DataChecksum = dataChecksum;
-            XMLOffset = xMLOffset;
-            XMLLength = xMLLength;
-            Checksum = checksum;
-            ImageVariant = imageVariant;
-            SectorCount = sectorCount;
-        }
-
-        private static void ReadUuid(ref ReadOnlySpan<byte> data, byte[] buffer)
-        {
-            data.Slice(0, UuidSize).CopyTo(buffer);
-            data = data.Slice(UuidSize);
-        }
-
-        internal static bool TryRead(Stream input, out DmgHeader? header)
-        {
-            header = null;
-
-            var buffer = new byte[HeaderSize];
-            int count = input.Read(buffer, 0, HeaderSize);
-            if (count != HeaderSize) return false;
-            ReadOnlySpan<byte> data = buffer.AsSpan();
-
-            uint sig = ReadUInt32(ref data);
-            if (sig != Signature) return false;
-
-            uint version = ReadUInt32(ref data);
-
-            uint size = ReadUInt32(ref data);
-            if (size != (uint)HeaderSize) return false;
-
-            uint flags = ReadUInt32(ref data);
-            ulong runningDataForkOffset = ReadUInt64(ref data);
-            ulong dataForkOffset = ReadUInt64(ref data);
-            ulong dataForkLength = ReadUInt64(ref data);
-            ulong rsrcForkOffset = ReadUInt64(ref data);
-            ulong rsrcForkLength = ReadUInt64(ref data);
-            uint segmentNumber = ReadUInt32(ref data);
-            uint segmentCount = ReadUInt32(ref data);
-
-            var segmentID = new byte[UuidSize];
-            ReadUuid(ref data, segmentID);
-
-            var dataChecksum = UdifChecksum.Read(ref data);
-
-            ulong xmlOffset = ReadUInt64(ref data);
-            ulong xmlLength = ReadUInt64(ref data);
-
-            data = data.Slice(120); // Reserved bytes
-
-            var checksum = UdifChecksum.Read(ref data);
-
-            uint imageVariant = ReadUInt32(ref data);
-            ulong sectorCount = ReadUInt64(ref data);
-
-            header = new DmgHeader(
-                version,
-                flags,
-                runningDataForkOffset,
-                dataForkOffset,
-                dataForkLength,
-                rsrcForkOffset,
-                rsrcForkLength,
-                segmentNumber,
-                segmentCount,
-                segmentID,
-                dataChecksum,
-                xmlOffset,
-                xmlLength,
-                checksum,
-                imageVariant,
-                sectorCount);
-
-            return true;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/DmgStructBase.cs

@@ -1,22 +0,0 @@
-using System;
-using System.Buffers.Binary;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal abstract class DmgStructBase
-    {
-        protected static uint ReadUInt32(ref ReadOnlySpan<byte> data)
-        {
-            uint val = BinaryPrimitives.ReadUInt32BigEndian(data);
-            data = data.Slice(sizeof(uint));
-            return val;
-        }
-
-        protected static ulong ReadUInt64(ref ReadOnlySpan<byte> data)
-        {
-            ulong val = BinaryPrimitives.ReadUInt64BigEndian(data);
-            data = data.Slice(sizeof(ulong));
-            return val;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/GptHeader.cs

@@ -1,90 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal sealed class GptHeader : GptStructBase
-    {
-        private const int HeaderSize = 92;
-        private static readonly ulong Signature = BinaryPrimitives.ReadUInt64LittleEndian(new byte[] { 69, 70, 73, 32, 80, 65, 82, 84 });
-
-        public uint Revision { get; }
-        public uint Crc32Header { get; }
-        public ulong CurrentLba { get; }
-        public ulong BackupLba { get; }
-        public ulong FirstUsableLba { get; }
-        public ulong LastUsableLba { get; }
-        public Guid DiskGuid { get; }
-        public ulong EntriesStart { get; }
-        public uint EntriesCount { get; }
-        public uint EntriesSize { get; }
-        public uint Crc32Array { get; }
-
-        private GptHeader(
-            uint revision,
-            uint crc32Header,
-            ulong currentLba,
-            ulong backupLba,
-            ulong firstUsableLba,
-            ulong lastUsableLba,
-            Guid diskGuid,
-            ulong entriesStart,
-            uint entriesCount,
-            uint entriesSize,
-            uint crc32Array)
-        {
-            Revision = revision;
-            Crc32Header = crc32Header;
-            CurrentLba = currentLba;
-            BackupLba = backupLba;
-            FirstUsableLba = firstUsableLba;
-            LastUsableLba = lastUsableLba;
-            DiskGuid = diskGuid;
-            EntriesStart = entriesStart;
-            EntriesCount = entriesCount;
-            EntriesSize = entriesSize;
-            Crc32Array = crc32Array;
-        }
-
-        public static bool TryRead(Stream stream, out GptHeader? header)
-        {
-            header = null;
-
-            ulong sig = ReadUInt64(stream);
-            if (sig != Signature) return false;
-
-            uint revision = ReadUInt32(stream);
-
-            uint headerSize = ReadUInt32(stream);
-            if (headerSize != HeaderSize) return false;
-
-            uint crc32Header = ReadUInt32(stream);
-            _ = ReadUInt32(stream); // reserved
-            ulong currentLba = ReadUInt64(stream);
-            ulong backupLba = ReadUInt64(stream);
-            ulong firstUsableLba = ReadUInt64(stream);
-            ulong lastUsableLba = ReadUInt64(stream);
-            Guid diskGuid = ReadGuid(stream);
-            ulong entriesStart = ReadUInt64(stream);
-            uint entriesCount = ReadUInt32(stream);
-            uint entriesSize = ReadUInt32(stream);
-            uint crc32Array = ReadUInt32(stream);
-
-            header = new GptHeader(
-                revision,
-                crc32Header,
-                currentLba,
-                backupLba,
-                firstUsableLba,
-                lastUsableLba,
-                diskGuid,
-                entriesStart,
-                entriesCount,
-                entriesSize,
-                crc32Array);
-
-            return true;
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/GptPartitionEntry.cs

@@ -1,36 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal sealed class GptPartitionEntry : GptStructBase
-    {
-        public Guid TypeGuid { get; }
-        public Guid Guid { get; }
-        public ulong FirstLba { get; }
-        public ulong LastLba { get; }
-        public ulong Attributes { get; }
-        public string Name { get; }
-
-        private GptPartitionEntry(Guid typeGuid, Guid guid, ulong firstLba, ulong lastLba, ulong attributes, string name)
-        {
-            TypeGuid = typeGuid;
-            Guid = guid;
-            FirstLba = firstLba;
-            LastLba = lastLba;
-            Attributes = attributes;
-            Name = name;
-        }
-
-        public static GptPartitionEntry Read(Stream stream)
-        {
-            return new GptPartitionEntry(
-                ReadGuid(stream),
-                ReadGuid(stream),
-                ReadUInt64(stream),
-                ReadUInt64(stream),
-                ReadUInt64(stream),
-                ReadString(stream, 72));
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/GptStructBase.cs

@@ -1,56 +0,0 @@
-using System;
-using System.Buffers.Binary;
-using System.IO;
-using System.Text;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal abstract class GptStructBase
-    {
-        private static readonly byte[] _buffer = new byte[8];
-
-        protected static ushort ReadUInt16(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(ushort)) != sizeof(ushort))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadUInt16LittleEndian(_buffer);
-        }
-
-        protected static uint ReadUInt32(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(uint)) != sizeof(uint))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadUInt32LittleEndian(_buffer);
-        }
-
-        protected static ulong ReadUInt64(Stream stream)
-        {
-            if (stream.Read(_buffer, 0, sizeof(ulong)) != sizeof(ulong))
-                throw new EndOfStreamException();
-
-            return BinaryPrimitives.ReadUInt64LittleEndian(_buffer);
-        }
-
-        protected static Guid ReadGuid(Stream stream)
-        {
-            int a = (int)ReadUInt32(stream);
-            short b = (short)ReadUInt16(stream);
-            short c = (short)ReadUInt16(stream);
-
-            if (stream.Read(_buffer, 0, 8) != 8)
-                throw new EndOfStreamException();
-
-            return new Guid(a, b, c, _buffer);
-        }
-
-        protected static string ReadString(Stream stream, int byteSize)
-        {
-            var buffer = new byte[byteSize];
-            if (stream.Read(buffer, 0, byteSize) != byteSize)
-                throw new EndOfStreamException();
-            return Encoding.Unicode.GetString(buffer).NullTerminate();
-        }
-    }
-}

src/SharpCompress/Common/Dmg/Headers/UdifChecksum.cs

@@ -1,33 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace SharpCompress.Common.Dmg.Headers
-{
-    internal sealed class UdifChecksum : DmgStructBase
-    {
-        private const int MaxSize = 32; // * 4 to get byte size
-
-        public uint Type { get; }
-        public uint Size { get; } // in bits
-        public IReadOnlyList<uint> Bits { get; }
-
-        private UdifChecksum(uint type, uint size, IReadOnlyList<uint> bits)
-        {
-            Type = type;
-            Size = size;
-            Bits = bits;
-        }
-
-        public static UdifChecksum Read(ref ReadOnlySpan<byte> data)
-        {
-            uint type = ReadUInt32(ref data);
-            uint size = ReadUInt32(ref data);
-
-            var bits = new uint[MaxSize];
-            for (int i = 0; i < MaxSize; i++)
-                bits[i] = ReadUInt32(ref data);
-
-            return new UdifChecksum(type, size, bits);
-        }
-    }
-}

src/SharpCompress/Common/Dmg/PartitionFormat.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace SharpCompress.Common.Dmg
-{
-    internal static class PartitionFormat
-    {
-        public static readonly Guid AppleHFS         = new Guid("48465300-0000-11AA-AA11-00306543ECAC");
-        public static readonly Guid AppleUFS         = new Guid("55465300-0000-11AA-AA11-00306543ECAC");
-        public static readonly Guid AppleBoot        = new Guid("426F6F74-0000-11AA-AA11-00306543ECAC");
-        public static readonly Guid AppleRaid        = new Guid("52414944-0000-11AA-AA11-00306543ECAC");
-        public static readonly Guid AppleRaidOffline = new Guid("52414944-5F4F-11AA-AA11-00306543ECAC");
-        public static readonly Guid AppleLabel       = new Guid("4C616265-6C00-11AA-AA11-00306543ECAC");
-    }
-}

src/SharpCompress/Common/Entry.cs

@@ -1,89 +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() => Key;
+    public int VolumeIndexFirst => Parts?.FirstOrDefault()?.Index ?? 0;
+    public int VolumeIndexLast => Parts?.LastOrDefault()?.Index ?? 0;
 
-        internal abstract IEnumerable<FilePart> Parts { get; }
+    /// <inheritdoc/>
+    public override string ToString() => Key;
 
-        internal bool IsSolid { get; set; }
+    internal abstract IEnumerable<FilePart> Parts { get; }
 
-        internal virtual void Close()
-        {
-        }
+    public bool IsSolid { get; set; }
 
-        /// <summary>
-        /// Entry file attribute.
-        /// </summary>
-        public virtual int? Attrib => throw new NotImplementedException();
-    }
+    internal virtual void Close() { }
+
+    /// <summary>
+    /// Entry file attribute.
+    /// </summary>
+    public virtual int? Attrib => throw new NotImplementedException();
 }

src/SharpCompress/Common/EntryStream.cs

@@ -1,93 +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;
+        string 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 ??= 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, StringComparison.Ordinal))
-                    {
-                        throw new ExtractionException("Entry is trying to create a directory outside of the destination directory.");
-                    }
-
-                    Directory.CreateDirectory(destdir);
-                }
-                destinationFileName = Path.Combine(destdir, file);
-            }
-            else
-            {
-                destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
-
-            }
-
-            if (!entry.IsDirectory)
-            {
-                destinationFileName = Path.GetFullPath(destinationFileName);
-
-                if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
-                {
-                    throw new ExtractionException("Entry is trying to write a file outside of the destination directory.");
-                }
-                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 (options?.WriteSymbolicLink is null)
-                {
-                    throw new ExtractionException("Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null");
-                }
-                options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
-            }
-            else
-            {
-                FileMode fm = FileMode.Create;
-                options ??= new ExtractionOptions()
-                {
-                    Overwrite = true
-                };
+            throw new ExtractionException(
+                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
+            );
+        }
 
-                if (!options.Overwrite)
+        options ??= new ExtractionOptions() { Overwrite = true };
+
+        string file = Path.GetFileName(entry.Key);
+        if (options.ExtractFullPath)
+        {
+            string folder = Path.GetDirectoryName(entry.Key)!;
+            string destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+
+            if (!Directory.Exists(destdir))
+            {
+                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
+        {
+            FileMode 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,40 +1,40 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+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 =
-            (sourcePath, targetPath) =>
-            {
-                Console.WriteLine($"Could not write symlink {sourcePath} -> {targetPath}, for more information please see https://github.com/dotnet/runtime/issues/24271");
-            };
-    }
-}
+        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,29 +1,28 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public sealed class FilePartExtractionBeginEventArgs : EventArgs
 {
-    public sealed class FilePartExtractionBeginEventArgs : EventArgs
+    public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize)
     {
-        public FilePartExtractionBeginEventArgs(string name, long size, long compressedSize)
-        {
-            Name = name;
-            Size = size;
-            CompressedSize = compressedSize;
-        }
-
-        /// <summary>
-        /// File name for the part for the current entry
-        /// </summary>
-        public string Name { get; }
-
-        /// <summary>
-        /// Uncompressed size of the current entry in the part
-        /// </summary>
-        public long Size { get; }
-
-        /// <summary>
-        /// Compressed size of the current entry in the part
-        /// </summary>
-        public long CompressedSize { get; }
+        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

@@ -2,48 +2,44 @@
 using System.Collections.Generic;
 using System.IO;
 
-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 => _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)
-        {
-            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,133 +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 sealed class GZipFilePart : FilePart
+    private string? _name;
+    private readonly Stream _stream;
+
+    internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
+        : base(archiveEncoding)
     {
-        private string? _name;
-        private readonly Stream _stream;
-
-        internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
-            : base(archiveEncoding)
+        _stream = stream;
+        ReadAndValidateGzipHeader();
+        if (stream.CanSeek)
         {
-            _stream = stream;
-            ReadAndValidateGzipHeader();
-            if (stream.CanSeek)
-            {
-                long position = stream.Position;
-                stream.Position = stream.Length - 8;
-                ReadTrailer();
-                stream.Position = position;
-            }
-            EntryStartPosition = stream.Position;
+            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 int? Crc { get; private set; }
-        internal int? UncompressedSize { 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 ReadTrailer()
+        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
+        DateModified = TarHeader.EPOCH.AddSeconds(timet);
+        if ((header[3] & 0x04) == 0x04)
         {
-            // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-            Span<byte> trailer = stackalloc byte[8];
-            int n = _stream.Read(trailer);
+            // read and discard extra field
+            n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
 
-            Crc = BinaryPrimitives.ReadInt32LittleEndian(trailer);
-            UncompressedSize = BinaryPrimitives.ReadInt32LittleEndian(trailer.Slice(4));
+            var extraLength = (short)(header[0] + (header[1] * 256));
+            var extra = new byte[extraLength];
+
+            if (!_stream.ReadFully(extra))
+            {
+                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+            }
+            n = extraLength;
         }
-
-        private void ReadAndValidateGzipHeader()
+        if ((header[3] & 0x08) == 0x08)
         {
-            // read the header on the first read
-            Span<byte> header = stackalloc byte[10];
-            int n = _stream.Read(header);
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
-            {
-                return;
-            }
-
-            if (n != 10)
-            {
-                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.Slice(4));
-            DateModified = TarHeader.EPOCH.AddSeconds(timet);
-            if ((header[3] & 0x04) == 0x04)
-            {
-                // read and discard extra field
-                n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
-
-                short extraLength = (short)(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
-            }
+            _name = ReadZeroTerminatedString(_stream);
         }
-
-        private string ReadZeroTerminatedString(Stream stream)
+        if ((header[3] & 0x10) == 0x010)
         {
-            Span<byte> buf1 = stackalloc byte[1];
-            var list = new List<byte>();
-            bool done = false;
-            do
-            {
-                // workitem 7740
-                int 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);
-            byte[] buffer = list.ToArray();
-            return ArchiveEncoding.Decode(buffer);
+            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,45 +1,48 @@
-using System.IO;
+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);
                 }
             }
         }