Update docker build

.circleci/config.yml

@@ -0,0 +1,16 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: mcr.microsoft.com/dotnet/core/sdk:2.2-alpine
+    steps:
+      - checkout
+      - run:
+          name: Install Cake
+          command: |
+            dotnet tool install -g Cake.Tool
+            echo 'export PATH=$PATH:/root/.dotnet/tools' >> $BASH_ENV
+            source $BASH_ENV
+      - run:
+          name: Build
+          command: dotnet cake build.cake

.config/dotnet-tools.json

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

.editorconfig

@@ -1,543 +0,0 @@
-# Version: 2.0.1 (Using https://semver.org/)
-# Updated: 2020-12-11
-# See https://github.com/RehanSaeed/EditorConfig/releases for release notes.
-# See https://github.com/RehanSaeed/EditorConfig for updates to this file.
-# See http://EditorConfig.org for more information about .editorconfig files.
-
-##########################################
-# Common Settings
-##########################################
-
-# This file is the top-most EditorConfig file
-root = true
-
-# All Files
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 4
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-##########################################
-# File Extension Settings
-##########################################
-
-# Visual Studio Solution Files
-[*.sln]
-indent_style = tab
-
-# Visual Studio XML Project Files
-[*.{csproj,vbproj,vcxproj.filters,proj,projitems,shproj}]
-indent_size = 2
-
-# XML Configuration Files
-[*.{xml,config,props,targets,nuspec,resx,ruleset,vsixmanifest,vsct}]
-indent_size = 2
-
-# JSON Files
-[*.{json,json5,webmanifest}]
-indent_size = 2
-
-# YAML Files
-[*.{yml,yaml}]
-indent_size = 2
-
-# Markdown Files
-[*.md]
-trim_trailing_whitespace = false
-
-# Web Files
-[*.{htm,html,js,jsm,ts,tsx,css,sass,scss,less,svg,vue}]
-indent_size = 2
-
-# Batch Files
-[*.{cmd,bat}]
-end_of_line = crlf
-
-# Bash Files
-[*.sh]
-end_of_line = lf
-
-# Makefiles
-[Makefile]
-indent_style = tab
-
-##########################################
-# Default .NET Code Style Severities
-# https://docs.microsoft.com/dotnet/fundamentals/code-analysis/configuration-options#scope
-##########################################
-
-[*.{cs,csx,cake,vb,vbx}]
-# Default Severity for all .NET Code Style rules below
-dotnet_analyzer_diagnostic.severity = warning
-
-##########################################
-# File Header (Uncomment to support file headers)
-# https://docs.microsoft.com/visualstudio/ide/reference/add-file-header
-##########################################
-
-# [*.{cs,csx,cake,vb,vbx}]
-# file_header_template = <copyright file="{fileName}" company="PROJECT-AUTHOR">\n© PROJECT-AUTHOR\n</copyright>
-
-# SA1636: File header copyright text should match
-# Justification: .editorconfig supports file headers. If this is changed to a value other than "none", a stylecop.json file will need to added to the project.
-# dotnet_diagnostic.SA1636.severity = none
-
-##########################################
-# .NET Language Conventions
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions
-##########################################
-
-# .NET Code Style Settings
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#net-code-style-settings
-[*.{cs,csx,cake,vb,vbx}]
-# "this." and "Me." qualifiers
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#this-and-me
-#dotnet_style_qualification_for_field = true:warning
-#dotnet_style_qualification_for_property = true:warning
-#dotnet_style_qualification_for_method = true:warning
-#dotnet_style_qualification_for_event = true:warning
-# Language keywords instead of framework type names for type references
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#language-keywords
-dotnet_style_predefined_type_for_locals_parameters_members = true:warning
-dotnet_style_predefined_type_for_member_access = true:warning
-# Modifier preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#normalize-modifiers
-dotnet_style_require_accessibility_modifiers = always:warning
-csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
-visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:warning
-dotnet_style_readonly_field = true:warning
-# Parentheses preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parentheses-preferences
-dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning
-dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning
-dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
-dotnet_style_parentheses_in_other_operators = always_for_clarity:suggestion
-# Expression-level preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
-dotnet_style_object_initializer = true:warning
-dotnet_style_collection_initializer = true:warning
-dotnet_style_explicit_tuple_names = true:warning
-dotnet_style_prefer_inferred_tuple_names = true:warning
-dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
-dotnet_style_prefer_auto_properties = true:warning
-dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
-dotnet_style_prefer_conditional_expression_over_assignment = false:suggestion
-dotnet_diagnostic.IDE0045.severity = suggestion
-dotnet_style_prefer_conditional_expression_over_return = false:suggestion
-dotnet_diagnostic.IDE0046.severity = suggestion
-dotnet_style_prefer_compound_assignment = true:warning
-# Null-checking preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#null-checking-preferences
-dotnet_style_coalesce_expression = true:warning
-dotnet_style_null_propagation = true:warning
-# Parameter preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parameter-preferences
-dotnet_code_quality_unused_parameters = all:warning
-# More style options (Undocumented)
-# https://github.com/MicrosoftDocs/visualstudio-docs/issues/3641
-dotnet_style_operator_placement_when_wrapping = end_of_line
-# https://github.com/dotnet/roslyn/pull/40070
-dotnet_style_prefer_simplified_interpolation = true:warning
-
-# C# Code Style Settings
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-code-style-settings
-[*.{cs,csx,cake}]
-# Implicit and explicit types
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#implicit-and-explicit-types
-csharp_style_var_for_built_in_types = true:warning
-csharp_style_var_when_type_is_apparent = true:warning
-csharp_style_var_elsewhere = true:warning
-# Expression-bodied members
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-bodied-members
-csharp_style_expression_bodied_methods = true:warning
-csharp_style_expression_bodied_constructors = true:warning
-csharp_style_expression_bodied_operators = true:warning
-csharp_style_expression_bodied_properties = true:warning
-csharp_style_expression_bodied_indexers = true:warning
-csharp_style_expression_bodied_accessors = true:warning
-csharp_style_expression_bodied_lambdas = true:warning
-csharp_style_expression_bodied_local_functions = true:warning
-# Pattern matching
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#pattern-matching
-csharp_style_pattern_matching_over_is_with_cast_check = true:warning
-csharp_style_pattern_matching_over_as_with_null_check = true:warning
-# Inlined variable declarations
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#inlined-variable-declarations
-csharp_style_inlined_variable_declaration = true:warning
-# Expression-level preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
-csharp_prefer_simple_default_expression = true:warning
-# "Null" checking preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-null-checking-preferences
-csharp_style_throw_expression = true:warning
-csharp_style_conditional_delegate_call = true:warning
-# Code block preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#code-block-preferences
-csharp_prefer_braces = true:warning
-# Unused value preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#unused-value-preferences
-csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
-dotnet_diagnostic.IDE0058.severity = suggestion
-csharp_style_unused_value_assignment_preference = discard_variable:suggestion
-dotnet_diagnostic.IDE0059.severity = suggestion
-# Index and range preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#index-and-range-preferences
-csharp_style_prefer_index_operator = true:warning
-csharp_style_prefer_range_operator = true:warning
-# Miscellaneous preferences
-# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#miscellaneous-preferences
-csharp_style_deconstructed_variable_declaration = true:warning
-csharp_style_pattern_local_over_anonymous_function = true:warning
-csharp_using_directive_placement = outside_namespace:warning
-csharp_prefer_static_local_function = true:warning
-csharp_prefer_simple_using_statement = true:suggestion
-dotnet_diagnostic.IDE0063.severity = suggestion
-
-csharp_style_namespace_declarations = file_scoped
-
-##########################################
-# .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
-
-##########################################
-# .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.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.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.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.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.BL0005.severity = suggestion
-
-dotnet_diagnostic.MVC1000.severity = suggestion
-
-dotnet_diagnostic.IDE0055.severity = suggestion # Fix formatting
-dotnet_diagnostic.IDE0023.severity = suggestion # use expression body for operators
-dotnet_diagnostic.IDE0025.severity = suggestion # use expression body for properties
-dotnet_diagnostic.IDE1006.severity = suggestion # Naming rule violation: These words cannot contain lower case characters
-dotnet_diagnostic.IDE0072.severity = suggestion # Populate switch - forces population of all cases even when default specified
-dotnet_diagnostic.IDE0027.severity = suggestion # Use expression body for accessors
-dotnet_diagnostic.IDE0032.severity = suggestion # Use auto property
-dotnet_diagnostic.IDE0007.severity = error # Use var
-dotnet_diagnostic.IDE0160.severity = suggestion # Use block scoped
-dotnet_diagnostic.IDE0011.severity = error # Use braces on if statements
-dotnet_diagnostic.IDE0057.severity = suggestion # substring can be simplified
-dotnet_diagnostic.IDE0004.severity = error # redundant cast
-dotnet_diagnostic.IDE0010.severity = silent # populate switch
-dotnet_diagnostic.IDE0021.severity = silent # expression body for constructors
-dotnet_diagnostic.IDE0022.severity = silent # expression body for methods
-dotnet_diagnostic.IDE0024.severity = silent # expression body for operators
-dotnet_diagnostic.IDE0028.severity = silent
-dotnet_diagnostic.IDE0033.severity = error # prefer tuple name
-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 = error # 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.IDE0060.severity = suggestion # unused parameters
-dotnet_diagnostic.IDE0066.severity = suggestion # switch expression
-dotnet_diagnostic.IDE0078.severity = suggestion # use pattern matching
-dotnet_diagnostic.IDE0090.severity = suggestion # new can be simplified
-dotnet_diagnostic.IDE0130.severity = suggestion # namespace folder structure
-dotnet_diagnostic.IDE0160.severity = silent # Use block namespaces ARE NOT required
-dotnet_diagnostic.IDE0161.severity = suggestion # Please use file namespaces
-
-##########################################
-# 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

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

.github/workflows/dotnetcore.yml

@@ -1,20 +0,0 @@
-name: SharpCompress
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [windows-latest, ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v3
-    - uses: actions/setup-dotnet@v2
-      with:
-        dotnet-version: 6.0.x
-    - run: dotnet run -p build/build.csproj
-    - uses: actions/upload-artifact@v3
-      with:
-        name: ${{ matrix.os }}-sharpcompress.nupkg
-        path: artifacts/*

.gitignore

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

FORMATS.md

@@ -19,6 +19,7 @@
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
 | 7Zip (4)               | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate      | Decompress          | SevenZipArchive | N/A        | N/A           |
+| LZip (single file) (5) | LZip (LZMA)                                       | Both                | LZipArchive     | LZipReader | LZipWriter    |
 
 1. SOLID Rars are only supported in the RarReader API.
 2. Zip format supports pkware and WinzipAES encryption. However, encrypted LZMA is not supported. Zip64 reading/writing is supported but only with seekable streams as the Zip spec doesn't support Zip64 data in post data descriptors. Deflate64 is only supported for reading.

README.md

@@ -1,11 +1,14 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1, .NET Core 3.1 and .NET 5.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Standard 1.4 and 2.0 and .NET 4.6 that can unrar, un7zip, unzip, untar unbzip2 and ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip are implemented.
 
 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)
+AppVeyor Build -
+[![Build status](https://ci.appveyor.com/api/projects/status/voxg971oemmvxh1e/branch/master?svg=true)](https://ci.appveyor.com/project/adamhathcock/sharpcompress/branch/master)
+
+Circle CI Build -
+[![CircleCI](https://circleci.com/gh/adamhathcock/sharpcompress.svg?style=svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
 
 ## Need Help?
 
@@ -182,8 +185,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott
 
-XZ BCJ filters support contributed by Louis-Michel Bergeron, on behalf of aDolus Technology Inc. - 2022
-
 7Zip implementation based on: https://code.google.com/p/managed-lzma/
 
 LICENSE

SharpCompress.sln

@@ -13,8 +13,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress", "src\SharpC
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress.Test", "tests\SharpCompress.Test\SharpCompress.Test.csproj", "{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "build", "build\build.csproj", "{D4D613CB-5E94-47FB-85BE-B8423D20C545}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -29,10 +27,6 @@ Global
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

SharpCompress.sln.DotSettings

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

appveyor.yml

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

build.cake

@@ -0,0 +1,81 @@
+var target = Argument("target", "Default");
+var tag = Argument("tag", "cake");
+
+Task("Restore")
+  .Does(() =>
+{
+    DotNetCoreRestore(".");
+});
+
+Task("Build")
+  .IsDependentOn("Restore")
+  .Does(() =>
+{
+    var settings = new DotNetCoreBuildSettings
+    {
+        Framework = "netstandard1.4",
+        Configuration = "Release",
+        NoRestore = true
+    };
+
+    DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
+
+    if (IsRunningOnWindows())
+    {
+        settings.Framework = "net46";
+        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
+    }
+
+    settings.Framework = "netstandard2.0";
+    DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
+});
+
+Task("Test")
+  .IsDependentOn("Build")
+  .Does(() =>
+{
+    var files = GetFiles("tests/**/*.csproj");
+    foreach(var file in files)
+    {
+        var settings = new DotNetCoreTestSettings
+        {
+            Configuration = "Release",
+            Framework = "netcoreapp2.2"
+        };
+        DotNetCoreTest(file.ToString(), settings);
+    }
+});
+
+Task("Pack")
+    .IsDependentOn("Build")
+    .Does(() => 
+{ 
+    if (IsRunningOnWindows())
+    {
+        var settings = new DotNetCorePackSettings
+        {
+            Configuration = "Release",
+            NoBuild = true
+        };
+
+        DotNetCorePack("src/SharpCompress/SharpCompress.csproj", settings);
+    }
+    else 
+    {
+        Information("Skipping Pack as this is not Windows");
+    }
+});
+
+Task("Default")
+    .IsDependentOn("Restore")
+    .IsDependentOn("Build")
+    .IsDependentOn("Test")
+    .IsDependentOn("Pack");
+
+ Task("RunTests")
+    .IsDependentOn("Restore")
+    .IsDependentOn("Build")
+    .IsDependentOn("Test");
+
+
+RunTarget(target);

build.ps1

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

build.sh

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

build/Program.cs

@@ -1,83 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Runtime.InteropServices;
-using GlobExpressions;
-using static Bullseye.Targets;
-using static SimpleExec.Command;
-
-const string Clean = "clean";
-const string Format = "format";
-const string Build = "build";
-const string Test = "test";
-const string Publish = "publish";
-
-Target(Clean,
-       ForEach("**/bin", "**/obj"),
-       dir =>
-       {
-           IEnumerable<string> GetDirectories(string d)
-           {
-               return Glob.Directories(".", d);
-           }
-
-           void RemoveDirectory(string d)
-           {
-               if (Directory.Exists(d))
-               {
-                   Console.WriteLine(d);
-                   Directory.Delete(d, true);
-               }
-           }
-
-           foreach (var d in GetDirectories(dir))
-           {
-               RemoveDirectory(d);
-           }
-       });
-
-Target(Format,
-       () =>
-       {
-           Run("dotnet", "tool restore");
-           Run("dotnet", "format --check");
-       });
-
-Target(Build,
-       DependsOn(Format),
-       framework =>
-       {
-           Run("dotnet", "build src/SharpCompress/SharpCompress.csproj -c Release");
-       });
-
-Target(Test,
-       DependsOn(Build),
-       ForEach("net6.0", "net461"),
-       framework =>
-       {
-           IEnumerable<string> GetFiles(string d)
-           {
-               return Glob.Files(".", d);
-           }
-
-           if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && framework == "net461")
-           {
-               return;
-           }
-
-           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!"));
-
-await RunTargetsAndExitAsync(args);

build/build.csproj

@@ -1,14 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Bullseye" Version="4.0.0" />
-    <PackageReference Include="Glob" Version="1.1.9" />
-    <PackageReference Include="SimpleExec" Version="10.0.0" />
-  </ItemGroup>
-
-</Project>

global.json

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

src/SharpCompress/Algorithms/Adler32.cs

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

src/SharpCompress/Archives/AbstractArchive.cs

@@ -1,9 +1,8 @@
-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
@@ -15,34 +14,46 @@ namespace SharpCompress.Archives
         private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
         private readonly LazyReadOnlyCollection<TEntry> lazyEntries;
 
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
 
-        public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
-        public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
+        public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
+        public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
 
         protected ReaderOptions ReaderOptions { get; }
 
         private bool disposed;
-        protected SourceStream SrcStream;
-
-        internal AbstractArchive(ArchiveType type, SourceStream srcStream)
+        
+        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
         {
             Type = type;
-            ReaderOptions = srcStream.ReaderOptions;
-            SrcStream = srcStream;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(SrcStream));
+            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));
         }
 
-#nullable disable
         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; }
 
@@ -68,29 +79,29 @@ namespace SharpCompress.Archives
         /// <summary>
         /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
         /// </summary>
-        public virtual ICollection<TEntry> Entries => lazyEntries;
+        public virtual ICollection<TEntry> Entries { get { return lazyEntries; } }
 
         /// <summary>
         /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
         /// </summary>
-        public ICollection<TVolume> Volumes => lazyVolumes;
+        public ICollection<TVolume> Volumes { get { return 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);
+        public virtual long TotalSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize); } }
 
         /// <summary>
         /// The total size of the files as uncompressed in the archive.
         /// </summary>
-        public virtual long TotalUncompressSize => Entries.Aggregate(0L, (total, cf) => total + cf.Size);
+        public virtual long TotalUncompressSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); } }
 
-        protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream srcStream);
+        protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams);
         protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
 
-        IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
+        IEnumerable<IArchiveEntry> IArchive.Entries { get { return Entries.Cast<IArchiveEntry>(); } }
 
-        IEnumerable<IVolume> IArchive.Volumes => lazyVolumes.Cast<IVolume>();
+        IEnumerable<IVolume> IArchive.Volumes { get { return lazyVolumes.Cast<IVolume>(); } }
 
         public virtual void Dispose()
         {
@@ -98,8 +109,6 @@ namespace SharpCompress.Archives
             {
                 lazyVolumes.ForEach(v => v.Dispose());
                 lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
-                if (SrcStream != null)
-                    SrcStream.Dispose();
                 disposed = true;
             }
         }
@@ -112,29 +121,31 @@ namespace SharpCompress.Archives
 
         void IExtractionListener.FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes)
         {
-            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs(
-                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
-                compressedBytesRead: compressedReadBytes
-            ));
+            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs
+            {
+                CurrentFilePartCompressedBytesRead = currentPartCompressedBytes,
+                CompressedBytesRead = compressedReadBytes
+            });
         }
 
         void IExtractionListener.FireFilePartExtractionBegin(string name, long size, long compressedSize)
         {
-            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs(
-                compressedSize: compressedSize,
-                size: size,
-                name: name
-            ));
+            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
+        /// 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
+        /// 
+        /// 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>
@@ -149,7 +160,7 @@ namespace SharpCompress.Archives
         /// <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;
+        public virtual bool IsSolid { get { return false; } }
 
         /// <summary>
         /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
@@ -163,4 +174,4 @@ namespace SharpCompress.Archives
             }
         }
     }
-}
+}

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -1,9 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Writers;
 
@@ -13,36 +12,24 @@ namespace SharpCompress.Archives
         where TEntry : IArchiveEntry
         where TVolume : IVolume
     {
-        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)
         {
         }
 
-        internal AbstractWritableArchive(ArchiveType type, SourceStream srcStream)
-            : base(type, srcStream)
+        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
+            : base(type, stream.AsEnumerable(), readerFactoryOptions)
+        {
+        }
+
+        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
+            : base(type, fileInfo, readerFactoryOptions)
         {
         }
 
@@ -58,17 +45,8 @@ namespace SharpCompress.Archives
             }
         }
 
-        public IDisposable PauseEntryRebuilding()
-        {
-            return new RebuildPauseDisposable(this);
-        }
-
         private void RebuildModifiedCollection()
         {
-            if (pauseRebuilding)
-            {
-                return;
-            }
             hasModifications = true;
             newEntries.RemoveAll(v => removedEntries.Contains(v));
             modifiedEntries.Clear();
@@ -105,7 +83,8 @@ namespace SharpCompress.Archives
         public TEntry AddEntry(string key, Stream source, bool closeStream,
                                long size = 0, DateTime? modified = null)
         {
-            if (key.Length > 0 && key[0] is '/' or '\\')
+            if (key.StartsWith("/")
+                || key.StartsWith("\\"))
             {
                 key = key.Substring(1);
             }
@@ -124,7 +103,7 @@ namespace SharpCompress.Archives
             foreach (var path in Entries.Select(x => x.Key))
             {
                 var p = path.Replace('/', '\\');
-                if (p.Length > 0 && p[0] == '\\')
+                if (p.StartsWith("\\"))
                 {
                     p = p.Substring(1);
                 }
@@ -163,4 +142,4 @@ namespace SharpCompress.Archives
             modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
         }
     }
-}
+}

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -1,19 +1,16 @@
-using System;
-using System.Collections.Generic;
+using System;
 using System.IO;
-using System.Linq;
 using SharpCompress.Archives.GZip;
 using SharpCompress.Archives.Rar;
 using SharpCompress.Archives.SevenZip;
 using SharpCompress.Archives.Tar;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives
 {
-    public static class ArchiveFactory
+    public class ArchiveFactory
     {
         /// <summary>
         /// Opens an Archive for random access
@@ -21,46 +18,67 @@ namespace SharpCompress.Archives
         /// <param name="stream"></param>
         /// <param name="readerOptions"></param>
         /// <returns></returns>
-        public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
         {
             stream.CheckNotNull(nameof(stream));
             if (!stream.CanRead || !stream.CanSeek)
             {
                 throw new ArgumentException("Stream should be readable and seekable");
             }
-            readerOptions ??= new ReaderOptions();
-
-            ArchiveType? type;
-            IsArchive(stream, out type); //test and reset stream position
-
-            if (type != null)
+            readerOptions = readerOptions ?? new ReaderOptions();
+            if (ZipArchive.IsZipFile(stream, null))
             {
-                switch (type.Value)
-                {
-                    case ArchiveType.Zip:
-                        return ZipArchive.Open(stream, readerOptions);
-                    case ArchiveType.SevenZip:
-                        return SevenZipArchive.Open(stream, readerOptions);
-                    case ArchiveType.GZip:
-                        return GZipArchive.Open(stream, readerOptions);
-                    case ArchiveType.Rar:
-                        return RarArchive.Open(stream, readerOptions);
-                    case ArchiveType.Tar:
-                        return TarArchive.Open(stream, readerOptions);
-                }
+                stream.Seek(0, SeekOrigin.Begin);
+                return ZipArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            if (SevenZipArchive.IsSevenZipFile(stream))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return SevenZipArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            if (GZipArchive.IsGZipFile(stream))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return GZipArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            if (RarArchive.IsRarFile(stream, readerOptions))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return RarArchive.Open(stream, readerOptions);
+            }
+            stream.Seek(0, SeekOrigin.Begin);
+            if (TarArchive.IsTarFile(stream))
+            {
+                stream.Seek(0, SeekOrigin.Begin);
+                return TarArchive.Open(stream, readerOptions);
             }
             throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
         }
 
         public static IWritableArchive Create(ArchiveType type)
         {
-            return type switch
+            switch (type)
             {
-                ArchiveType.Zip => ZipArchive.Create(),
-                ArchiveType.Tar => TarArchive.Create(),
-                ArchiveType.GZip => GZipArchive.Create(),
-                _ => throw new NotSupportedException("Cannot create Archives of type: " + type)
-            };
+                case ArchiveType.Zip:
+                {
+                    return ZipArchive.Create();
+                }
+                case ArchiveType.Tar:
+                {
+                    return TarArchive.Create();
+                }
+                case ArchiveType.GZip:
+                {
+                    return GZipArchive.Create();
+                }
+                default:
+                {
+                    throw new NotSupportedException("Cannot create Archives of type: " + type);
+                }
+            }
         }
 
         /// <summary>
@@ -68,7 +86,7 @@ namespace SharpCompress.Archives
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="options"></param>
-        public static IArchive Open(string filePath, ReaderOptions? options = null)
+        public static IArchive Open(string filePath, ReaderOptions options = null)
         {
             filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), options);
@@ -79,217 +97,52 @@ namespace SharpCompress.Archives
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="options"></param>
-        public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+        public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null)
         {
             fileInfo.CheckNotNull(nameof(fileInfo));
-            options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-            ArchiveType? type;
-            using (Stream stream = fileInfo.OpenRead())
+            options = options ?? new ReaderOptions { LeaveStreamOpen = false };
+            using (var stream = fileInfo.OpenRead())
             {
-                IsArchive(stream, out type); //test and reset stream position
-
-                if (type != null)
+                if (ZipArchive.IsZipFile(stream, null))
                 {
-                    switch (type.Value)
-                    {
-                        case ArchiveType.Zip:
-                            return ZipArchive.Open(fileInfo, options);
-                        case ArchiveType.SevenZip:
-                            return SevenZipArchive.Open(fileInfo, options);
-                        case ArchiveType.GZip:
-                            return GZipArchive.Open(fileInfo, options);
-                        case ArchiveType.Rar:
-                            return RarArchive.Open(fileInfo, options);
-                        case ArchiveType.Tar:
-                            return TarArchive.Open(fileInfo, options);
-                    }
+                    return ZipArchive.Open(fileInfo, options);
                 }
-            }
-            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
-        }
-
-        /// <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));
-            FileInfo[] files = fileInfos.ToArray();
-            if (files.Length == 0)
-                throw new InvalidOperationException("No files to open");
-            FileInfo fileInfo = files[0];
-            if (files.Length == 1)
-                return Open(fileInfo, options);
-
-
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-            ArchiveType? type;
-            using (Stream stream = fileInfo.OpenRead())
-                IsArchive(stream, out type); //test and reset stream position
-
-            if (type != null)
-            {
-                switch (type.Value)
+                stream.Seek(0, SeekOrigin.Begin);
+                if (SevenZipArchive.IsSevenZipFile(stream))
                 {
-                    case ArchiveType.Zip:
-                        return ZipArchive.Open(files, options);
-                    case ArchiveType.SevenZip:
-                        return SevenZipArchive.Open(files, options);
-                    case ArchiveType.GZip:
-                        return GZipArchive.Open(files, options);
-                    case ArchiveType.Rar:
-                        return RarArchive.Open(files, options);
-                    case ArchiveType.Tar:
-                        return TarArchive.Open(files, options);
+                    return SevenZipArchive.Open(fileInfo, options);
                 }
-            }
-            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
-        }
-
-        /// <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));
-            if (streams.Count() == 0)
-                throw new InvalidOperationException("No streams");
-            if (streams.Count() == 1)
-                return Open(streams.First(), options);
-
-
-            options ??= new ReaderOptions();
-
-            ArchiveType? type;
-            using (Stream stream = streams.First())
-                IsArchive(stream, out type); //test and reset stream position
-
-            if (type != null)
-            {
-                switch (type.Value)
+                stream.Seek(0, SeekOrigin.Begin);
+                if (GZipArchive.IsGZipFile(stream))
                 {
-                    case ArchiveType.Zip:
-                        return ZipArchive.Open(streams, options);
-                    case ArchiveType.SevenZip:
-                        return SevenZipArchive.Open(streams, options);
-                    case ArchiveType.GZip:
-                        return GZipArchive.Open(streams, options);
-                    case ArchiveType.Rar:
-                        return RarArchive.Open(streams, options);
-                    case ArchiveType.Tar:
-                        return TarArchive.Open(streams, options);
+                    return GZipArchive.Open(fileInfo, options);
                 }
+                stream.Seek(0, SeekOrigin.Begin);
+                if (RarArchive.IsRarFile(stream, options))
+                {
+                   return RarArchive.Open(fileInfo, options);
+                }
+                stream.Seek(0, SeekOrigin.Begin);
+                if (TarArchive.IsTarFile(stream))
+                {
+                    return TarArchive.Open(fileInfo, options);
+                }
+                throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
             }
-            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
         }
 
         /// <summary>
         /// Extract to specific directory, retaining filename
         /// </summary>
         public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
-                                            ExtractionOptions? options = null)
+                                            ExtractionOptions options = null)
         {
-            using IArchive archive = Open(sourceArchive);
-            foreach (IArchiveEntry entry in archive.Entries)
+            using (IArchive archive = Open(sourceArchive))
             {
-                entry.WriteToDirectory(destinationDirectory, options);
-            }
-        }
-
-        public static bool IsArchive(string filePath, out ArchiveType? type)
-        {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            using (Stream s = File.OpenRead(filePath))
-                return IsArchive(s, out type);
-        }
-
-        private 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");
-            }
-            if (ZipArchive.IsZipFile(stream, null))
-                type = ArchiveType.Zip;
-            stream.Seek(0, SeekOrigin.Begin);
-            if (type == null)
-            {
-                if (SevenZipArchive.IsSevenZipFile(stream))
-                    type = ArchiveType.SevenZip;
-                stream.Seek(0, SeekOrigin.Begin);
-            }
-            if (type == null)
-            {
-                if (GZipArchive.IsGZipFile(stream))
-                    type = ArchiveType.GZip;
-                stream.Seek(0, SeekOrigin.Begin);
-            }
-            if (type == null)
-            {
-                if (RarArchive.IsRarFile(stream))
-                    type = ArchiveType.Rar;
-                stream.Seek(0, SeekOrigin.Begin);
-            }
-            if (type == null)
-            {
-                if (TarArchive.IsTarFile(stream))
-                    type = ArchiveType.Tar;
-                stream.Seek(0, SeekOrigin.Begin);
-            }
-            if (type == null) //test multipartzip as it could find zips in other non compressed archive types?
-            {
-                if (ZipArchive.IsZipMulti(stream)) //test the zip (last) file of a multipart zip
-                    type = ArchiveType.Zip;
-                stream.Seek(0, SeekOrigin.Begin);
-            }
-
-            return type != null;
-        }
-
-        /// <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;
-            int i = 1;
-
-            FileInfo? part = RarArchiveVolumeFactory.GetFilePart(i++, part1);
-            if (part != null)
-            {
-                yield return part;
-                while ((part = RarArchiveVolumeFactory.GetFilePart(i++, part1)) != null) //tests split too
-                    yield return part;
-            }
-            else
-            {
-                i = 1;
-                while ((part = ZipArchiveVolumeFactory.GetFilePart(i++, part1)) != null) //tests split too
-                    yield return part;
+                foreach (IArchiveEntry entry in archive.Entries)
+                {
+                    entry.WriteToDirectory(destinationDirectory, options);
+                }
             }
         }
     }

src/SharpCompress/Archives/ArchiveVolumeFactory.cs

@@ -1,29 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Readers;
-using System.Linq;
-using System.Text;
-using SharpCompress.Common.Rar.Headers;
-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/GZip/GZipArchive.cs

@@ -1,10 +1,9 @@
-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;
@@ -19,7 +18,7 @@ namespace SharpCompress.Archives.GZip
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="readerOptions"></param>
-        public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+        public static GZipArchive Open(string filePath, ReaderOptions readerOptions = null)
         {
             filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
@@ -30,34 +29,10 @@ namespace SharpCompress.Archives.GZip
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="readerOptions"></param>
-        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+        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));
-            FileInfo[] 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));
-            Stream[] strms = streams.ToArray();
-            return new GZipArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
+            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
 
         /// <summary>
@@ -65,10 +40,10 @@ namespace SharpCompress.Archives.GZip
         /// </summary>
         /// <param name="stream"></param>
         /// <param name="readerOptions"></param>
-        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        public static GZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
         {
             stream.CheckNotNull(nameof(stream));
-            return new GZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
+            return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
         }
 
         public static GZipArchive Create()
@@ -77,20 +52,20 @@ namespace SharpCompress.Archives.GZip
         }
 
         /// <summary>
-        /// Constructor with a SourceStream able to handle FileInfo and Streams.
+        /// Constructor with a FileInfo object to an existing file.
         /// </summary>
-        /// <param name="srcStream"></param>
+        /// <param name="fileInfo"></param>
         /// <param name="options"></param>
-        internal GZipArchive(SourceStream srcStream)
-            : base(ArchiveType.Tar, srcStream)
+        internal GZipArchive(FileInfo fileInfo, ReaderOptions options)
+            : base(ArchiveType.GZip, fileInfo, options)
         {
         }
 
-        protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream srcStream)
+        protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file)
         {
-            srcStream.LoadAllParts();
-            return srcStream.Streams.Select(a => new GZipVolume(a, ReaderOptions));
+            return new GZipVolume(file, ReaderOptions).AsEnumerable();
         }
+
         public static bool IsGZipFile(string filePath)
         {
             return IsGZipFile(new FileInfo(filePath));
@@ -102,9 +77,10 @@ namespace SharpCompress.Archives.GZip
             {
                 return false;
             }
-
-            using Stream stream = fileInfo.OpenRead();
-            return IsGZipFile(stream);
+            using (Stream stream = fileInfo.OpenRead())
+            {
+                return IsGZipFile(stream);
+            }
         }
 
         public void SaveTo(string filePath)
@@ -123,7 +99,7 @@ namespace SharpCompress.Archives.GZip
         public static bool IsGZipFile(Stream stream)
         {
             // read the header on the first read
-            Span<byte> header = stackalloc byte[10];
+            byte[] header = new byte[10];
 
             // workitem 8501: handle edge case (decompress empty stream)
             if (!stream.ReadFully(header))
@@ -139,6 +115,16 @@ namespace SharpCompress.Archives.GZip
             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)
         {
@@ -175,6 +161,11 @@ namespace SharpCompress.Archives.GZip
             }
         }
 
+        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;

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -15,7 +15,7 @@ namespace SharpCompress.Archives.GZip
         public virtual Stream OpenEntryStream()
         {
             //this is to reset the stream to be read multiple times
-            var part = (GZipFilePart)Parts.Single();
+            var part = Parts.Single() as GZipFilePart;
             if (part.GetRawStream().Position != part.EntryStartPosition)
             {
                 part.GetRawStream().Position = part.EntryStartPosition;

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
@@ -8,7 +6,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Archives.GZip
 {
-    internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
+    internal class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
     {
         private readonly bool closeStream;
         private readonly Stream stream;

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -8,17 +8,22 @@ namespace SharpCompress.Archives
     {
         public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
         {
+            if (archiveEntry.Archive.Type == ArchiveType.Rar && archiveEntry.Archive.IsSolid)
+            {
+                throw new InvalidFormatException("Cannot use Archive random access on SOLID Rar files.");
+            }
+
             if (archiveEntry.IsDirectory)
             {
                 throw new ExtractionException("Entry is a file directory and cannot be extracted.");
             }
 
-            var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+            var streamListener = archiveEntry.Archive as IArchiveExtractionListener;
             streamListener.EnsureEntriesLoaded();
             streamListener.FireEntryExtractionBegin(archiveEntry);
             streamListener.FireFilePartExtractionBegin(archiveEntry.Key, archiveEntry.Size, archiveEntry.CompressedSize);
             var entryStream = archiveEntry.OpenEntryStream();
-            if (entryStream is null)
+            if (entryStream == null)
             {
                 return;
             }
@@ -31,12 +36,12 @@ namespace SharpCompress.Archives
             }
             streamListener.FireEntryExtractionEnd(archiveEntry);
         }
-
+        
         /// <summary>
         /// Extract to specific directory, retaining filename
         /// </summary>
         public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory,
-                                            ExtractionOptions? options = null)
+                                            ExtractionOptions options = null)
         {
             ExtractionMethods.WriteEntryToDirectory(entry, destinationDirectory, options,
                                               entry.WriteToFile);
@@ -45,11 +50,10 @@ namespace SharpCompress.Archives
         /// <summary>
         /// Extract to specific file
         /// </summary>
-        public static void WriteToFile(this IArchiveEntry entry,
-                                       string destinationFileName,
-                                       ExtractionOptions? options = null)
+        public static void WriteToFile(this IArchiveEntry entry, string destinationFileName,
+                                       ExtractionOptions options = null)
         {
-
+            
             ExtractionMethods.WriteEntryToFile(entry, destinationFileName, options,
                                                (x, fm) =>
                                                {

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -9,7 +9,7 @@ namespace SharpCompress.Archives
         /// Extract to specific directory, retaining filename
         /// </summary>
         public static void WriteToDirectory(this IArchive archive, string destinationDirectory,
-                                            ExtractionOptions? options = null)
+                                            ExtractionOptions options = null)
         {
             foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory))
             {

src/SharpCompress/Archives/IWritableArchive.cs

@@ -11,11 +11,5 @@ namespace SharpCompress.Archives
         IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);
 
         void SaveTo(Stream stream, WriterOptions options);
-
-        /// <summary>
-        /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
-        /// </summary>
-        /// <returns>IDisposeable to resume entry rebuilding</returns>
-        IDisposable PauseEntryRebuilding();
     }
 }

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -35,14 +35,11 @@ namespace SharpCompress.Archives
             this IWritableArchive writableArchive,
             string filePath, string searchPattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories)
         {
-            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)

src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs

@@ -3,9 +3,9 @@ using SharpCompress.Common.Rar.Headers;
 
 namespace SharpCompress.Archives.Rar
 {
-    internal sealed class FileInfoRarFilePart : SeekableFilePart
+    internal class FileInfoRarFilePart : SeekableFilePart
     {
-        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string? password, MarkHeader mh, FileHeader fh, FileInfo fi)
+        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string password, MarkHeader mh, FileHeader fh, FileInfo fi)
             : base(mh, fh, volume.Stream, password)
         {
             FileInfo = fi;

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -5,48 +5,49 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
-using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Rar;
 
 namespace SharpCompress.Archives.Rar
 {
-    public class
-        RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
+    public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
     {
         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)
+        {
+        }
+
+        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
+        {
+            return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
+        }
 
         /// <summary>
-        /// Constructor with a SourceStream able to handle FileInfo and Streams.
+        /// Takes multiple seekable Streams for a multi-part archive
         /// </summary>
-        /// <param name="srcStream"></param>
+        /// <param name="streams"></param>
         /// <param name="options"></param>
-        internal RarArchive(SourceStream srcStream)
-            : base(ArchiveType.Rar, srcStream)
+        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);
+            return RarArchiveEntryFactory.GetEntries(this, volumes);
         }
 
-        protected override IEnumerable<RarVolume> LoadVolumes(SourceStream srcStream)
+        protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams)
         {
-            base.SrcStream.LoadAllParts(); //request all streams
-            Stream[] streams = base.SrcStream.Streams.ToArray();
-            if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
-            {
-                base.SrcStream.IsVolumes = true;
-                streams[1].Position = 0;
-                base.SrcStream.Position = 0;
-
-                return srcStream.Streams.Select(a => new StreamRarArchiveVolume(a, ReaderOptions));
-            }
-            else //split mode or single file
-                return new StreamRarArchiveVolume(base.SrcStream, ReaderOptions).AsEnumerable();
+            return RarArchiveVolumeFactory.GetParts(streams, ReaderOptions);
         }
 
         protected override IReader CreateReaderForSolidExtraction()
@@ -64,11 +65,10 @@ namespace SharpCompress.Archives.Rar
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="options"></param>
-        public static RarArchive Open(string filePath, ReaderOptions? options = null)
+        public static RarArchive Open(string filePath, ReaderOptions options = null)
         {
             filePath.CheckNotNullOrEmpty(nameof(filePath));
-            FileInfo fileInfo = new FileInfo(filePath);
-            return new RarArchive(new SourceStream(fileInfo, i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo), options ?? new ReaderOptions()));
+            return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
         }
 
         /// <summary>
@@ -76,10 +76,10 @@ namespace SharpCompress.Archives.Rar
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="options"></param>
-        public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+        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()));
+            return new RarArchive(fileInfo, options ?? new ReaderOptions());
         }
 
         /// <summary>
@@ -87,37 +87,23 @@ namespace SharpCompress.Archives.Rar
         /// </summary>
         /// <param name="stream"></param>
         /// <param name="options"></param>
-        public static RarArchive Open(Stream stream, ReaderOptions? options = null)
+        public static RarArchive Open(Stream stream, ReaderOptions options = null)
         {
             stream.CheckNotNull(nameof(stream));
-            return new RarArchive(new SourceStream(stream, i => null, options ?? new ReaderOptions()));
+            return Open(stream.AsEnumerable(), 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));
-            FileInfo[] 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
+        /// Takes multiple seekable Streams for a multi-part archive
         /// </summary>
         /// <param name="streams"></param>
-        /// <param name="readerOptions"></param>
-        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+        /// <param name="options"></param>
+        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions options = null)
         {
             streams.CheckNotNull(nameof(streams));
-            Stream[] strms = streams.ToArray();
-            return new RarArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
+            return new RarArchive(streams, options ?? new ReaderOptions());
         }
 
-
         public static bool IsRarFile(string filePath)
         {
             return IsRarFile(new FileInfo(filePath));
@@ -134,8 +120,8 @@ namespace SharpCompress.Archives.Rar
                 return IsRarFile(stream);
             }
         }
-
-        public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
+        
+        public static bool IsRarFile(Stream stream, ReaderOptions options = null)
         {
             try
             {

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -6,7 +6,6 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
-using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.Rar
 {
@@ -14,14 +13,11 @@ namespace SharpCompress.Archives.Rar
     {
         private readonly ICollection<RarFilePart> parts;
         private readonly RarArchive archive;
-        private readonly ReaderOptions readerOptions;
 
-        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts, ReaderOptions readerOptions)
+        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts)
         {
             this.parts = parts.ToList();
             this.archive = archive;
-            this.readerOptions = readerOptions;
-            this.IsSolid = this.FileHeader.IsSolid;
         }
 
         public override CompressionType CompressionType => CompressionType.Rar;
@@ -61,26 +57,30 @@ namespace SharpCompress.Archives.Rar
 
         public Stream OpenEntryStream()
         {
+            if (archive.IsSolid)
+            {
+                throw new InvalidOperationException("Use ExtractAllEntries to extract SOLID archives.");
+            }
+
             if (IsRarV3)
             {
                 return new RarStream(archive.UnpackV1.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
             }
-
+            
             return new RarStream(archive.UnpackV2017.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
         }
 
-        public bool IsComplete
-        {
-            get
-            {
-                var headers = parts.Select(x => x.FileHeader);
-                return !headers.First().IsSplitBefore && !headers.Last().IsSplitAfter;
-            }
+        public bool IsComplete 
+        { 
+            get 
+            { 
+                return parts.Select(fp => fp.FileHeader).Any(fh => !fh.IsSplitAfter); 
+            } 
         }
 
         private void CheckIncomplete()
         {
-            if (!readerOptions.DisableCheckIncomplete && !IsComplete)
+            if (!IsComplete)
             {
                 throw new IncompleteArchiveException("ArchiveEntry is incomplete and cannot perform this operation.");
             }

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using SharpCompress.Common.Rar;
-using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.Rar
 {
@@ -37,12 +36,11 @@ namespace SharpCompress.Archives.Rar
         }
 
         internal static IEnumerable<RarArchiveEntry> GetEntries(RarArchive archive,
-                                                                IEnumerable<RarVolume> rarParts,
-                                                                ReaderOptions readerOptions)
+                                                                IEnumerable<RarVolume> rarParts)
         {
             foreach (var groupedParts in GetMatchedFileParts(rarParts))
             {
-                yield return new RarArchiveEntry(archive, groupedParts, readerOptions);
+                yield return new RarArchiveEntry(archive, groupedParts);
             }
         }
     }

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar;
@@ -6,35 +6,137 @@ using SharpCompress.Readers;
 using System.Linq;
 using System.Text;
 using SharpCompress.Common.Rar.Headers;
-using System.Text.RegularExpressions;
 
 namespace SharpCompress.Archives.Rar
 {
     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)
             {
-                //old style - ...rar, .r00, .r01 ...
-                m = Regex.Match(part1.Name, @"^(.*\.r)(ar|[0-9]+)$", RegexOptions.IgnoreCase);
-                if (m.Success)
-                    item = new FileInfo(Path.Combine(part1.DirectoryName!, String.Concat(m.Groups[1].Value, index == 0 ? "ar" : (index - 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'))));
-                else //split .001, .002 ....
-                    return ArchiveVolumeFactory.GetFilePart(index, part1);
+                if (!s.CanRead || !s.CanSeek)
+                {
+                    throw new ArgumentException("Stream is not readable and seekable");
+                }
+                StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, options);
+                yield return part;
             }
+        }
+        
+        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
+        {
+            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
+            yield return part;
 
-            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);
 
-            return null; //no more items
+                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
+                yield return part;
+            }
         }
 
+        private static FileInfo GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart currentFilePart)
+        {
+            if (currentFilePart == null)
+            {
+                return null;
+            }
+            bool oldNumbering = ah.OldNumberingFormat
+                                || currentFilePart.MarkHeader.OldNumberingFormat;
+            if (oldNumbering)
+            {
+                return FindNextFileWithOldNumbering(currentFilePart.FileInfo);
+            }
+            else
+            {
+                return FindNextFileWithNewNumbering(currentFilePart.FileInfo);
+            }
+        }
+
+        private static FileInfo FindNextFileWithOldNumbering(FileInfo currentFileInfo)
+        {
+            // .rar, .r00, .r01, ...
+            string extension = currentFileInfo.Extension;
+
+            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
+            buffer.Append(currentFileInfo.FullName.Substring(0,
+                                                             currentFileInfo.FullName.Length - extension.Length));
+            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) == 0)
+            {
+                buffer.Append(".r00");
+            }
+            else
+            {
+                int num = 0;
+                if (int.TryParse(extension.Substring(2, 2), out num))
+                {
+                    num++;
+                    buffer.Append(".r");
+                    if (num < 10)
+                    {
+                        buffer.Append('0');
+                    }
+                    buffer.Append(num);
+                }
+                else
+                {
+                    ThrowInvalidFileName(currentFileInfo);
+                }
+            }
+            return new FileInfo(buffer.ToString());
+        }
+
+        private static FileInfo FindNextFileWithNewNumbering(FileInfo currentFileInfo)
+        {
+            // part1.rar, part2.rar, ...
+            string extension = currentFileInfo.Extension;
+            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) != 0)
+            {
+                throw new ArgumentException("Invalid extension, expected 'rar': " + currentFileInfo.FullName);
+            }
+            int startIndex = currentFileInfo.FullName.LastIndexOf(".part");
+            if (startIndex < 0)
+            {
+                ThrowInvalidFileName(currentFileInfo);
+            }
+            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
+            buffer.Append(currentFileInfo.FullName, 0, startIndex);
+            int num = 0;
+            string numString = currentFileInfo.FullName.Substring(startIndex + 5,
+                                                                  currentFileInfo.FullName.IndexOf('.', startIndex + 5) -
+                                                                  startIndex - 5);
+            buffer.Append(".part");
+            if (int.TryParse(numString, out num))
+            {
+                num++;
+                for (int i = 0; i < numString.Length - num.ToString().Length; i++)
+                {
+                    buffer.Append('0');
+                }
+                buffer.Append(num);
+            }
+            else
+            {
+                ThrowInvalidFileName(currentFileInfo);
+            }
+            buffer.Append(".rar");
+            return new FileInfo(buffer.ToString());
+        }
+
+        private static void ThrowInvalidFileName(FileInfo fileInfo)
+        {
+            throw new ArgumentException("Filename invalid or next archive could not be found:"
+                                        + fileInfo.FullName);
+        }
     }
-}
+}

src/SharpCompress/Archives/Rar/SeekableFilePart.cs

@@ -7,9 +7,9 @@ namespace SharpCompress.Archives.Rar
     internal class SeekableFilePart : RarFilePart
     {
         private readonly Stream stream;
-        private readonly string? password;
+        private readonly string password;
 
-        internal SeekableFilePart(MarkHeader mh, FileHeader fh, Stream stream, string? password)
+        internal SeekableFilePart(MarkHeader mh, FileHeader fh, Stream stream, string password)
             : base(mh, fh)
         {
             this.stream = stream;
@@ -21,7 +21,7 @@ namespace SharpCompress.Archives.Rar
             stream.Position = FileHeader.DataStartPosition;
             if (FileHeader.R4Salt != null)
             {
-                return new RarCryptoWrapper(stream, password!, FileHeader.R4Salt);
+                return new RarCryptoWrapper(stream, password, FileHeader.R4Salt);
             }
             return stream;
         }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -34,33 +32,8 @@ namespace SharpCompress.Archives.SevenZip
         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()));
+            return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
-
-        /// <summary>
-        /// Constructor with all file parts passed in
-        /// </summary>
-        /// <param name="fileInfos"></param>
-        /// <param name="readerOptions"></param>
-        public static SevenZipArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions readerOptions = null)
-        {
-            fileInfos.CheckNotNull(nameof(fileInfos));
-            FileInfo[] files = fileInfos.ToArray();
-            return new SevenZipArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
-        }
-
-        /// <summary>
-        /// Constructor with all stream parts passed in
-        /// </summary>
-        /// <param name="streams"></param>
-        /// <param name="readerOptions"></param>
-        public static SevenZipArchive Open(IEnumerable<Stream> streams, ReaderOptions readerOptions = null)
-        {
-            streams.CheckNotNull(nameof(streams));
-            Stream[] strms = streams.ToArray();
-            return new SevenZipArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
-        }
-
         /// <summary>
         /// Takes a seekable Stream as a source
         /// </summary>
@@ -69,23 +42,17 @@ namespace SharpCompress.Archives.SevenZip
         public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
         {
             stream.CheckNotNull("stream");
-            return new SevenZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
+            return new SevenZipArchive(stream, readerOptions ?? new ReaderOptions());
         }
 
-        /// <summary>
-        /// Constructor with a SourceStream able to handle FileInfo and Streams.
-        /// </summary>
-        /// <param name="srcStream"></param>
-        /// <param name="options"></param>
-        internal SevenZipArchive(SourceStream srcStream)
-            : base(ArchiveType.SevenZip, srcStream)
+        internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
+            : base(ArchiveType.SevenZip, fileInfo, readerOptions)
         {
         }
 
-        protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream srcStream)
+        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
         {
-            base.SrcStream.LoadAllParts(); //request all streams
-            return new SevenZipVolume(srcStream, ReaderOptions).AsEnumerable(); //simple single volume or split, multivolume not supported
+            return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
         }
 
         public static bool IsSevenZipFile(string filePath)
@@ -105,37 +72,43 @@ namespace SharpCompress.Archives.SevenZip
             }
         }
 
+        internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
+        {
+        }
+
         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);
-            var entries = new SevenZipArchiveEntry[database._files.Count];
             for (int 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));
+                yield return 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)
-                {
-                    entry.IsSolid = isSolid;
-                    isSolid = true; //mark others in this group as solid - same as rar behaviour.
-                }
-            }
-
-            return entries;
         }
 
         private void LoadFactory(Stream stream)
         {
-            if (database is null)
+            if (database == null)
             {
                 stream.Position = 0;
                 var reader = new ArchiveReader();
@@ -156,13 +129,13 @@ namespace SharpCompress.Archives.SevenZip
             }
         }
 
-        private static ReadOnlySpan<byte> SIGNATURE => new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
+        private static readonly byte[] SIGNATURE = {(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);
+            byte[] signatureBytes = reader.ReadBytes(6);
+            return signatureBytes.BinaryEquals(SIGNATURE);
         }
 
         protected override IReader CreateReaderForSolidExtraction()
@@ -181,7 +154,7 @@ namespace SharpCompress.Archives.SevenZip
             }
         }
 
-        private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+        private class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
         {
             private readonly SevenZipArchive archive;
             private CFolder currentFolder;
@@ -207,7 +180,7 @@ namespace SharpCompress.Archives.SevenZip
                 foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
                 {
                     currentFolder = group.Key;
-                    if (group.Key is null)
+                    if (group.Key == null)
                     {
                         currentStream = Stream.Null;
                     }
@@ -228,7 +201,7 @@ namespace SharpCompress.Archives.SevenZip
                 return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
             }
         }
-
+        
         private class PasswordProvider : IPasswordProvider
         {
             private readonly string _password;
@@ -236,6 +209,7 @@ namespace SharpCompress.Archives.SevenZip
             public PasswordProvider(string password)
             {
                 _password = password;
+
             }
 
             public string CryptoGetTextPassword()

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -20,7 +20,7 @@ namespace SharpCompress.Archives.Tar
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="readerOptions"></param>
-        public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
+        public static TarArchive Open(string filePath, ReaderOptions readerOptions = null)
         {
             filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
@@ -31,34 +31,10 @@ namespace SharpCompress.Archives.Tar
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="readerOptions"></param>
-        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+        public static TarArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
         {
             fileInfo.CheckNotNull(nameof(fileInfo));
-            return new TarArchive(new SourceStream(fileInfo, i => ArchiveVolumeFactory.GetFilePart(i, fileInfo), readerOptions ?? new ReaderOptions()));
-        }
-
-        /// <summary>
-        /// Constructor with all file parts passed in
-        /// </summary>
-        /// <param name="fileInfos"></param>
-        /// <param name="readerOptions"></param>
-        public static TarArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? readerOptions = null)
-        {
-            fileInfos.CheckNotNull(nameof(fileInfos));
-            FileInfo[] files = fileInfos.ToArray();
-            return new TarArchive(new SourceStream(files[0], i => i < files.Length ? files[i] : null, readerOptions ?? new ReaderOptions()));
-        }
-
-        /// <summary>
-        /// Constructor with all stream parts passed in
-        /// </summary>
-        /// <param name="streams"></param>
-        /// <param name="readerOptions"></param>
-        public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
-        {
-            streams.CheckNotNull(nameof(streams));
-            Stream[] strms = streams.ToArray();
-            return new TarArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
+            return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
 
         /// <summary>
@@ -66,10 +42,10 @@ namespace SharpCompress.Archives.Tar
         /// </summary>
         /// <param name="stream"></param>
         /// <param name="readerOptions"></param>
-        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        public static TarArchive Open(Stream stream, ReaderOptions readerOptions = null)
         {
             stream.CheckNotNull(nameof(stream));
-            return new TarArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
+            return new TarArchive(stream, readerOptions ?? new ReaderOptions());
         }
 
         public static bool IsTarFile(string filePath)
@@ -103,20 +79,29 @@ namespace SharpCompress.Archives.Tar
             }
             return false;
         }
-
-        protected override IEnumerable<TarVolume> LoadVolumes(SourceStream srcStream)
+        
+        /// <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)
         {
-            base.SrcStream.LoadAllParts(); //request all streams
-            return new TarVolume(srcStream, ReaderOptions).AsEnumerable(); //simple single volume or split, multivolume not supported
+        }
+
+        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
+        {
+            return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
         }
 
         /// <summary>
-        /// Constructor with a SourceStream able to handle FileInfo and Streams.
+        /// Takes multiple seekable Streams for a multi-part archive
         /// </summary>
-        /// <param name="srcStream"></param>
-        /// <param name="options"></param>
-        internal TarArchive(SourceStream srcStream)
-            : base(ArchiveType.Tar, srcStream)
+        /// <param name="stream"></param>
+        /// <param name="readerOptions"></param>
+        internal TarArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.Tar, stream, readerOptions)
         {
         }
 
@@ -125,11 +110,16 @@ namespace SharpCompress.Archives.Tar
         {
         }
 
+        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
+        {
+            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))
+            TarHeader previousHeader = null;
+            foreach (TarHeader header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
             {
                 if (header != null)
                 {
@@ -148,7 +138,7 @@ namespace SharpCompress.Archives.Tar
 
                             using (var entryStream = entry.OpenEntryStream())
                             {
-                                using (var memoryStream = new MemoryStream())
+                                using (var memoryStream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream())
                                 {
                                     entryStream.TransferTo(memoryStream);
                                     memoryStream.Position = 0;

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
@@ -8,7 +6,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Archives.Tar
 {
-    internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
+    internal class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
     {
         private readonly bool closeStream;
         private readonly Stream stream;

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,7 +6,6 @@ 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;
@@ -16,33 +15,20 @@ namespace SharpCompress.Archives.Zip
 {
     public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     {
-#nullable disable
         private readonly SeekableZipHeaderFactory headerFactory;
-#nullable enable
 
         /// <summary>
         /// Gets or sets the compression level applied to files added to the archive,
         /// if the compression method is set to deflate
         /// </summary>
         public CompressionLevel DeflateCompressionLevel { get; set; }
-
-        /// <summary>
-        /// Constructor with a SourceStream able to handle FileInfo and Streams.
-        /// </summary>
-        /// <param name="srcStream"></param>
-        /// <param name="options"></param>
-        internal ZipArchive(SourceStream srcStream)
-            : base(ArchiveType.Zip, srcStream)
-        {
-            headerFactory = new SeekableZipHeaderFactory(srcStream.ReaderOptions.Password, srcStream.ReaderOptions.ArchiveEncoding);
-        }
-
+        
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="readerOptions"></param>
-        public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+        public static ZipArchive Open(string filePath, ReaderOptions readerOptions = null)
         {
             filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
@@ -53,34 +39,10 @@ namespace SharpCompress.Archives.Zip
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="readerOptions"></param>
-        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+        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));
-            FileInfo[] 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));
-            Stream[] strms = streams.ToArray();
-            return new ZipArchive(new SourceStream(strms[0], i => i < strms.Length ? strms[i] : null, readerOptions ?? new ReaderOptions()));
+            return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
 
         /// <summary>
@@ -88,18 +50,18 @@ namespace SharpCompress.Archives.Zip
         /// </summary>
         /// <param name="stream"></param>
         /// <param name="readerOptions"></param>
-        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        public static ZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
         {
             stream.CheckNotNull(nameof(stream));
-            return new ZipArchive(new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions()));
+            return new ZipArchive(stream, readerOptions ?? new ReaderOptions());
         }
-
-        public static bool IsZipFile(string filePath, string? password = null)
+        
+        public static bool IsZipFile(string filePath, string password = null)
         {
             return IsZipFile(new FileInfo(filePath), password);
         }
 
-        public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+        public static bool IsZipFile(FileInfo fileInfo, string password = null)
         {
             if (!fileInfo.Exists)
             {
@@ -111,13 +73,14 @@ namespace SharpCompress.Archives.Zip
             }
         }
 
-        public static bool IsZipFile(Stream stream, string? password = null)
+        public static bool IsZipFile(Stream stream, string password = null)
         {
             StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
             try
             {
-                ZipHeader? header = headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-                if (header is null)
+                ZipHeader header =
+                    headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+                if (header == null)
                 {
                     return false;
                 }
@@ -132,62 +95,21 @@ namespace SharpCompress.Archives.Zip
                 return false;
             }
         }
-
-        public static bool IsZipMulti(Stream stream, string? password = null)
+        
+        /// <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)
         {
-            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
-            try
-            {
-                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
-                    {
-                        SeekableZipHeaderFactory 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;
-            }
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
         }
 
-        protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream srcStream)
+        protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
         {
-            base.SrcStream.LoadAllParts(); //request all streams
-            base.SrcStream.Position = 0;
-
-            List<Stream> streams = base.SrcStream.Streams.ToList();
-            if (streams.Count > 1) //test part 2 - true = multipart not split
-            {
-                streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
-                bool isZip = IsZipFile(streams[1], ReaderOptions.Password);
-                streams[1].Position -= 4;
-                if (isZip)
-                {
-                    base.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));
-                }
-            }
-
-            //split mode or single file
-            return new ZipVolume(base.SrcStream, ReaderOptions).AsEnumerable();
+            return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
         }
 
         internal ZipArchive()
@@ -195,35 +117,46 @@ namespace SharpCompress.Archives.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 vols = volumes.ToArray();
-            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(vols.Last().Stream))
+            var volume = volumes.Single();
+            Stream stream = volume.Stream;
+            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(stream))
             {
                 if (h != null)
                 {
                     switch (h.ZipHeaderType)
                     {
                         case ZipHeaderType.DirectoryEntry:
-                        {
-                            DirectoryEntryHeader 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 });
+                                yield return new ZipArchiveEntry(this,
+                                                                 new SeekableZipFilePart(headerFactory,
+                                                                                         h as DirectoryEntryHeader,
+                                                                                         stream));
                             }
-                            else
-                                s = vols[deh.DiskNumberStart].Stream;
-                            yield return new ZipArchiveEntry(this, new SeekableZipFilePart(headerFactory, deh, s));
-                        }
-                        break;
+                            break;
                         case ZipHeaderType.DirectoryEnd:
-                        {
-                            byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                            volumes.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                            yield break;
-                        }
+                            {
+                                byte[] bytes = (h as DirectoryEndHeader).Comment;
+                                volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                                yield break;
+                            }
                     }
                 }
             }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -6,7 +6,7 @@ namespace SharpCompress.Archives.Zip
 {
     public class ZipArchiveEntry : ZipEntry, IArchiveEntry
     {
-        internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
+        internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart part)
             : base(part)
         {
             Archive = archive;
@@ -25,6 +25,6 @@ namespace SharpCompress.Archives.Zip
 
         #endregion
 
-        public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
+        public string Comment => (Parts.Single() as SeekableZipFilePart).Comment;
     }
 }

src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs

@@ -1,34 +0,0 @@
-using System;
-using System.Collections.Generic;
-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.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/AssemblyInfo.cs

@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 [assembly: AssemblyTitle("SharpCompress")]
 [assembly: AssemblyProduct("SharpCompress")]
 [assembly: InternalsVisibleTo("SharpCompress.Test" + SharpCompress.AssemblyInfo.PublicKeySuffix)]
+[assembly: InternalsVisibleTo("SharpCompress.Test.Portable"  + SharpCompress.AssemblyInfo.PublicKeySuffix)]
 [assembly: CLSCompliant(true)]
 
 namespace SharpCompress

src/SharpCompress/Common/ArchiveEncoding.cs

@@ -18,30 +18,24 @@ namespace SharpCompress.Common
         /// <summary>
         /// Set this encoding when you want to force it for all encoding operations.
         /// </summary>
-        public Encoding? Forced { get; set; }
+        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 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;
+            Default = Encoding.GetEncoding(437);
+            Password = Encoding.GetEncoding(437);
         }
 
-#if !NETFRAMEWORK
         static ArchiveEncoding()
         {
             Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
         }
-#endif
 
         public string Decode(byte[] bytes)
         {
@@ -73,4 +67,4 @@ namespace SharpCompress.Common
             return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
         }
     }
-}
+}

src/SharpCompress/Common/CompressedBytesReadEventArgs.cs

@@ -2,22 +2,16 @@
 
 namespace SharpCompress.Common
 {
-    public sealed class CompressedBytesReadEventArgs : EventArgs
+    public class CompressedBytesReadEventArgs : EventArgs
     {
-        public CompressedBytesReadEventArgs(long compressedBytesRead, long currentFilePartCompressedBytesRead)
-        {
-            CompressedBytesRead = compressedBytesRead;
-            CurrentFilePartCompressedBytesRead = currentFilePartCompressedBytesRead;
-        }
-
         /// <summary>
         /// Compressed bytes read for the current entry
         /// </summary>
-        public long CompressedBytesRead { get; }
+        public long CompressedBytesRead { get; internal set; }
 
         /// <summary>
         /// Current file part read for Multipart files (e.g. Rar)
         /// </summary>
-        public long CurrentFilePartCompressedBytesRead { get; }
+        public long CurrentFilePartCompressedBytesRead { get; internal set; }
     }
 }

src/SharpCompress/Common/Entry.cs

@@ -18,7 +18,7 @@ namespace SharpCompress.Common
         /// <summary>
         /// The target of a symlink entry internal to the Archive. Will be null if not a symlink.
         /// </summary>
-        public abstract string? LinkTarget { get; }
+        public abstract string LinkTarget { get; }
 
         /// <summary>
         /// The compressed file size
@@ -71,11 +71,13 @@ namespace SharpCompress.Common
         public abstract bool IsSplitAfter { get; }
 
         /// <inheritdoc/>
-        public override string ToString() => Key;
+        public override string ToString()
+        {
+            return Key;
+        }
 
         internal abstract IEnumerable<FilePart> Parts { get; }
-
-        public bool IsSolid { get; set; }
+        internal bool IsSolid { get; set; }
 
         internal virtual void Close()
         {

src/SharpCompress/Common/EntryStream.cs

@@ -47,8 +47,7 @@ namespace SharpCompress.Common
 
         public override bool CanWrite => false;
 
-        public override void Flush()
-        {
+        public override void Flush() {
         }
 
         public override long Length => _stream.Length;

src/SharpCompress/Common/ExtractionMethods.cs

@@ -8,39 +8,28 @@ namespace SharpCompress.Common
         /// <summary>
         /// Extract to specific directory, retaining filename
         /// </summary>
-        public static void WriteEntryToDirectory(IEntry entry,
-                                                 string destinationDirectory,
-                                                 ExtractionOptions? options,
-                                                 Action<string, ExtractionOptions?> write)
+        public static void WriteEntryToDirectory(IEntry entry, string destinationDirectory,
+                                                 ExtractionOptions options, Action<string, ExtractionOptions> write)
         {
             string destinationFileName;
+            string file = Path.GetFileName(entry.Key);
             string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
 
-            //check for trailing slash.
-            if (fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1] != Path.DirectorySeparatorChar)
-            {
-                fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
-            }
+            options = options ?? new ExtractionOptions()
+                                 {
+                                     Overwrite = true
+                                 };
 
-            if (!Directory.Exists(fullDestinationDirectoryPath))
-            {
-                throw new ExtractionException($"Directory does not exist to extract to: {fullDestinationDirectoryPath}");
-            }
-
-            options ??= new ExtractionOptions()
-            {
-                Overwrite = true
-            };
-
-            string file = Path.GetFileName(entry.Key);
             if (options.ExtractFullPath)
             {
-                string folder = Path.GetDirectoryName(entry.Key)!;
-                string destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+                string folder = Path.GetDirectoryName(entry.Key);
+                string destdir = Path.GetFullPath(
+                                                  Path.Combine(fullDestinationDirectoryPath, folder)
+                                                 );
 
                 if (!Directory.Exists(destdir))
                 {
-                    if (!destdir.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
+                    if (!destdir.StartsWith(fullDestinationDirectoryPath))
                     {
                         throw new ExtractionException("Entry is trying to create a directory outside of the destination directory.");
                     }
@@ -50,7 +39,7 @@ namespace SharpCompress.Common
                 destinationFileName = Path.Combine(destdir, file);
             }
             else
-            {
+            {        
                 destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
 
             }
@@ -59,7 +48,7 @@ namespace SharpCompress.Common
             {
                 destinationFileName = Path.GetFullPath(destinationFileName);
 
-                if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, StringComparison.Ordinal))
+                if (!destinationFileName.StartsWith(fullDestinationDirectoryPath))
                 {
                     throw new ExtractionException("Entry is trying to write a file outside of the destination directory.");
                 }
@@ -70,14 +59,14 @@ namespace SharpCompress.Common
                 Directory.CreateDirectory(destinationFileName);
             }
         }
-
+        
         public static void WriteEntryToFile(IEntry entry, string destinationFileName,
-                                            ExtractionOptions? options,
+                                            ExtractionOptions options,
                                             Action<string, FileMode> openAndWrite)
         {
             if (entry.LinkTarget != null)
             {
-                if (options?.WriteSymbolicLink is null)
+                if (null == options.WriteSymbolicLink)
                 {
                     throw new ExtractionException("Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null");
                 }
@@ -86,10 +75,10 @@ namespace SharpCompress.Common
             else
             {
                 FileMode fm = FileMode.Create;
-                options ??= new ExtractionOptions()
-                {
-                    Overwrite = true
-                };
+                options = options ?? new ExtractionOptions()
+                                     {
+                                         Overwrite = true
+                                     };
 
                 if (!options.Overwrite)
                 {

src/SharpCompress/Common/ExtractionOptions.cs

@@ -1,13 +1,11 @@
-using System;
-
-namespace SharpCompress.Common
+namespace SharpCompress.Common
 {
     public class ExtractionOptions
     {
         /// <summary>
         /// overwrite target if it exists
         /// </summary>
-        public bool Overwrite { get; set; }
+        public bool Overwrite  {get; set; }
 
         /// <summary>
         /// extract with internal directory structure
@@ -31,10 +29,6 @@ namespace SharpCompress.Common
         /// </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");
-            };
+        public SymbolicLinkWriterDelegate WriteSymbolicLink;
     }
 }

src/SharpCompress/Common/FilePart.cs

@@ -14,7 +14,7 @@ namespace SharpCompress.Common
         internal abstract string FilePartName { get; }
 
         internal abstract Stream GetCompressedStream();
-        internal abstract Stream? GetRawStream();
+        internal abstract Stream GetRawStream();
         internal bool Skipped { get; set; }
     }
 }

src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs

@@ -2,28 +2,21 @@
 
 namespace SharpCompress.Common
 {
-    public sealed class FilePartExtractionBeginEventArgs : EventArgs
+    public class FilePartExtractionBeginEventArgs : EventArgs
     {
-        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; }
+        public string Name { get; internal set; }
 
         /// <summary>
         /// Uncompressed size of the current entry in the part
         /// </summary>
-        public long Size { get; }
+        public long Size { get; internal set; }
 
         /// <summary>
         /// Compressed size of the current entry in the part
         /// </summary>
-        public long CompressedSize { get; }
+        public long CompressedSize { get; internal set; }
     }
 }

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
 
 namespace SharpCompress.Common.GZip
 {
@@ -15,15 +16,15 @@ namespace SharpCompress.Common.GZip
 
         public override CompressionType CompressionType => CompressionType.GZip;
 
-        public override long Crc => _filePart.Crc ?? 0;
+        public override long Crc => 0;
 
         public override string Key => _filePart.FilePartName;
 
-        public override string? LinkTarget => null;
+        public override string LinkTarget => null;
 
         public override long CompressedSize => 0;
 
-        public override long Size => _filePart.UncompressedSize ?? 0;
+        public override long Size => 0;
 
         public override DateTime? LastModifiedTime => _filePart.DateModified;
 

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -1,40 +1,32 @@
 using System;
-using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
+using SharpCompress.Converters;
+using System.Text;
 
 namespace SharpCompress.Common.GZip
 {
-    internal sealed class GZipFilePart : FilePart
+    internal class GZipFilePart : FilePart
     {
-        private string? _name;
+        private string _name;
         private readonly Stream _stream;
 
         internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
-            : base(archiveEncoding)
+        : base(archiveEncoding)
         {
-            _stream = stream;
-            ReadAndValidateGzipHeader();
-            if (stream.CanSeek)
-            {
-                long position = stream.Position;
-                stream.Position = stream.Length - 8;
-                ReadTrailer();
-                stream.Position = position;
-            }
+            ReadAndValidateGzipHeader(stream);
             EntryStartPosition = stream.Position;
+            _stream = stream;
         }
 
         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 string FilePartName => _name;
 
         internal override Stream GetCompressedStream()
         {
@@ -46,21 +38,11 @@ namespace SharpCompress.Common.GZip
             return _stream;
         }
 
-        private void ReadTrailer()
-        {
-            // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-            Span<byte> trailer = stackalloc byte[8];
-            int n = _stream.Read(trailer);
-
-            Crc = BinaryPrimitives.ReadInt32LittleEndian(trailer);
-            UncompressedSize = BinaryPrimitives.ReadInt32LittleEndian(trailer.Slice(4));
-        }
-
-        private void ReadAndValidateGzipHeader()
+        private void ReadAndValidateGzipHeader(Stream stream)
         {
             // read the header on the first read
-            Span<byte> header = stackalloc byte[10];
-            int n = _stream.Read(header);
+            byte[] header = new byte[10];
+            int n = stream.Read(header, 0, header.Length);
 
             // workitem 8501: handle edge case (decompress empty stream)
             if (n == 0)
@@ -78,17 +60,17 @@ namespace SharpCompress.Common.GZip
                 throw new ZlibException("Bad GZIP header.");
             }
 
-            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
+            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 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
+                n = stream.Read(header, 0, 2); // 2-byte length field
 
-                short extraLength = (short)(header[0] + header[1] * 256);
+                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
                 byte[] extra = new byte[extraLength];
-
-                if (!_stream.ReadFully(extra))
+                
+                if (!stream.ReadFully(extra))
                 {
                     throw new ZlibException("Unexpected end-of-file reading GZIP header.");
                 }
@@ -96,27 +78,27 @@ namespace SharpCompress.Common.GZip
             }
             if ((header[3] & 0x08) == 0x08)
             {
-                _name = ReadZeroTerminatedString(_stream);
+                _name = ReadZeroTerminatedString(stream);
             }
             if ((header[3] & 0x10) == 0x010)
             {
-                ReadZeroTerminatedString(_stream);
+                ReadZeroTerminatedString(stream);
             }
             if ((header[3] & 0x02) == 0x02)
             {
-                _stream.ReadByte(); // CRC16, ignore
+                stream.ReadByte(); // CRC16, ignore
             }
         }
 
         private string ReadZeroTerminatedString(Stream stream)
         {
-            Span<byte> buf1 = stackalloc byte[1];
+            byte[] buf1 = new byte[1];
             var list = new List<byte>();
             bool done = false;
             do
             {
                 // workitem 7740
-                int n = stream.Read(buf1);
+                int n = stream.Read(buf1, 0, 1);
                 if (n != 1)
                 {
                     throw new ZlibException("Unexpected EOF reading GZIP header.");
@@ -135,4 +117,4 @@ namespace SharpCompress.Common.GZip
             return ArchiveEncoding.Decode(buffer);
         }
     }
-}
+}

src/SharpCompress/Common/IEntry.Extensions.cs

@@ -1,4 +1,5 @@
 using System.IO;
+using SharpCompress.Readers;
 
 namespace SharpCompress.Common
 {

src/SharpCompress/Common/IEntry.cs

@@ -10,11 +10,10 @@ namespace SharpCompress.Common
         long Crc { get; }
         DateTime? CreatedTime { get; }
         string Key { get; }
-        string? LinkTarget { get; }
+        string LinkTarget { get; }
         bool IsDirectory { get; }
         bool IsEncrypted { get; }
         bool IsSplitAfter { get; }
-        bool IsSolid { get; }
         DateTime? LastAccessedTime { get; }
         DateTime? LastModifiedTime { get; }
         long Size { get; }

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

@@ -4,13 +4,11 @@ namespace SharpCompress.Common.Rar.Headers
 {
     internal class AvHeader : RarHeader
     {
-        public AvHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.Av)
+        public AvHeader(RarHeader header, RarCrcBinaryReader reader) 
+            : base(header, reader, HeaderType.Av) 
         {
-            if (IsRar5)
-            {
+            if (IsRar5) 
                 throw new InvalidFormatException("unexpected rar5 record");
-            }
         }
 
         protected override void ReadFinish(MarkingBinaryReader reader)

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

@@ -1,12 +1,10 @@
-#nullable disable
-
-using SharpCompress.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers
 {
     internal class ArchiveCryptHeader : RarHeader
     {
-
+        
         private const int CRYPT_VERSION = 0; // Supported encryption version.
         private const int SIZE_SALT50 = 16;
         private const int SIZE_SALT30 = 8;
@@ -15,14 +13,14 @@ namespace SharpCompress.Common.Rar.Headers
         private const int SIZE_PSWCHECK_CSUM = 4;
         private const int CRYPT5_KDF_LG2_COUNT = 15; // LOG2 of PDKDF2 iteration count.
         private const int CRYPT5_KDF_LG2_COUNT_MAX = 24; // LOG2 of maximum accepted iteration count.
-
-
+        
+        
         private bool _usePswCheck;
         private uint _lg2Count; // Log2 of PBKDF2 repetition count.
         private byte[] _salt;
         private byte[] _pswCheck;
         private byte[] _pswCheckCsm;
-
+        
         public ArchiveCryptHeader(RarHeader header, RarCrcBinaryReader reader)
             : base(header, reader, HeaderType.Crypt)
         {
@@ -35,12 +33,12 @@ namespace SharpCompress.Common.Rar.Headers
             {
                 //error?
                 return;
-            }
+            } 
             var encryptionFlags = reader.ReadRarVIntUInt32();
             _usePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
             _lg2Count = reader.ReadRarVIntByte(1);
 
-
+            
             //UsePswCheck = HasHeaderFlag(EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
             if (_lg2Count > CRYPT5_KDF_LG2_COUNT_MAX)
             {

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

@@ -2,16 +2,16 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers
 {
-    internal sealed class ArchiveHeader : RarHeader
+    internal class ArchiveHeader : RarHeader
     {
-        public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.Archive)
+        public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader) 
+            : base(header, reader, HeaderType.Archive) 
         {
         }
 
         protected override void ReadFinish(MarkingBinaryReader reader)
         {
-            if (IsRar5)
+            if (IsRar5) 
             {
                 Flags = reader.ReadRarVIntUInt16();
                 if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
@@ -22,8 +22,8 @@ namespace SharpCompress.Common.Rar.Headers
                 //if (ExtraSize != 0) {
                 //    ReadLocator(reader);
                 //}
-            }
-            else
+            } 
+            else 
             {
                 Flags = HeaderFlags;
                 HighPosAv = reader.ReadInt16();
@@ -35,33 +35,26 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        private void ReadLocator(MarkingBinaryReader reader)
-        {
+        private void ReadLocator(MarkingBinaryReader reader) {
             var size = reader.ReadRarVIntUInt16();
             var type = reader.ReadRarVIntUInt16();
-            if (type != 1)
-            {
-                throw new InvalidFormatException("expected locator record");
-            }
-
+            if (type != 1) throw new InvalidFormatException("expected locator record");
             var flags = reader.ReadRarVIntUInt16();
             const ushort hasQuickOpenOffset = 0x01;
             const ushort hasRecoveryOffset = 0x02;
             ulong quickOpenOffset = 0;
-            if ((flags & hasQuickOpenOffset) == hasQuickOpenOffset)
-            {
+            if ((flags & hasQuickOpenOffset) == hasQuickOpenOffset) { 
                 quickOpenOffset = reader.ReadRarVInt();
             }
             ulong recoveryOffset = 0;
-            if ((flags & hasRecoveryOffset) == hasRecoveryOffset)
-            {
+            if ((flags & hasRecoveryOffset) == hasRecoveryOffset) { 
                 recoveryOffset = reader.ReadRarVInt();
             }
         }
 
-        private ushort Flags { get; set; }
+        private ushort Flags  { get; set; }
 
-        private bool HasFlag(ushort flag)
+        private bool HasFlag(ushort flag) 
         {
             return (Flags & flag) == flag;
         }
@@ -81,7 +74,7 @@ namespace SharpCompress.Common.Rar.Headers
         public bool IsVolume => HasFlag(IsRar5 ? ArchiveFlagsV5.VOLUME : ArchiveFlagsV4.VOLUME);
 
         // RAR5: Volume number field is present. True for all volumes except first.
-        public bool IsFirstVolume => IsRar5 ? VolumeNumber is null : HasFlag(ArchiveFlagsV4.FIRST_VOLUME);
+        public bool IsFirstVolume => IsRar5 ? VolumeNumber == null : HasFlag(ArchiveFlagsV4.FIRST_VOLUME);
 
         public bool IsSolid => HasFlag(IsRar5 ? ArchiveFlagsV5.SOLID : ArchiveFlagsV4.SOLID);
     }

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

@@ -5,12 +5,9 @@ namespace SharpCompress.Common.Rar.Headers
     internal class CommentHeader : RarHeader
     {
         protected CommentHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.Comment)
-        {
-            if (IsRar5)
-            {
-                throw new InvalidFormatException("unexpected rar5 record");
-            }
+            : base(header, reader, HeaderType.Comment) 
+        { 
+            if (IsRar5) throw new InvalidFormatException("unexpected rar5 record");
         }
 
         protected override void ReadFinish(MarkingBinaryReader reader)

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

@@ -4,14 +4,14 @@ namespace SharpCompress.Common.Rar.Headers
 {
     internal class EndArchiveHeader : RarHeader
     {
-        public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.EndArchive)
+        public EndArchiveHeader(RarHeader header, RarCrcBinaryReader reader) 
+            : base(header, reader, HeaderType.EndArchive) 
         {
         }
 
         protected override void ReadFinish(MarkingBinaryReader reader)
         {
-            if (IsRar5)
+            if (IsRar5) 
             {
                 Flags = reader.ReadRarVIntUInt16();
             }
@@ -31,7 +31,7 @@ namespace SharpCompress.Common.Rar.Headers
 
         private ushort Flags { get; set; }
 
-        private bool HasFlag(ushort flag)
+        private bool HasFlag(ushort flag) 
         {
             return (Flags & flag) == flag;
         }

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

@@ -1,5 +1,3 @@
-#nullable disable
-
 #if !Rar2017_64bit
 using nint = System.Int32;
 using nuint = System.UInt32;
@@ -21,18 +19,18 @@ namespace SharpCompress.Common.Rar.Headers
     {
         private uint _fileCrc;
 
-        public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
-            : base(header, reader, headerType)
+        public FileHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType) 
+            : base(header, reader, headerType) 
         {
         }
 
-        protected override void ReadFinish(MarkingBinaryReader reader)
+        protected override void ReadFinish(MarkingBinaryReader reader) 
         {
-            if (IsRar5)
+            if (IsRar5) 
             {
                 ReadFromReaderV5(reader);
-            }
-            else
+            } 
+            else 
             {
                 ReadFromReaderV4(reader);
             }
@@ -49,13 +47,11 @@ namespace SharpCompress.Common.Rar.Headers
 
             FileAttributes = reader.ReadRarVIntUInt32();
 
-            if (HasFlag(FileFlagsV5.HAS_MOD_TIME))
-            {
+            if (HasFlag(FileFlagsV5.HAS_MOD_TIME)) {
                 FileLastModifiedTime = Utility.UnixTimeToDateTime(reader.ReadUInt32());
             }
 
-            if (HasFlag(FileFlagsV5.HAS_CRC32))
-            {
+            if (HasFlag(FileFlagsV5.HAS_CRC32)) {
                 FileCrc = reader.ReadUInt32();
             }
 
@@ -67,7 +63,7 @@ namespace SharpCompress.Common.Rar.Headers
             // but it was already used in RAR 1.5 and Unpack needs to distinguish
             // them.
             CompressionAlgorithm = (byte)((compressionInfo & 0x3f) + 50);
-
+            
             // 7th bit (0x0040) defines the solid flag. If it is set, RAR continues to use the compression dictionary left after processing preceding files. 
             // It can be set only for file headers and is never set for service headers.
             IsSolid = (compressionInfo & 0x40) == 0x40;
@@ -76,7 +72,7 @@ namespace SharpCompress.Common.Rar.Headers
             CompressionMethod = (byte)((compressionInfo >> 7) & 0x7);
 
             // Bits 11 - 14 (0x3c00) define the minimum size of dictionary size required to extract data. Value 0 means 128 KB, 1 - 256 KB, ..., 14 - 2048 MB, 15 - 4096 MB.
-            WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo >> 10) & 0xf);
+            WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo>>10) & 0xf);
 
             HostOs = reader.ReadRarVIntByte();
 
@@ -103,20 +99,18 @@ namespace SharpCompress.Common.Rar.Headers
             FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
 
             // extra size seems to be redudant since we know the total header size
-            if (ExtraSize != RemainingHeaderBytes(reader))
+            if (ExtraSize != RemainingHeaderBytes(reader)) 
             {
                 throw new InvalidFormatException("rar5 header size / extra size inconsistency");
             }
 
             isEncryptedRar5 = false;
 
-            while (RemainingHeaderBytes(reader) > 0)
-            {
+            while (RemainingHeaderBytes(reader) > 0) {
                 var size = reader.ReadRarVIntUInt16();
                 int n = RemainingHeaderBytes(reader);
                 var type = reader.ReadRarVIntUInt16();
-                switch (type)
-                {
+                switch (type) {
                     //TODO
                     case 1: // file encryption
                         {
@@ -124,7 +118,7 @@ namespace SharpCompress.Common.Rar.Headers
 
                             //var version = reader.ReadRarVIntByte();
                             //if (version != 0) throw new InvalidFormatException("unknown encryption algorithm " + version);
-                        }
+                                                    }
                         break;
                     //                    case 2: // file hash
                     //                        {
@@ -135,41 +129,38 @@ namespace SharpCompress.Common.Rar.Headers
                         {
                             ushort flags = reader.ReadRarVIntUInt16();
                             var isWindowsTime = (flags & 1) == 0;
-                            if ((flags & 0x2) == 0x2)
-                            {
+                            if ((flags & 0x2) == 0x2) {
                                 FileLastModifiedTime = ReadExtendedTimeV5(reader, isWindowsTime);
                             }
-                            if ((flags & 0x4) == 0x4)
-                            {
+                            if ((flags & 0x4) == 0x4) {
                                 FileCreatedTime = ReadExtendedTimeV5(reader, isWindowsTime);
                             }
-                            if ((flags & 0x8) == 0x8)
-                            {
+                            if ((flags & 0x8) == 0x8) {
                                 FileLastAccessedTime = ReadExtendedTimeV5(reader, isWindowsTime);
                             }
                         }
                         break;
-                    //TODO
-                    //                    case 4: // file version
-                    //                        {
-                    //
-                    //                        }
-                    //                        break;
-                    //                    case 5: // file system redirection
-                    //                        {
-                    //
-                    //                        }
-                    //                        break;
-                    //                    case 6: // unix owner
-                    //                        {
-                    //
-                    //                        }
-                    //                        break;
-                    //                    case 7: // service data
-                    //                        {
-                    //
-                    //                        }
-                    //                        break;
+//TODO
+//                    case 4: // file version
+//                        {
+//
+//                        }
+//                        break;
+//                    case 5: // file system redirection
+//                        {
+//
+//                        }
+//                        break;
+//                    case 6: // unix owner
+//                        {
+//
+//                        }
+//                        break;
+//                    case 7: // service data
+//                        {
+//
+//                        }
+//                        break;
 
                     default:
                         // skip unknown record types to allow new record types to be added in the future
@@ -178,26 +169,25 @@ namespace SharpCompress.Common.Rar.Headers
                 // drain any trailing bytes of extra record
                 int did = n - RemainingHeaderBytes(reader);
                 int drain = size - did;
-                if (drain > 0)
+                if (drain > 0) 
                 {
                     reader.ReadBytes(drain);
                 }
             }
 
-            if (AdditionalDataSize != 0)
-            {
+            if (AdditionalDataSize != 0) {
                 CompressedSize = AdditionalDataSize;
             }
         }
 
 
-        private static DateTime ReadExtendedTimeV5(MarkingBinaryReader reader, bool isWindowsTime)
+        private static DateTime ReadExtendedTimeV5(MarkingBinaryReader reader, bool isWindowsTime) 
         {
-            if (isWindowsTime)
+            if (isWindowsTime) 
             {
                 return DateTime.FromFileTime(reader.ReadInt64());
-            }
-            else
+            } 
+            else 
             {
                 return Utility.UnixTimeToDateTime(reader.ReadUInt32());
             }
@@ -209,7 +199,7 @@ namespace SharpCompress.Common.Rar.Headers
             {
                 // replace embedded \\ with valid filename char
                 return path.Replace('\\', '-').Replace('/', '\\');
-            }
+            } 
             return path;
         }
 
@@ -384,22 +374,20 @@ namespace SharpCompress.Common.Rar.Headers
 
         private ushort Flags { get; set; }
 
-        private bool HasFlag(ushort flag)
+        private bool HasFlag(ushort flag) 
         {
             return (Flags & flag) == flag;
         }
 
-        internal uint FileCrc
-        {
-            get
-            {
-                if (IsRar5 && !HasFlag(FileFlagsV5.HAS_CRC32))
-                {
-                    //!!! rar5: 
+        internal uint FileCrc 
+        { 
+            get { 
+                if (IsRar5 && !HasFlag(FileFlagsV5.HAS_CRC32)) {
+//!!! rar5: 
                     throw new InvalidOperationException("TODO rar5");
                 }
-                return _fileCrc;
-            }
+                return _fileCrc; 
+            } 
             private set => _fileCrc = value;
         }
 
@@ -419,7 +407,7 @@ namespace SharpCompress.Common.Rar.Headers
         //case 29: // rar 3.x compression
         //case 50: // RAR 5.0 compression algorithm.
         internal byte CompressionAlgorithm { get; private set; }
-
+        
         public bool IsSolid { get; private set; }
 
         // unused for UnpackV1 implementation (limitation)
@@ -437,14 +425,13 @@ namespace SharpCompress.Common.Rar.Headers
         internal long DataStartPosition { get; set; }
         public Stream PackedStream { get; set; }
 
-        public bool IsSplitBefore => IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_BEFORE) : HasFlag(FileFlagsV4.SPLIT_BEFORE);
         public bool IsSplitAfter => IsRar5 ? HasHeaderFlag(HeaderFlagsV5.SPLIT_AFTER) : HasFlag(FileFlagsV4.SPLIT_AFTER);
 
         public bool IsDirectory => HasFlag(IsRar5 ? FileFlagsV5.DIRECTORY : FileFlagsV4.DIRECTORY);
 
         private bool isEncryptedRar5 = false;
-        public bool IsEncrypted => IsRar5 ? isEncryptedRar5 : HasFlag(FileFlagsV4.PASSWORD);
-
+        public bool IsEncrypted => IsRar5 ? isEncryptedRar5: HasFlag(FileFlagsV4.PASSWORD);
+        
         internal DateTime? FileLastModifiedTime { get; private set; }
 
         internal DateTime? FileCreatedTime { get; private set; }

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

@@ -42,10 +42,10 @@ namespace SharpCompress.Common.Rar.Headers
     }
 
     internal static class EncryptionFlagsV5
-    {
+    {   
         // RAR 5.0 archive encryption header specific flags.
         public const uint CHFL_CRYPT_PSWCHECK = 0x01; // Password check data is present.
-
+        
         public const uint FHEXTRA_CRYPT_PSWCHECK = 0x01; // Password check data is present.
         public const uint FHEXTRA_CRYPT_HASHMAC = 0x02;
     }

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

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

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

@@ -11,98 +11,71 @@ namespace SharpCompress.Common.Rar.Headers
 
         public bool IsRar5 { get; }
 
-        private MarkHeader(bool isRar5)
-        {
+        private MarkHeader(bool isRar5) 
+        { 
             IsRar5 = isRar5;
         }
 
         public HeaderType HeaderType => HeaderType.Mark;
 
-        private static byte GetByte(Stream stream)
+        private static byte GetByte(Stream stream) 
         {
             var b = stream.ReadByte();
-            if (b != -1)
+            if (b != -1) 
             {
                 return (byte)b;
             }
             throw new EndOfStreamException();
         }
 
-        public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
+        public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader) 
         {
             int maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
             try
             {
                 int start = -1;
                 var b = GetByte(stream); start++;
-                while (start <= maxScanIndex)
+                while (start <= maxScanIndex) 
                 {
                     // Rar old signature: 52 45 7E 5E
                     // Rar4 signature:    52 61 72 21 1A 07 00
                     // Rar5 signature:    52 61 72 21 1A 07 01 00
-                    if (b == 0x52)
+                    if (b == 0x52) 
                     {
                         b = GetByte(stream); start++;
-                        if (b == 0x61)
+                        if (b == 0x61) 
                         {
                             b = GetByte(stream); start++;
-                            if (b != 0x72)
-                            {
-                                continue;
-                            }
+                            if (b != 0x72) continue;
+                            b = GetByte(stream); start++;
+                            if (b != 0x21) continue;
+                            b = GetByte(stream); start++;
+                            if (b != 0x1a) continue;
+                            b = GetByte(stream); start++;
+                            if (b != 0x07) continue;
 
                             b = GetByte(stream); start++;
-                            if (b != 0x21)
-                            {
-                                continue;
-                            }
-
-                            b = GetByte(stream); start++;
-                            if (b != 0x1a)
-                            {
-                                continue;
-                            }
-
-                            b = GetByte(stream); start++;
-                            if (b != 0x07)
-                            {
-                                continue;
-                            }
-
-                            b = GetByte(stream); start++;
-                            if (b == 1)
+                            if (b == 1) 
                             {
                                 b = GetByte(stream); start++;
-                                if (b != 0)
-                                {
-                                    continue;
-                                }
-
+                                if (b != 0) continue;
                                 return new MarkHeader(true); // Rar5
-                            }
-                            else if (b == 0)
+                            } 
+                            else if (b == 0) 
                             {
                                 return new MarkHeader(false); // Rar4
-                            }
-                        }
-                        else if (b == 0x45)
+                            } 
+                        } 
+                        else if (b == 0x45) 
                         {
                             b = GetByte(stream); start++;
-                            if (b != 0x7e)
-                            {
-                                continue;
-                            }
-
+                            if (b != 0x7e) continue;
                             b = GetByte(stream); start++;
-                            if (b != 0x5e)
-                            {
-                                continue;
-                            }
-
+                            if (b != 0x5e) continue;
                             throw new InvalidFormatException("Rar format version pre-4 is unsupported.");
-                        }
-                    }
-                    else
+                        } 
+                    } 
+                    else 
                     {
                         b = GetByte(stream); start++;
                     }

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

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

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

@@ -3,15 +3,12 @@
 namespace SharpCompress.Common.Rar.Headers
 {
     // ProtectHeader is part of the Recovery Record feature
-    internal sealed class ProtectHeader : RarHeader
+    internal class ProtectHeader : RarHeader
     {
-        public ProtectHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.Protect)
+        public ProtectHeader(RarHeader header, RarCrcBinaryReader reader) 
+            : base(header, reader, HeaderType.Protect) 
         {
-            if (IsRar5)
-            {
-                throw new InvalidFormatException("unexpected rar5 record");
-            }
+            if (IsRar5) throw new InvalidFormatException("unexpected rar5 record");
         }
 
         protected override void ReadFinish(MarkingBinaryReader reader)
@@ -26,6 +23,6 @@ namespace SharpCompress.Common.Rar.Headers
         internal byte Version { get; private set; }
         internal ushort RecSectors { get; private set; }
         internal uint TotalBlocks { get; private set; }
-        internal byte[]? Mark { get; private set; }
+        internal byte[] Mark { get; private set; }
     }
 }

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

@@ -11,7 +11,7 @@ namespace SharpCompress.Common.Rar.Headers
         private readonly HeaderType _headerType;
         private readonly bool _isRar5;
 
-        internal static RarHeader? TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
+        internal static RarHeader TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
         {
             try
             {
@@ -23,12 +23,12 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
+        private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding) 
         {
             _headerType = HeaderType.Null;
             _isRar5 = isRar5;
             ArchiveEncoding = archiveEncoding;
-            if (IsRar5)
+            if (IsRar5) 
             {
                 HeaderCrc = reader.ReadUInt32();
                 reader.ResetCrc();
@@ -45,9 +45,7 @@ namespace SharpCompress.Common.Rar.Headers
                 {
                     AdditionalDataSize = (long)reader.ReadRarVInt();
                 }
-            }
-            else
-            {
+            } else {
                 reader.Mark();
                 HeaderCrc = reader.ReadUInt16();
                 reader.ResetCrc();
@@ -61,8 +59,7 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        protected RarHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType)
-        {
+        protected RarHeader(RarHeader header, RarCrcBinaryReader reader, HeaderType headerType) {
             _headerType = headerType;
             _isRar5 = header.IsRar5;
             HeaderCrc = header.HeaderCrc;
@@ -83,8 +80,7 @@ namespace SharpCompress.Common.Rar.Headers
             VerifyHeaderCrc(reader.GetCrc32());
         }
 
-        protected int RemainingHeaderBytes(MarkingBinaryReader reader)
-        {
+        protected int RemainingHeaderBytes(MarkingBinaryReader reader) {
             return checked(HeaderSize - (int)reader.CurrentReadByteCount);
         }
 
@@ -112,7 +108,7 @@ namespace SharpCompress.Common.Rar.Headers
 
         protected ushort HeaderFlags { get; }
 
-        protected bool HasHeaderFlag(ushort flag)
+        protected bool HasHeaderFlag(ushort flag) 
         {
             return (HeaderFlags & flag) == flag;
         }

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

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.IO;
@@ -25,7 +26,7 @@ namespace SharpCompress.Common.Rar.Headers
             _isRar5 = markHeader.IsRar5;
             yield return markHeader;
 
-            RarHeader? header;
+            RarHeader header;
             while ((header = TryReadNextHeader(stream)) != null)
             {
                 yield return header;
@@ -38,16 +39,16 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        private RarHeader? TryReadNextHeader(Stream stream)
+        private RarHeader TryReadNextHeader(Stream stream)
         {
             RarCrcBinaryReader reader;
-            if (!IsEncrypted)
+            if (!IsEncrypted) 
             {
                 reader = new RarCrcBinaryReader(stream);
-            }
-            else
+            } 
+            else 
             {
-                if (Options.Password is null)
+                if (Options.Password == null)
                 {
                     throw new CryptographicException("Encrypted Rar archive has no password specified.");
                 }
@@ -55,7 +56,7 @@ namespace SharpCompress.Common.Rar.Headers
             }
 
             var header = RarHeader.TryReadBase(reader, _isRar5, Options.ArchiveEncoding);
-            if (header is null)
+            if (header == null)
             {
                 return null;
             }
@@ -65,7 +66,7 @@ namespace SharpCompress.Common.Rar.Headers
                 case HeaderCodeV.RAR4_ARCHIVE_HEADER:
                     {
                         var ah = new ArchiveHeader(header, reader);
-                        if (ah.IsEncrypted == true)
+                        if (ah.IsEncrypted == true) 
                         {
                             //!!! rar5 we don't know yet
                             IsEncrypted = true;
@@ -127,13 +128,13 @@ namespace SharpCompress.Common.Rar.Headers
                             case StreamingMode.Streaming:
                                 {
                                     var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                                    if (fh.R4Salt is null)
+                                    if (fh.R4Salt == null)
                                     {
                                         fh.PackedStream = ms;
                                     }
                                     else
                                     {
-                                        fh.PackedStream = new RarCryptoWrapper(ms, Options.Password!, fh.R4Salt);
+                                        fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.R4Salt);
                                     }
                                 }
                                 break;
@@ -150,11 +151,11 @@ namespace SharpCompress.Common.Rar.Headers
                         return new EndArchiveHeader(header, reader);
                     }
                 case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
-                    {
-                        var ch = new ArchiveCryptHeader(header, reader);
-                        IsEncrypted = true;
-                        return ch;
-                    }
+                {
+                    var ch = new ArchiveCryptHeader(header, reader);
+                    IsEncrypted = true;
+                    return ch;
+                }
                 default:
                     {
                         throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
@@ -162,26 +163,21 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        private void SkipData(FileHeader fh, RarCrcBinaryReader reader)
-        {
-            switch (StreamingMode)
-            {
-                case StreamingMode.Seekable:
-                    {
-                        fh.DataStartPosition = reader.BaseStream.Position;
-                        reader.BaseStream.Position += fh.CompressedSize;
-                    }
+        private void SkipData(FileHeader fh, RarCrcBinaryReader reader) {
+            switch (StreamingMode) {
+                case StreamingMode.Seekable: {
+                    fh.DataStartPosition = reader.BaseStream.Position;
+                    reader.BaseStream.Position += fh.CompressedSize;
+                }
                     break;
-                case StreamingMode.Streaming:
-                    {
-                        //skip the data because it's useless?
-                        reader.BaseStream.Skip(fh.CompressedSize);
-                    }
+                case StreamingMode.Streaming: {
+                    //skip the data because it's useless?
+                    reader.BaseStream.Skip(fh.CompressedSize);
+                }
                     break;
-                default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
+                default: {
+                    throw new InvalidFormatException("Invalid StreamingMode");
+                }
             }
         }
     }

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

@@ -5,12 +5,9 @@ namespace SharpCompress.Common.Rar.Headers
     internal class SignHeader : RarHeader
     {
         protected SignHeader(RarHeader header, RarCrcBinaryReader reader)
-            : base(header, reader, HeaderType.Sign)
-        {
-            if (IsRar5)
-            {
-                throw new InvalidFormatException("unexpected rar5 record");
-            }
+            : base(header, reader, HeaderType.Sign) 
+        { 
+            if (IsRar5) throw new InvalidFormatException("unexpected rar5 record");
         }
 
         protected override void ReadFinish(MarkingBinaryReader reader)

src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs

@@ -3,7 +3,7 @@ using System.IO;
 
 namespace SharpCompress.Common.Rar
 {
-    internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
+    internal class RarCryptoBinaryReader : RarCrcBinaryReader
     {
         private RarRijndael _rijndael;
         private byte[] _salt;
@@ -19,9 +19,7 @@ namespace SharpCompress.Common.Rar
             // coderb: not sure why this was being done at this logical point
             //SkipQueue();
             byte[] salt = ReadBytes(8);
-
-            _salt = salt;
-            _rijndael = RarRijndael.InitializeFrom(_password, salt);
+            InitializeAes(salt);
         }
 
         // track read count ourselves rather than using the underlying stream since we buffer
@@ -41,6 +39,12 @@ namespace SharpCompress.Common.Rar
 
         private bool UseEncryption => _salt != null;
 
+        internal void InitializeAes(byte[] salt)
+        {
+            _salt = salt;
+            _rijndael = RarRijndael.InitializeFrom(_password, salt);
+        }
+
         public override byte ReadByte()
         {
             if (UseEncryption)
@@ -77,9 +81,7 @@ namespace SharpCompress.Common.Rar
                     byte[] cipherText = ReadBytesNoCrc(16);
                     var readBytes = _rijndael.ProcessBlock(cipherText);
                     foreach (var readByte in readBytes)
-                    {
                         _data.Enqueue(readByte);
-                    }
                 }
             }
 

src/SharpCompress/Common/Rar/RarCryptoWrapper.cs

@@ -4,7 +4,7 @@ using System.IO;
 
 namespace SharpCompress.Common.Rar
 {
-    internal sealed class RarCryptoWrapper : Stream
+    internal class RarCryptoWrapper : Stream
     {
         private readonly Stream _actualStream;
         private readonly byte[] _salt;
@@ -35,7 +35,7 @@ namespace SharpCompress.Common.Rar
 
         public override int Read(byte[] buffer, int offset, int count)
         {
-            if (_salt is null)
+            if (_salt == null)
             {
                 return _actualStream.Read(buffer, offset, count);
             }
@@ -50,23 +50,20 @@ namespace SharpCompress.Common.Rar
             if (sizeToRead > 0)
             {
                 int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
-                Span<byte> cipherText = stackalloc byte[RarRijndael.CRYPTO_BLOCK_SIZE];
                 for (int i = 0; i < alignedSize / 16; i++)
                 {
                     //long ax = System.currentTimeMillis();
-                    _actualStream.Read(cipherText);
+                    byte[] cipherText = new byte[RarRijndael.CRYPTO_BLOCK_SIZE];
+                    _actualStream.Read(cipherText, 0, RarRijndael.CRYPTO_BLOCK_SIZE);
 
                     var readBytes = _rijndael.ProcessBlock(cipherText);
                     foreach (var readByte in readBytes)
-                    {
                         _data.Enqueue(readByte);
-                    }
+
                 }
 
                 for (int i = 0; i < count; i++)
-                {
                     buffer[offset + i] = _data.Dequeue();
-                }
             }
             return count;
         }
@@ -91,9 +88,9 @@ namespace SharpCompress.Common.Rar
             if (_rijndael != null)
             {
                 _rijndael.Dispose();
-                _rijndael = null!;
+                _rijndael = null;
             }
             base.Dispose(disposing);
         }
     }
-}
+}

src/SharpCompress/Common/Rar/RarEntry.cs

@@ -10,8 +10,8 @@ namespace SharpCompress.Common.Rar
         /// <summary>
         /// As the V2017 port isn't complete, add this check to use the legacy Rar code.
         /// </summary>
-        internal bool IsRarV3 => FileHeader.CompressionAlgorithm == 20 || FileHeader.CompressionAlgorithm == 26 || FileHeader.CompressionAlgorithm == 29 || FileHeader.CompressionAlgorithm == 36; //Nanook - Added 20+26 as Test arc from WinRar2.8 (algo 20) was failing with 2017 code
-
+        internal bool IsRarV3 => FileHeader.CompressionAlgorithm == 29 || FileHeader.CompressionAlgorithm == 36;
+        
         /// <summary>
         /// The File's 32 bit CRC Hash
         /// </summary>
@@ -22,7 +22,7 @@ namespace SharpCompress.Common.Rar
         /// </summary>
         public override string Key => FileHeader.FileName;
 
-        public override string? LinkTarget => null;
+        public override string LinkTarget => null;
 
         /// <summary>
         /// The entry last modified time in the archive, if recorded

src/SharpCompress/Common/Rar/RarFilePart.cs

@@ -19,7 +19,7 @@ namespace SharpCompress.Common.Rar
 
         internal FileHeader FileHeader { get; }
 
-        internal override Stream? GetRawStream()
+        internal override Stream GetRawStream()
         {
             return null;
         }

src/SharpCompress/Common/Rar/RarRijndael.cs

@@ -1,6 +1,5 @@
-#nullable disable
-
-using System;
+using System;
+using System.Collections.Generic;
 using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.Crypto;
@@ -27,13 +26,13 @@ namespace SharpCompress.Common.Rar
 
             _rijndael = new RijndaelEngine();
             _aesInitializationVector = new byte[CRYPTO_BLOCK_SIZE];
-            int rawLength = 2 * _password.Length;
+            int rawLength = 2*_password.Length;
             byte[] rawPassword = new byte[rawLength + 8];
             byte[] passwordBytes = Encoding.UTF8.GetBytes(_password);
             for (int i = 0; i < _password.Length; i++)
             {
-                rawPassword[i * 2] = passwordBytes[i];
-                rawPassword[i * 2 + 1] = 0;
+                rawPassword[i*2] = passwordBytes[i];
+                rawPassword[i*2 + 1] = 0;
             }
             for (int i = 0; i < _salt.Length; i++)
             {
@@ -68,11 +67,11 @@ namespace SharpCompress.Common.Rar
             {
                 for (int j = 0; j < 4; j++)
                 {
-                    aesKey[i * 4 + j] = (byte)
-                        (((digest[i * 4] * 0x1000000) & 0xff000000 |
-                          (uint)((digest[i * 4 + 1] * 0x10000) & 0xff0000) |
-                          (uint)((digest[i * 4 + 2] * 0x100) & 0xff00) |
-                          (uint)(digest[i * 4 + 3] & 0xff)) >> (j * 8));
+                    aesKey[i*4 + j] = (byte)
+                        (((digest[i*4]*0x1000000) & 0xff000000 |
+                          (uint) ((digest[i*4 + 1]*0x10000) & 0xff0000) |
+                          (uint) ((digest[i*4 + 2]*0x100) & 0xff00) |
+                          (uint) (digest[i*4 + 3] & 0xff)) >> (j*8));
                 }
             }
 
@@ -87,23 +86,22 @@ namespace SharpCompress.Common.Rar
             return rijndael;
         }
 
-        public byte[] ProcessBlock(ReadOnlySpan<byte> cipherText)
+        public byte[] ProcessBlock(byte[] cipherText)
         {
-            Span<byte> plainText = stackalloc byte[CRYPTO_BLOCK_SIZE]; // 16 bytes
-            byte[] decryptedBytes = new byte[CRYPTO_BLOCK_SIZE];
-            _rijndael.ProcessBlock(cipherText, plainText);
+            var plainText = new byte[CRYPTO_BLOCK_SIZE];
+            var decryptedBytes = new List<byte>();
+            _rijndael.ProcessBlock(cipherText, 0, plainText, 0);
 
-            for (int j = 0; j < CRYPTO_BLOCK_SIZE; j++)
+            for (int j = 0; j < plainText.Length; j++)
             {
-                decryptedBytes[j] = (byte)(plainText[j] ^ _aesInitializationVector[j % 16]); //32:114, 33:101
+                decryptedBytes.Add((byte) (plainText[j] ^ _aesInitializationVector[j%16])); //32:114, 33:101
             }
 
             for (int j = 0; j < _aesInitializationVector.Length; j++)
             {
                 _aesInitializationVector[j] = cipherText[j];
             }
-
-            return decryptedBytes;
+            return decryptedBytes.ToArray();
         }
 
         public void Dispose()

src/SharpCompress/Common/Rar/RarVolume.cs

@@ -21,9 +21,7 @@ namespace SharpCompress.Common.Rar
             _headerFactory = new RarHeaderFactory(mode, options);
         }
 
-#nullable disable
         internal ArchiveHeader ArchiveHeader { get; private set; }
-#nullable enable
 
         internal StreamingMode Mode => _headerFactory.StreamingMode;
 
@@ -33,26 +31,26 @@ namespace SharpCompress.Common.Rar
 
         internal IEnumerable<RarFilePart> GetVolumeFileParts()
         {
-            MarkHeader? lastMarkHeader = null;
+            MarkHeader lastMarkHeader = null;
             foreach (var header in _headerFactory.ReadHeaders(Stream))
             {
                 switch (header.HeaderType)
                 {
                     case HeaderType.Mark:
-                        {
-                            lastMarkHeader = (MarkHeader)header;
-                        }
+                    {
+                        lastMarkHeader = header as MarkHeader;
+                    }
                         break;
                     case HeaderType.Archive:
-                        {
-                            ArchiveHeader = (ArchiveHeader)header;
-                        }
+                    {
+                        ArchiveHeader = header as ArchiveHeader;
+                    }
                         break;
                     case HeaderType.File:
-                        {
-                            var fh = (FileHeader)header;
-                            yield return CreateFilePart(lastMarkHeader!, fh);
-                        }
+                    {
+                        var fh = header as FileHeader;
+                        yield return CreateFilePart(lastMarkHeader, fh);
+                    }
                         break;
                 }
             }
@@ -60,7 +58,7 @@ namespace SharpCompress.Common.Rar
 
         private void EnsureArchiveHeaderLoaded()
         {
-            if (ArchiveHeader is null)
+            if (ArchiveHeader == null)
             {
                 if (Mode == StreamingMode.Streaming)
                 {

src/SharpCompress/Common/ReaderExtractionEventArgs.cs

@@ -3,16 +3,15 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Common
 {
-    public sealed class ReaderExtractionEventArgs<T> : EventArgs
+    public class ReaderExtractionEventArgs<T> : EventArgs
     {
-        internal ReaderExtractionEventArgs(T entry, ReaderProgress? readerProgress = null)
+        internal ReaderExtractionEventArgs(T entry, ReaderProgress readerProgress = null)
         {
             Item = entry;
             ReaderProgress = readerProgress;
         }
 
         public T Item { get; }
-
-        public ReaderProgress? ReaderProgress { get; }
+        public ReaderProgress ReaderProgress { get; }
     }
 }

src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Compressors.LZMA;
@@ -24,7 +22,7 @@ namespace SharpCompress.Common.SevenZip
         internal List<long> _packStreamStartPositions = new List<long>();
         internal List<int> _folderStartFileIndex = new List<int>();
         internal List<int> _fileIndexToFolderIndexMap = new List<int>();
-
+        
         internal IPasswordProvider PasswordProvider { get; }
 
         public ArchiveDatabase(IPasswordProvider passwordProvider)
@@ -37,7 +35,7 @@ namespace SharpCompress.Common.SevenZip
             _packSizes.Clear();
             _packCrCs.Clear();
             _folders.Clear();
-            _numUnpackStreamsVector = null!;
+            _numUnpackStreamsVector = null;
             _files.Clear();
 
             _packStreamStartPositions.Clear();
@@ -89,7 +87,7 @@ namespace SharpCompress.Common.SevenZip
                 {
                     // v3.13 incorrectly worked with empty folders
                     // v4.07: Loop for skipping empty folders
-                    for (; ; )
+                    for (;;)
                     {
                         if (folderIndex >= _folders.Count)
                         {
@@ -98,7 +96,7 @@ namespace SharpCompress.Common.SevenZip
 
                         _folderStartFileIndex.Add(i); // check it
 
-                        if (_numUnpackStreamsVector![folderIndex] != 0)
+                        if (_numUnpackStreamsVector[folderIndex] != 0)
                         {
                             break;
                         }
@@ -116,7 +114,7 @@ namespace SharpCompress.Common.SevenZip
 
                 indexInFolder++;
 
-                if (indexInFolder >= _numUnpackStreamsVector![folderIndex])
+                if (indexInFolder >= _numUnpackStreamsVector[folderIndex])
                 {
                     folderIndex++;
                     indexInFolder = 0;
@@ -154,14 +152,13 @@ namespace SharpCompress.Common.SevenZip
         {
             int packStreamIndex = folder._firstPackStreamId;
             long folderStartPackPos = GetFolderStreamPos(folder, 0);
-            int count = folder._packStreams.Count;
-            long[] packSizes = new long[count];
-            for (int j = 0; j < count; j++)
+            List<long> packSizes = new List<long>();
+            for (int j = 0; j < folder._packStreams.Count; j++)
             {
-                packSizes[j] = _packSizes[packStreamIndex + j];
+                packSizes.Add(_packSizes[packStreamIndex + j]);
             }
 
-            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes, folder, pw);
+            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes.ToArray(), folder, pw);
         }
 
         private long GetFolderPackStreamSize(int folderIndex, int streamIndex)
@@ -182,4 +179,4 @@ namespace SharpCompress.Common.SevenZip
             return 0;
         }
     }
-}
+}

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -90,7 +88,7 @@ namespace SharpCompress.Common.SevenZip
 
         private void WaitAttribute(BlockType attribute)
         {
-            for (; ; )
+            for (;;)
             {
                 BlockType? type = ReadId();
                 if (type == attribute)
@@ -452,7 +450,7 @@ namespace SharpCompress.Common.SevenZip
 #endif
 
                 BlockType? type;
-                for (; ; )
+                for (;;)
                 {
                     type = ReadId();
                     if (type == BlockType.End)
@@ -467,7 +465,7 @@ namespace SharpCompress.Common.SevenZip
                     SkipData();
                 }
 
-                if (packCrCs is null)
+                if (packCrCs == null)
                 {
                     packCrCs = new List<uint?>(numPackStreams);
                     for (int i = 0; i < numPackStreams; i++)
@@ -508,7 +506,7 @@ namespace SharpCompress.Common.SevenZip
                     int index = 0;
                     for (int i = 0; i < numFolders; i++)
                     {
-                        var f = new CFolder { _firstPackStreamId = index };
+                        var f = new CFolder {_firstPackStreamId = index};
                         folders.Add(f);
                         GetNextFolderItem(f);
                         index += f._packStreams.Count;
@@ -539,7 +537,7 @@ namespace SharpCompress.Common.SevenZip
 #endif
                 }
 
-                for (; ; )
+                for (;;)
                 {
                     BlockType? type = ReadId();
                     if (type == BlockType.End)
@@ -580,7 +578,7 @@ namespace SharpCompress.Common.SevenZip
                 numUnpackStreamsInFolders = null;
 
                 BlockType? type;
-                for (; ; )
+                for (;;)
                 {
                     type = ReadId();
                     if (type == BlockType.NumUnpackStream)
@@ -602,7 +600,7 @@ namespace SharpCompress.Common.SevenZip
 #endif
                         continue;
                     }
-                    if (type is BlockType.Crc or BlockType.Size)
+                    if (type == BlockType.Crc || type == BlockType.Size)
                     {
                         break;
                     }
@@ -613,7 +611,7 @@ namespace SharpCompress.Common.SevenZip
                     SkipData();
                 }
 
-                if (numUnpackStreamsInFolders is null)
+                if (numUnpackStreamsInFolders == null)
                 {
                     numUnpackStreamsInFolders = new List<int>(folders.Count);
                     for (int i = 0; i < folders.Count; i++)
@@ -672,7 +670,7 @@ namespace SharpCompress.Common.SevenZip
 
                 digests = null;
 
-                for (; ; )
+                for (;;)
                 {
                     if (type == BlockType.Crc)
                     {
@@ -705,7 +703,7 @@ namespace SharpCompress.Common.SevenZip
                     }
                     else if (type == BlockType.End)
                     {
-                        if (digests is null)
+                        if (digests == null)
                         {
                             digests = new List<uint?>(numDigestsTotal);
                             for (int i = 0; i < numDigestsTotal; i++)
@@ -755,7 +753,7 @@ namespace SharpCompress.Common.SevenZip
                 unpackSizes = null;
                 digests = null;
 
-                for (; ; )
+                for (;;)
                 {
                     switch (ReadId())
                     {
@@ -791,14 +789,22 @@ namespace SharpCompress.Common.SevenZip
 #endif
             try
             {
+                long dataStartPos;
+                List<long> packSizes;
+                List<uint?> packCrCs;
+                List<CFolder> folders;
+                List<int> numUnpackStreamsInFolders;
+                List<long> unpackSizes;
+                List<uint?> digests;
+
                 ReadStreamsInfo(null,
-                                out long dataStartPos,
-                                out List<long> packSizes,
-                                out List<uint?> packCrCs,
-                                out List<CFolder> folders,
-                                out List<int> numUnpackStreamsInFolders,
-                                out List<long> unpackSizes,
-                                out List<uint?> digests);
+                                out dataStartPos,
+                                out packSizes,
+                                out packCrCs,
+                                out folders,
+                                out numUnpackStreamsInFolders,
+                                out unpackSizes,
+                                out digests);
 
                 dataStartPos += baseOffset;
 
@@ -926,7 +932,7 @@ namespace SharpCompress.Common.SevenZip
                 BitVector antiFileVector = null;
                 int numEmptyStreams = 0;
 
-                for (; ; )
+                for (;;)
                 {
                     type = ReadId();
                     if (type == BlockType.End)
@@ -961,7 +967,7 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                             Log.Write("WinAttributes:");
 #endif
-                            ReadAttributeVector(dataVector, numFiles, delegate (int i, uint? attr)
+                            ReadAttributeVector(dataVector, numFiles, delegate(int i, uint? attr)
                                                                       {
                                                                           // Some third party implementations established an unofficial extension
                                                                           // of the 7z archive format by placing posix file attributes in the high
@@ -1049,7 +1055,7 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                             Log.Write("StartPos:");
 #endif
-                            ReadNumberVector(dataVector, numFiles, delegate (int i, long? startPos)
+                            ReadNumberVector(dataVector, numFiles, delegate(int i, long? startPos)
                                                                    {
                                                                        db._files[i].StartPos = startPos;
 #if DEBUG
@@ -1064,7 +1070,7 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                             Log.Write("CTime:");
 #endif
-                            ReadDateTimeVector(dataVector, numFiles, delegate (int i, DateTime? time)
+                            ReadDateTimeVector(dataVector, numFiles, delegate(int i, DateTime? time)
                                                                      {
                                                                          db._files[i].CTime = time;
 #if DEBUG
@@ -1079,7 +1085,7 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                             Log.Write("ATime:");
 #endif
-                            ReadDateTimeVector(dataVector, numFiles, delegate (int i, DateTime? time)
+                            ReadDateTimeVector(dataVector, numFiles, delegate(int i, DateTime? time)
                                                                      {
                                                                          db._files[i].ATime = time;
 #if DEBUG
@@ -1094,7 +1100,7 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                             Log.Write("MTime:");
 #endif
-                            ReadDateTimeVector(dataVector, numFiles, delegate (int i, DateTime? time)
+                            ReadDateTimeVector(dataVector, numFiles, delegate(int i, DateTime? time)
                                                                      {
                                                                          db._files[i].MTime = time;
 #if DEBUG
@@ -1248,7 +1254,7 @@ namespace SharpCompress.Common.SevenZip
 
             if (nextHeaderOffset > _streamEnding - db._startPositionAfterHeader)
             {
-                throw new InvalidOperationException("nextHeaderOffset is invalid");
+                throw new IndexOutOfRangeException();
             }
 
             _stream.Seek(nextHeaderOffset, SeekOrigin.Current);
@@ -1390,7 +1396,7 @@ namespace SharpCompress.Common.SevenZip
                 }
                 else
                 {
-                    _stream = new MemoryStream();
+                    _stream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream();
                 }
                 _rem = _db._files[index].Size;
             }
@@ -1437,19 +1443,19 @@ namespace SharpCompress.Common.SevenZip
 
         private Stream GetCachedDecoderStream(ArchiveDatabase db, int folderIndex)
         {
-            if (!_cachedStreams.TryGetValue(folderIndex, out Stream s))
+            Stream s;
+            if (!_cachedStreams.TryGetValue(folderIndex, out s))
             {
                 CFolder folderInfo = db._folders[folderIndex];
                 int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                 long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
-                var count = folderInfo._packStreams.Count;
-                long[] packSizes = new long[count];
-                for (int j = 0; j < count; j++)
+                List<long> packSizes = new List<long>();
+                for (int j = 0; j < folderInfo._packStreams.Count; j++)
                 {
-                    packSizes[j] = db._packSizes[packStreamIndex + j];
+                    packSizes.Add(db._packSizes[packStreamIndex + j]);
                 }
 
-                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes, folderInfo,
+                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
                                                             db.PasswordProvider);
                 _cachedStreams.Add(folderIndex, s);
             }
@@ -1480,11 +1486,16 @@ namespace SharpCompress.Common.SevenZip
 
         public void Extract(ArchiveDatabase db, int[] indices)
         {
-            bool allFilesMode = (indices is null);
-
-            int numItems = allFilesMode
-                ? db._files.Count
-                : indices.Length;
+            int numItems;
+            bool allFilesMode = (indices == null);
+            if (allFilesMode)
+            {
+                numItems = db._files.Count;
+            }
+            else
+            {
+                numItems = indices.Length;
+            }
 
             if (numItems == 0)
             {
@@ -1517,7 +1528,6 @@ namespace SharpCompress.Common.SevenZip
                 }
             }
 
-            byte[] buffer = null;
             foreach (CExtractFolderInfo efi in extractFolderInfoVector)
             {
                 int startIndex;
@@ -1543,19 +1553,18 @@ namespace SharpCompress.Common.SevenZip
                 int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                 long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
 
-                var count = folderInfo._packStreams.Count;
-                long[] packSizes = new long[count];
-                for (int j = 0; j < count; j++)
+                List<long> packSizes = new List<long>();
+                for (int j = 0; j < folderInfo._packStreams.Count; j++)
                 {
-                    packSizes[j] = db._packSizes[packStreamIndex + j];
+                    packSizes.Add(db._packSizes[packStreamIndex + j]);
                 }
 
                 // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?
 
-                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes,
+                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
                                                                    folderInfo, db.PasswordProvider);
-                buffer ??= new byte[4 << 10];
-                for (; ; )
+                byte[] buffer = new byte[4 << 10];
+                for (;;)
                 {
                     int processed = s.Read(buffer, 0, buffer.Length);
                     if (processed == 0)

src/SharpCompress/Common/SevenZip/CCoderInfo.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-namespace SharpCompress.Common.SevenZip
+namespace SharpCompress.Common.SevenZip
 {
     internal class CCoderInfo
     {

src/SharpCompress/Common/SevenZip/CFileItem.cs

@@ -1,6 +1,4 @@
-#nullable disable
-
-using System;
+using System;
 
 namespace SharpCompress.Common.SevenZip
 {

src/SharpCompress/Common/SevenZip/CFolder.cs

@@ -30,7 +30,7 @@ namespace SharpCompress.Common.SevenZip
                 }
             }
 
-            throw new InvalidOperationException();
+            throw new Exception();
         }
 
         public int GetNumOutStreams()
@@ -185,4 +185,4 @@ namespace SharpCompress.Common.SevenZip
             return true;
         }
     }
-}
+}

src/SharpCompress/Common/SevenZip/CMethodId.cs

@@ -1,6 +1,6 @@
 namespace SharpCompress.Common.SevenZip
 {
-    internal readonly struct CMethodId
+    internal struct CMethodId
     {
         public const ulong K_COPY_ID = 0;
         public const ulong K_LZMA_ID = 0x030101;
@@ -24,9 +24,9 @@
             return _id.GetHashCode();
         }
 
-        public override bool Equals(object? obj)
+        public override bool Equals(object obj)
         {
-            return obj is CMethodId other && Equals(other);
+            return obj is CMethodId && (CMethodId)obj == this;
         }
 
         public bool Equals(CMethodId other)

src/SharpCompress/Common/SevenZip/DataReader.cs

@@ -161,7 +161,7 @@ namespace SharpCompress.Common.SevenZip
         {
             int ending = Offset;
 
-            for (; ; )
+            for (;;)
             {
                 if (ending + 2 > _ending)
                 {

src/SharpCompress/Common/SevenZip/SevenZipEntry.cs

@@ -18,7 +18,7 @@ namespace SharpCompress.Common.SevenZip
 
         public override string Key => FilePart.Header.Name;
 
-        public override string? LinkTarget => null;
+        public override string LinkTarget => null;
 
         public override long CompressedSize => 0;
 
@@ -32,13 +32,13 @@ namespace SharpCompress.Common.SevenZip
 
         public override DateTime? ArchivedTime => null;
 
-        public override bool IsEncrypted => FilePart.IsEncrypted;
+        public override bool IsEncrypted => false;
 
         public override bool IsDirectory => FilePart.Header.IsDir;
 
         public override bool IsSplitAfter => false;
 
-        public override int? Attrib => FilePart.Header.Attrib.HasValue ? (int?)FilePart.Header.Attrib.Value : null;
+        public override int? Attrib => (int)FilePart.Header.Attrib;
 
         internal override IEnumerable<FilePart> Parts => FilePart.AsEnumerable<FilePart>();
     }

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -25,12 +25,12 @@ namespace SharpCompress.Common.SevenZip
         }
 
         internal CFileItem Header { get; }
-        internal CFolder? Folder { get; }
+        internal CFolder Folder { get; }
         internal int Index { get; }
 
         internal override string FilePartName => Header.Name;
 
-        internal override Stream? GetRawStream()
+        internal override Stream GetRawStream()
         {
             return null;
         }
@@ -39,11 +39,11 @@ namespace SharpCompress.Common.SevenZip
         {
             if (!Header.HasStream)
             {
-                return null!;
+                return null;
             }
-            var folderStream = _database.GetFolderStream(_stream, Folder!, _database.PasswordProvider);
+            var folderStream = _database.GetFolderStream(_stream, Folder, _database.PasswordProvider);
 
-            int firstFileIndex = _database._folderStartFileIndex[_database._folders.IndexOf(Folder!)];
+            int firstFileIndex = _database._folderStartFileIndex[_database._folders.IndexOf(Folder)];
             int skipCount = Index - firstFileIndex;
             long skipSize = 0;
             for (int i = 0; i < skipCount; i++)
@@ -61,7 +61,7 @@ namespace SharpCompress.Common.SevenZip
         {
             get
             {
-                if (_type is null)
+                if (_type == null)
                 {
                     _type = GetCompression();
                 }
@@ -82,27 +82,25 @@ namespace SharpCompress.Common.SevenZip
 
         internal CompressionType GetCompression()
         {
-            var coder = Folder!._coders.First();
+            var coder = Folder._coders.First();
             switch (coder._methodId._id)
-            {
+            {                
                 case K_LZMA:
                 case K_LZMA2:
-                    {
-                        return CompressionType.LZMA;
-                    }
+                {
+                    return CompressionType.LZMA;
+                }
                 case K_PPMD:
-                    {
-                        return CompressionType.PPMd;
-                    }
+                {
+                    return CompressionType.PPMd;
+                }
                 case K_B_ZIP2:
-                    {
-                        return CompressionType.BZip2;
-                    }
+                {
+                    return CompressionType.BZip2;
+                }
                 default:
                     throw new NotImplementedException();
             }
         }
-
-        internal bool IsEncrypted => Folder!._coders.FindIndex(c => c._methodId._id == CMethodId.K_AES_ID) != -1;
     }
 }

src/SharpCompress/Common/SevenZip/SevenZipVolume.cs

@@ -1,4 +1,5 @@
 using System.IO;
+using SharpCompress.Archives;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Common.SevenZip

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

@@ -1,13 +1,11 @@
-#nullable disable
-
-using System;
-using System.Buffers.Binary;
+using System;
 using System.IO;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Tar.Headers
 {
-    internal sealed class TarHeader
+    internal class TarHeader
     {
         internal static readonly DateTime EPOCH = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
@@ -19,9 +17,11 @@ namespace SharpCompress.Common.Tar.Headers
         internal string Name { get; set; }
         internal string LinkName { get; set; }
 
-        internal long Mode { get; set; }
-        internal long UserId { get; set; }
-        internal long GroupId { get; set; }
+        //internal int Mode { get; set; }
+        //internal int UserId { get; set; }
+        //internal string UserName { get; set; }
+        //internal int GroupId { get; set; }
+        //internal string GroupName { get; set; }
         internal long Size { get; set; }
         internal DateTime LastModifiedTime { get; set; }
         internal EntryType EntryType { get; set; }
@@ -49,7 +49,7 @@ namespace SharpCompress.Common.Tar.Headers
             }
             else
             {
-                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
+                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 0, 100);
                 WriteOctalBytes(Size, buffer, 124, 12);
                 var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
                 WriteOctalBytes(time, buffer, 136, 12);
@@ -57,10 +57,11 @@ namespace SharpCompress.Common.Tar.Headers
 
                 if (Size >= 0x1FFFFFFFF)
                 {
-                    Span<byte> bytes12 = stackalloc byte[12];
-                    BinaryPrimitives.WriteInt64BigEndian(bytes12.Slice(4), Size);
+                    byte[] bytes = DataConverter.BigEndian.GetBytes(Size);
+                    var bytes12 = new byte[12];
+                    bytes.CopyTo(bytes12, 12 - bytes.Length);
                     bytes12[0] |= 0x80;
-                    bytes12.CopyTo(buffer.AsSpan(124));
+                    bytes12.CopyTo(buffer, 124);
                 }
             }
 
@@ -95,7 +96,7 @@ namespace SharpCompress.Common.Tar.Headers
             {
                 numPaddingBytes = BLOCK_SIZE;
             }
-            output.Write(stackalloc byte[numPaddingBytes]);
+            output.Write(new byte[numPaddingBytes], 0, numPaddingBytes);
         }
 
         internal bool Read(BinaryReader reader)
@@ -125,12 +126,9 @@ namespace SharpCompress.Common.Tar.Headers
             EntryType = ReadEntryType(buffer);
             Size = ReadSize(buffer);
 
-            Mode = ReadAsciiInt64Base8(buffer, 100, 7);
-            if(EntryType == EntryType.Directory) 
-                Mode |= 0b1_000_000_000;
-
-            UserId = ReadAsciiInt64Base8(buffer, 108, 7);
-            GroupId = ReadAsciiInt64Base8(buffer, 116, 7);
+            //Mode = ReadASCIIInt32Base8(buffer, 100, 7);
+            //UserId = ReadASCIIInt32Base8(buffer, 108, 7);
+            //GroupId = ReadASCIIInt32Base8(buffer, 116, 7);
             long unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
             LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();
 
@@ -178,9 +176,8 @@ namespace SharpCompress.Common.Tar.Headers
         {
             if ((buffer[124] & 0x80) == 0x80) // if size in binary
             {
-                return BinaryPrimitives.ReadInt64BigEndian(buffer.AsSpan(0x80));
+                return DataConverter.BigEndian.GetInt64(buffer, 0x80);
             }
-
             return ReadAsciiInt64Base8(buffer, 124, 11);
         }
 
@@ -195,11 +192,15 @@ namespace SharpCompress.Common.Tar.Headers
             return buffer;
         }
 
-        private static void WriteStringBytes(ReadOnlySpan<byte> name, Span<byte> buffer, int length)
+        private static void WriteStringBytes(byte[] name, byte[] buffer, int offset, int length)
         {
-            name.CopyTo(buffer);
             int i = Math.Min(length, name.Length);
-            buffer.Slice(i, length - i).Clear();
+            Buffer.BlockCopy(name, 0, buffer, offset, i);
+            // if Span<byte>.Fill can be used, it is more efficient
+            for (; i < length; ++i)
+            {
+                buffer[offset + i] = 0;
+            }
         }
 
         private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)
@@ -261,16 +262,10 @@ namespace SharpCompress.Common.Tar.Headers
             return Convert.ToInt64(s);
         }
 
-
-        private static readonly byte[] eightSpaces = {
-            (byte)' ', (byte)' ', (byte)' ', (byte)' ',
-            (byte)' ', (byte)' ', (byte)' ', (byte)' '
-        };
-
         internal static int RecalculateChecksum(byte[] buf)
         {
             // Set default value for checksum. That is 8 spaces.
-            eightSpaces.CopyTo(buf, 148);
+            Encoding.UTF8.GetBytes("        ").CopyTo(buf, 148);
 
             // Calculate checksum
             int headerChecksum = 0;
@@ -283,7 +278,7 @@ namespace SharpCompress.Common.Tar.Headers
 
         internal static int RecalculateAltChecksum(byte[] buf)
         {
-            eightSpaces.CopyTo(buf, 148);
+            Encoding.UTF8.GetBytes("        ").CopyTo(buf, 148);
             int headerChecksum = 0;
             foreach (byte b in buf)
             {

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -1,10 +1,9 @@
-#nullable disable
-
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
+using System.Text;
 
 namespace SharpCompress.Common.Tar
 {
@@ -44,12 +43,6 @@ namespace SharpCompress.Common.Tar
 
         public override bool IsSplitAfter => false;
 
-        public long Mode => _filePart.Header.Mode;
-
-        public long UserID => _filePart.Header.UserId;
-        
-        public long GroupId => _filePart.Header.GroupId;
-
         internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();
 
         internal static IEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,

src/SharpCompress/Common/Tar/TarFilePart.cs

@@ -4,7 +4,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar
 {
-    internal sealed class TarFilePart : FilePart
+    internal class TarFilePart : FilePart
     {
         private readonly Stream _seekableStream;
 
@@ -23,13 +23,13 @@ namespace SharpCompress.Common.Tar
         {
             if (_seekableStream != null)
             {
-                _seekableStream.Position = Header.DataStartPosition!.Value;
-                return new TarReadOnlySubStream(_seekableStream, Header.Size);
+                _seekableStream.Position = Header.DataStartPosition.Value;
+                return new ReadOnlySubStream(_seekableStream, Header.Size);
             }
             return Header.PackedStream;
         }
 
-        internal override Stream? GetRawStream()
+        internal override Stream GetRawStream()
         {
             return null;
         }

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -2,16 +2,17 @@
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
+using System.Text;
 
 namespace SharpCompress.Common.Tar
 {
     internal static class TarHeaderFactory
     {
-        internal static IEnumerable<TarHeader?> ReadHeader(StreamingMode mode, Stream stream, ArchiveEncoding archiveEncoding)
+        internal static IEnumerable<TarHeader> ReadHeader(StreamingMode mode, Stream stream, ArchiveEncoding archiveEncoding)
         {
             while (true)
             {
-                TarHeader? header = null;
+                TarHeader header = null;
                 try
                 {
                     BinaryReader reader = new BinaryReader(stream);

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -20,24 +20,22 @@ namespace SharpCompress.Common.Tar
             {
                 return;
             }
-
             _isDisposed = true;
-
             if (disposing)
             {
-                // Ensure we read all remaining blocks for this entry.
-                Stream.Skip(BytesLeftToRead);
-                _amountRead += BytesLeftToRead;
-
-                // If the last block wasn't a full 512 bytes, skip the remaining padding bytes.
-                var bytesInLastBlock = _amountRead % 512;
-
-                if (bytesInLastBlock != 0)
+                long skipBytes = _amountRead % 512;
+                if (skipBytes == 0)
                 {
-                    Stream.Skip(512 - bytesInLastBlock);
+                    return;
                 }
+                skipBytes = 512 - skipBytes;
+                if (skipBytes == 0)
+                {
+                    return;
+                }
+                var buffer = new byte[skipBytes];
+                Stream.ReadFully(buffer);
             }
-
             base.Dispose(disposing);
         }
 

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

@@ -33,7 +33,7 @@ namespace SharpCompress.Common.Zip.Headers
 
         public ushort CommentLength { get; private set; }
 
-        public byte[]? Comment { get; private set; }
+        public byte[] Comment { get; private set; }
 
         public ushort TotalNumberOfEntries { get; private set; }
 

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

@@ -1,5 +1,6 @@
 using System.IO;
 using System.Linq;
+using System.Text;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -32,7 +33,7 @@ namespace SharpCompress.Common.Zip.Headers
             byte[] name = reader.ReadBytes(nameLength);
             byte[] extra = reader.ReadBytes(extraLength);
             byte[] comment = reader.ReadBytes(commentLength);
-
+            
             // According to .ZIP File Format Specification
             //
             // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
@@ -40,7 +41,7 @@ namespace SharpCompress.Common.Zip.Headers
             // Bit 11: Language encoding flag (EFS).  If this bit is set,
             //         the filename and comment fields for this file
             //         MUST be encoded using UTF-8. (see APPENDIX D)
-
+            
             if (Flags.HasFlag(HeaderFlags.Efs))
             {
                 Name = ArchiveEncoding.DecodeUTF8(name);
@@ -63,8 +64,6 @@ namespace SharpCompress.Common.Zip.Headers
             var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
             if (zip64ExtraData != null)
             {
-                zip64ExtraData.Process(UncompressedSize, CompressedSize, RelativeOffsetOfEntryHeader, DiskNumberStart);
-
                 if (CompressedSize == uint.MaxValue)
                 {
                     CompressedSize = zip64ExtraData.CompressedSize;
@@ -94,6 +93,6 @@ namespace SharpCompress.Common.Zip.Headers
 
         public ushort DiskNumberStart { get; set; }
 
-        public string? Comment { get; private set; }
+        public string Comment { get; private set; }
     }
 }

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

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 
 namespace SharpCompress.Common.Zip.Headers
 {

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

@@ -1,5 +1,6 @@
 using System.IO;
 using System.Linq;
+using System.Text;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -24,7 +25,7 @@ namespace SharpCompress.Common.Zip.Headers
             ushort extraLength = reader.ReadUInt16();
             byte[] name = reader.ReadBytes(nameLength);
             byte[] extra = reader.ReadBytes(extraLength);
-
+            
             // According to .ZIP File Format Specification
             //
             // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
@@ -32,7 +33,7 @@ namespace SharpCompress.Common.Zip.Headers
             // Bit 11: Language encoding flag (EFS).  If this bit is set,
             //         the filename and comment fields for this file
             //         MUST be encoded using UTF-8. (see APPENDIX D)
-
+            
             if (Flags.HasFlag(HeaderFlags.Efs))
             {
                 Name = ArchiveEncoding.DecodeUTF8(name);
@@ -41,7 +42,7 @@ namespace SharpCompress.Common.Zip.Headers
             {
                 Name = ArchiveEncoding.Decode(name);
             }
-
+            
             LoadExtra(extra);
 
             var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
@@ -53,8 +54,6 @@ namespace SharpCompress.Common.Zip.Headers
             var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
             if (zip64ExtraData != null)
             {
-                zip64ExtraData.Process(UncompressedSize, CompressedSize, 0, 0);
-
                 if (CompressedSize == uint.MaxValue)
                 {
                     CompressedSize = zip64ExtraData.CompressedSize;

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

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -18,25 +18,13 @@ namespace SharpCompress.Common.Zip.Headers
 
     internal class ExtraData
     {
-        public ExtraData(ExtraDataType type, ushort length, byte[] dataBytes)
-        {
-            Type = type;
-            Length = length;
-            DataBytes = dataBytes;
-        }
-
-        internal ExtraDataType Type { get; }
-        internal ushort Length { get; }
-        internal byte[] DataBytes { get; }
+        internal ExtraDataType Type { get; set; }
+        internal ushort Length { get; set; }
+        internal byte[] DataBytes { get; set; }
     }
 
-    internal sealed class ExtraUnicodePathExtraField : ExtraData
+    internal class ExtraUnicodePathExtraField : ExtraData
     {
-        public ExtraUnicodePathExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
-            : base(type, length, dataBytes)
-        {
-        }
-
         internal byte Version => DataBytes[0];
 
         internal byte[] NameCrc32
@@ -61,79 +49,70 @@ namespace SharpCompress.Common.Zip.Headers
         }
     }
 
-    internal sealed class Zip64ExtendedInformationExtraField : ExtraData
+    internal class Zip64ExtendedInformationExtraField : ExtraData
     {
+
         public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
-            : base(type, length, dataBytes)
         {
+            Type = type;
+            Length = length;
+            DataBytes = dataBytes;
+            Process();
         }
 
-        // From the spec, values are only in the extradata if the standard
-        // value is set to 0xFFFFFFFF (or 0xFFFF for the Disk Start Number).
-        // Values, if present, must appear in the following order:
-        // - Original Size
-        // - Compressed Size
-        // - Relative Header Offset
-        // - Disk Start Number
-        public void Process(long uncompressedFileSize, long compressedFileSize, long relativeHeaderOffset, ushort diskNumber)
+        //From the spec values are only in the extradata if the standard
+        //value is set to 0xFFFF, but if one of the sizes are present, both are.
+        //Hence if length == 4 volume only
+        //      if length == 8 offset only
+        //      if length == 12 offset + volume
+        //      if length == 16 sizes only
+        //      if length == 20 sizes + volume
+        //      if length == 24 sizes + offset
+        //      if length == 28 everything.
+        //It is unclear how many of these are used in the wild.
+
+        private void Process()
         {
-            var bytesRequired = ((uncompressedFileSize == uint.MaxValue) ? 8 : 0)
-                + ((compressedFileSize == uint.MaxValue) ? 8 : 0)
-                + ((relativeHeaderOffset == uint.MaxValue) ? 8 : 0)
-                + ((diskNumber == ushort.MaxValue) ? 4 : 0);
-            var currentIndex = 0;
-
-            if (bytesRequired > DataBytes.Length)
+            switch (DataBytes.Length)
             {
-                throw new ArchiveException("Zip64 extended information extra field is not large enough for the required information");
-            }
-
-            if (uncompressedFileSize == uint.MaxValue)
-            {
-                UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
-                currentIndex += 8;
-            }
-
-            if (compressedFileSize == uint.MaxValue)
-            {
-                CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
-                currentIndex += 8;
-            }
-
-            if (relativeHeaderOffset == uint.MaxValue)
-            {
-                RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(currentIndex));
-                currentIndex += 8;
-            }
-
-            if (diskNumber == ushort.MaxValue)
-            {
-                VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(currentIndex));
+                case 4:
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 0);
+                    return;
+                case 8:
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    return;
+                case 12:
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 8);
+                    return;
+                case 16:
+                     UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                     CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    return;
+                case 20:
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 16);
+                    return;
+                case 24:
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
+                    return;
+                case 28:
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 24);
+                    return;
+                default:
+                throw new ArchiveException("Unexpected size of of Zip64 extended information extra field");
             }
         }
 
-        /// <summary>
-        /// Uncompressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
-        /// original entry header had a corresponding 0xFFFFFFFF value.
-        /// </summary>
         public long UncompressedSize { get; private set; }
-
-        /// <summary>
-        /// Compressed file size. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
-        /// original entry header had a corresponding 0xFFFFFFFF value.
-        /// </summary>
         public long CompressedSize { get; private set; }
-
-        /// <summary>
-        /// Relative offset of the entry header. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
-        /// original entry header had a corresponding 0xFFFFFFFF value.
-        /// </summary>
         public long RelativeOffsetOfEntryHeader { get; private set; }
-
-        /// <summary>
-        /// Volume number. Only valid after <see cref="Process(long, long, long, ushort)"/> has been called and if the
-        /// original entry header had a corresponding 0xFFFF value.
-        /// </summary>
         public uint VolumeNumber { get; private set; }
     }
 
@@ -141,12 +120,30 @@ namespace SharpCompress.Common.Zip.Headers
     {
         internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extraData)
         {
-            return type switch
+            switch (type)
             {
-                ExtraDataType.UnicodePathExtraField => new ExtraUnicodePathExtraField(type, length, extraData),
-                ExtraDataType.Zip64ExtendedInformationExtraField => new Zip64ExtendedInformationExtraField(type, length, extraData),
-                _ => new ExtraData(type, length, extraData)
-            };
+                case ExtraDataType.UnicodePathExtraField:
+                    return new ExtraUnicodePathExtraField
+                           {
+                               Type = type,
+                               Length = length,
+                               DataBytes = extraData
+                           };
+                case ExtraDataType.Zip64ExtendedInformationExtraField:
+                    return new Zip64ExtendedInformationExtraField
+                            (
+                                type, 
+                                length,
+                                extraData
+                           );
+                default:
+                    return new ExtraData
+                           {
+                               Type = type,
+                               Length = length,
+                               DataBytes = extraData
+                           };
+            }
         }
     }
-}
+}

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

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -43,6 +44,6 @@ namespace SharpCompress.Common.Zip.Headers
 
         public long DirectoryStartOffsetRelativeToDisk { get; private set; }
 
-        public byte[]? DataSector { get; private set; }
+        public byte[] DataSector { get; private set; }
     }
 }

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

@@ -1,9 +1,8 @@
-#nullable disable
-
-using System;
-using System.Buffers.Binary;
+using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -20,7 +19,7 @@ namespace SharpCompress.Common.Zip.Headers
         {
             get
             {
-                if (Name.EndsWith('/'))
+                if (Name.EndsWith("/"))
                 {
                     return true;
                 }
@@ -28,10 +27,10 @@ namespace SharpCompress.Common.Zip.Headers
                 //.NET Framework 4.5 : System.IO.Compression::CreateFromDirectory() probably writes backslashes to headers
                 return CompressedSize == 0
                        && UncompressedSize == 0
-                       && Name.EndsWith('\\');
+                       && Name.EndsWith("\\");
             }
         }
-
+        
         internal Stream PackedStream { get; set; }
 
         internal ArchiveEncoding ArchiveEncoding { get; }
@@ -54,7 +53,7 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal PkwareTraditionalEncryptionData ComposeEncryptionData(Stream archiveStream)
         {
-            if (archiveStream is null)
+            if (archiveStream == null)
             {
                 throw new ArgumentNullException(nameof(archiveStream));
             }
@@ -62,11 +61,11 @@ namespace SharpCompress.Common.Zip.Headers
             var buffer = new byte[12];
             archiveStream.ReadFully(buffer);
 
-            PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password!, this, buffer);
+            PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password, this, buffer);
 
             return encryptionData;
         }
-
+        
         internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
 
         internal ushort LastModifiedDate { get; set; }
@@ -79,13 +78,13 @@ namespace SharpCompress.Common.Zip.Headers
         {
             for (int i = 0; i < extra.Length - 4;)
             {
-                ExtraDataType type = (ExtraDataType)BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i));
+                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
                 if (!Enum.IsDefined(typeof(ExtraDataType), type))
                 {
                     type = ExtraDataType.NotImplementedExtraData;
                 }
 
-                ushort length = BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i + 2));
+                ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
 
                 // 7zip has this same kind of check to ignore extras blocks that don't conform to the standard 2-byte ID, 2-byte length, N-byte value.
                 // CPP/7Zip/Zip/ZipIn.cpp: CInArchive::ReadExtra
@@ -105,6 +104,6 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal ZipFilePart Part { get; set; }
 
-        internal bool IsZip64 => CompressedSize >= uint.MaxValue;
+        internal bool IsZip64 => CompressedSize == uint.MaxValue;
     }
 }

src/SharpCompress/Common/Zip/PkwareTraditionalCryptoStream.cs

@@ -40,7 +40,7 @@ namespace SharpCompress.Common.Zip
                 throw new NotSupportedException("This stream does not encrypt via Read()");
             }
 
-            if (buffer is null)
+            if (buffer == null)
             {
                 throw new ArgumentNullException(nameof(buffer));
             }
@@ -64,7 +64,7 @@ namespace SharpCompress.Common.Zip
                 return;
             }
 
-            byte[] plaintext;
+            byte[] plaintext = null;
             if (offset != 0)
             {
                 plaintext = new byte[count];

src/SharpCompress/Common/Zip/PkwareTraditionalEncryptionData.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Text;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 
@@ -7,7 +8,7 @@ namespace SharpCompress.Common.Zip
     internal class PkwareTraditionalEncryptionData
     {
         private static readonly CRC32 CRC32 = new CRC32();
-        private readonly UInt32[] _keys = { 0x12345678, 0x23456789, 0x34567890 };
+        private readonly UInt32[] _keys = {0x12345678, 0x23456789, 0x34567890};
         private readonly ArchiveEncoding _archiveEncoding;
 
         private PkwareTraditionalEncryptionData(string password, ArchiveEncoding archiveEncoding)
@@ -64,9 +65,9 @@ namespace SharpCompress.Common.Zip
 
         public byte[] Encrypt(byte[] plainText, int length)
         {
-            if (plainText is null)
+            if (plainText == null)
             {
-                throw new ArgumentNullException(nameof(plainText));
+                throw new ArgumentNullException("plaintext");
             }
 
             if (length > plainText.Length)

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -27,25 +27,25 @@ namespace SharpCompress.Common.Zip
             return base.GetCompressedStream();
         }
 
-        internal string? Comment => ((DirectoryEntryHeader)Header).Comment;
+        internal string Comment => (Header as DirectoryEntryHeader).Comment;
 
         private void LoadLocalHeader()
         {
             bool hasData = Header.HasData;
-            Header = _headerFactory.GetLocalHeader(BaseStream, ((DirectoryEntryHeader)Header));
+            Header = _headerFactory.GetLocalHeader(BaseStream, Header as DirectoryEntryHeader);
             Header.HasData = hasData;
         }
 
         protected override Stream CreateBaseStream()
         {
-            BaseStream.Position = Header.DataStartPosition!.Value;
+            BaseStream.Position = Header.DataStartPosition.Value;
 
             if ((Header.CompressedSize == 0)
                 && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)
                 && (_directoryEntryHeader?.HasData == true)
                 && (_directoryEntryHeader?.CompressedSize != 0))
             {
-                return new ReadOnlySubStream(BaseStream, _directoryEntryHeader!.CompressedSize);
+                return new ReadOnlySubStream(BaseStream, _directoryEntryHeader.CompressedSize);
             }
 
             return BaseStream;