run CI on release branch

Fix: Should not throw on ARJ detection

.config/dotnet-tools.json

@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "csharpier": {
+      "version": "1.2.1",
+      "commands": [
+        "csharpier"
+      ],
+      "rollForward": false
+    }
+  }
+}

.copilot-agent.yml

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

.editorconfig

@@ -0,0 +1,568 @@
+# 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 = silent
+
+##########################################
+# File Header (Uncomment to support file headers)
+# https://docs.microsoft.com/visualstudio/ide/reference/add-file-header
+##########################################
+
+# [*.{cs,csx,cake,vb,vbx}]
+# file_header_template = <copyright file="{fileName}" company="PROJECT-AUTHOR">\n© PROJECT-AUTHOR\n</copyright>
+
+# SA1636: File header copyright text should match
+# Justification: .editorconfig supports file headers. If this is changed to a value other than "none", a stylecop.json file will need to added to the project.
+# dotnet_diagnostic.SA1636.severity = none
+
+##########################################
+# .NET Language Conventions
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions
+##########################################
+
+# .NET Code Style Settings
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#net-code-style-settings
+[*.{cs,csx,cake,vb,vbx}]
+# "this." and "Me." qualifiers
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#this-and-me
+#dotnet_style_qualification_for_field = true:warning
+#dotnet_style_qualification_for_property = true:warning
+#dotnet_style_qualification_for_method = true:warning
+#dotnet_style_qualification_for_event = true:warning
+# Language keywords instead of framework type names for type references
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#language-keywords
+dotnet_style_predefined_type_for_locals_parameters_members = true:warning
+dotnet_style_predefined_type_for_member_access = true:warning
+# Modifier preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#normalize-modifiers
+dotnet_style_require_accessibility_modifiers = always:warning
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:warning
+visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:warning
+dotnet_style_readonly_field = true:warning
+# Parentheses preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parentheses-preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:warning
+dotnet_style_parentheses_in_other_operators = always_for_clarity:suggestion
+# Expression-level preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
+dotnet_style_object_initializer = true:warning
+dotnet_style_collection_initializer = true:warning
+dotnet_style_explicit_tuple_names = true:warning
+dotnet_style_prefer_inferred_tuple_names = true:warning
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
+dotnet_style_prefer_auto_properties = true:warning
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
+dotnet_style_prefer_conditional_expression_over_assignment = false:suggestion
+dotnet_diagnostic.IDE0045.severity = suggestion
+dotnet_style_prefer_conditional_expression_over_return = false:suggestion
+dotnet_diagnostic.IDE0046.severity = suggestion
+dotnet_style_prefer_compound_assignment = true:warning
+# Null-checking preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#null-checking-preferences
+dotnet_style_coalesce_expression = true:warning
+dotnet_style_null_propagation = true:warning
+# Parameter preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#parameter-preferences
+dotnet_code_quality_unused_parameters = all:warning
+# More style options (Undocumented)
+# https://github.com/MicrosoftDocs/visualstudio-docs/issues/3641
+dotnet_style_operator_placement_when_wrapping = end_of_line
+# https://github.com/dotnet/roslyn/pull/40070
+dotnet_style_prefer_simplified_interpolation = true:warning
+
+# C# Code Style Settings
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-code-style-settings
+[*.{cs,csx,cake}]
+# Implicit and explicit types
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#implicit-and-explicit-types
+csharp_style_var_for_built_in_types = true:warning
+csharp_style_var_when_type_is_apparent = true:warning
+csharp_style_var_elsewhere = true:warning
+# Expression-bodied members
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-bodied-members
+csharp_style_expression_bodied_methods = true:warning
+csharp_style_expression_bodied_constructors = true:warning
+csharp_style_expression_bodied_operators = true:warning
+csharp_style_expression_bodied_properties = true:warning
+csharp_style_expression_bodied_indexers = true:warning
+csharp_style_expression_bodied_accessors = true:warning
+csharp_style_expression_bodied_lambdas = true:warning
+csharp_style_expression_bodied_local_functions = true:warning
+# Pattern matching
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#pattern-matching
+csharp_style_pattern_matching_over_is_with_cast_check = true:warning
+csharp_style_pattern_matching_over_as_with_null_check = true:warning
+# Inlined variable declarations
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#inlined-variable-declarations
+csharp_style_inlined_variable_declaration = true:warning
+# Expression-level preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#expression-level-preferences
+csharp_prefer_simple_default_expression = true:warning
+# "Null" checking preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#c-null-checking-preferences
+csharp_style_throw_expression = true:warning
+csharp_style_conditional_delegate_call = true:warning
+# Code block preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#code-block-preferences
+csharp_prefer_braces = true:warning
+# Unused value preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#unused-value-preferences
+csharp_style_unused_value_expression_statement_preference = discard_variable:suggestion
+dotnet_diagnostic.IDE0058.severity = suggestion
+csharp_style_unused_value_assignment_preference = discard_variable:suggestion
+dotnet_diagnostic.IDE0059.severity = suggestion
+# Index and range preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#index-and-range-preferences
+csharp_style_prefer_index_operator = true:warning
+csharp_style_prefer_range_operator = true:warning
+# Miscellaneous preferences
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-language-conventions#miscellaneous-preferences
+csharp_style_deconstructed_variable_declaration = true:warning
+csharp_style_pattern_local_over_anonymous_function = true:warning
+csharp_using_directive_placement = outside_namespace:warning
+csharp_prefer_static_local_function = true:warning
+csharp_prefer_simple_using_statement = true:suggestion
+dotnet_diagnostic.IDE0063.severity = suggestion
+
+##########################################
+# .NET Formatting Conventions
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-code-style-settings-reference#formatting-conventions
+##########################################
+
+# Organize usings
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#organize-using-directives
+dotnet_sort_system_directives_first = true
+# Newline options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#new-line-options
+csharp_new_line_before_open_brace = all
+csharp_new_line_before_else = true
+csharp_new_line_before_catch = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_between_query_expression_clauses = true
+# Indentation options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#indentation-options
+csharp_indent_case_contents = true
+csharp_indent_switch_labels = true
+csharp_indent_labels = no_change
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents_when_block = false
+# Spacing options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#spacing-options
+csharp_space_after_cast = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_between_parentheses = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_after_comma = true
+csharp_space_before_comma = false
+csharp_space_after_dot = false
+csharp_space_before_dot = false
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_around_declaration_statements = false
+csharp_space_before_open_square_brackets = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_square_brackets = false
+# Wrapping options
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-formatting-conventions#wrap-options
+csharp_preserve_single_line_statements = false
+csharp_preserve_single_line_blocks = true
+
+csharp_style_namespace_declarations = file_scoped
+
+##########################################
+# .NET Naming Conventions
+# https://docs.microsoft.com/visualstudio/ide/editorconfig-naming-conventions
+##########################################
+
+[*.{cs,csx,cake,vb,vbx}]
+dotnet_diagnostic.CA1000.severity = suggestion
+dotnet_diagnostic.CA1001.severity = error
+dotnet_diagnostic.CA1018.severity = error
+dotnet_diagnostic.CA1036.severity = silent
+dotnet_diagnostic.CA1051.severity = suggestion
+dotnet_diagnostic.CA1068.severity = error
+dotnet_diagnostic.CA1069.severity = error
+dotnet_diagnostic.CA1304.severity = error
+dotnet_diagnostic.CA1305.severity = suggestion
+dotnet_diagnostic.CA1307.severity = suggestion
+dotnet_diagnostic.CA1309.severity = suggestion
+dotnet_diagnostic.CA1310.severity = error
+dotnet_diagnostic.CA1507.severity = suggestion
+dotnet_diagnostic.CA1513.severity = suggestion
+dotnet_diagnostic.CA1707.severity = suggestion
+dotnet_diagnostic.CA1708.severity = suggestion
+dotnet_diagnostic.CA1711.severity = suggestion
+dotnet_diagnostic.CA1716.severity = suggestion
+dotnet_diagnostic.CA1720.severity = suggestion
+dotnet_diagnostic.CA1725.severity = suggestion
+dotnet_diagnostic.CA1805.severity = suggestion
+dotnet_diagnostic.CA1816.severity = suggestion
+dotnet_diagnostic.CA1822.severity = suggestion
+dotnet_diagnostic.CA1825.severity = error
+dotnet_diagnostic.CA1826.severity = silent
+dotnet_diagnostic.CA1827.severity = error
+dotnet_diagnostic.CA1829.severity = suggestion
+dotnet_diagnostic.CA1834.severity = error
+dotnet_diagnostic.CA1845.severity = suggestion
+dotnet_diagnostic.CA1848.severity = suggestion
+dotnet_diagnostic.CA1852.severity = suggestion
+dotnet_diagnostic.CA1860.severity = silent
+dotnet_diagnostic.CA2016.severity = suggestion
+dotnet_diagnostic.CA2201.severity = error
+dotnet_diagnostic.CA2206.severity = error
+dotnet_diagnostic.CA2208.severity = error
+dotnet_diagnostic.CA2211.severity = error
+dotnet_diagnostic.CA2249.severity = error
+dotnet_diagnostic.CA2251.severity = error
+dotnet_diagnostic.CA2252.severity = none
+dotnet_diagnostic.CA2254.severity = suggestion
+
+dotnet_diagnostic.CS0169.severity = error
+dotnet_diagnostic.CS0219.severity = error
+dotnet_diagnostic.CS0649.severity = suggestion
+dotnet_diagnostic.CS1998.severity = error
+dotnet_diagnostic.CS8602.severity = error
+dotnet_diagnostic.CS8604.severity = error
+dotnet_diagnostic.CS8618.severity = error
+dotnet_diagnostic.CS0618.severity = suggestion
+dotnet_diagnostic.CS1998.severity = error
+dotnet_diagnostic.CS4014.severity = error
+dotnet_diagnostic.CS8600.severity = error
+dotnet_diagnostic.CS8603.severity = error
+dotnet_diagnostic.CS8625.severity = error
+
+dotnet_diagnostic.BL0005.severity = suggestion
+
+dotnet_diagnostic.MVC1000.severity = suggestion
+
+dotnet_diagnostic.RZ10012.severity = error
+
+dotnet_diagnostic.IDE0004.severity = error # redundant cast
+dotnet_diagnostic.IDE0005.severity = suggestion
+dotnet_diagnostic.IDE0007.severity = error # Use var
+dotnet_diagnostic.IDE0011.severity = error # Use braces on if statements
+dotnet_diagnostic.IDE0010.severity = silent # populate switch
+dotnet_diagnostic.IDE0017.severity = suggestion # initialization can be simplified
+dotnet_diagnostic.IDE0021.severity = silent # expression body for constructors
+dotnet_diagnostic.IDE0022.severity = silent # expression body for methods
+dotnet_diagnostic.IDE0023.severity = suggestion # use expression body for operators
+dotnet_diagnostic.IDE0024.severity = silent # expression body for operators
+dotnet_diagnostic.IDE0025.severity = suggestion # use expression body for properties
+dotnet_diagnostic.IDE0027.severity = suggestion # Use expression body for accessors
+dotnet_diagnostic.IDE0028.severity = silent # expression body for accessors
+dotnet_diagnostic.IDE0032.severity = suggestion # Use auto property
+dotnet_diagnostic.IDE0033.severity = error # prefer tuple name
+dotnet_diagnostic.IDE0037.severity = suggestion # simplify anonymous type
+dotnet_diagnostic.IDE0040.severity = error # modifiers required
+dotnet_diagnostic.IDE0041.severity = error # simplify null
+dotnet_diagnostic.IDE0042.severity = error # deconstruct variable
+dotnet_diagnostic.IDE0044.severity = suggestion # make field only when possible
+dotnet_diagnostic.IDE0047.severity = suggestion # parameter name
+dotnet_diagnostic.IDE0051.severity = error # unused field
+dotnet_diagnostic.IDE0052.severity = error # unused member
+dotnet_diagnostic.IDE0053.severity = suggestion # lambda not needed
+dotnet_diagnostic.IDE0055.severity = suggestion # Fix formatting
+dotnet_diagnostic.IDE0057.severity = suggestion # substring can be simplified
+dotnet_diagnostic.IDE0060.severity = suggestion # unused parameters
+dotnet_diagnostic.IDE0061.severity = suggestion # local expression body
+dotnet_diagnostic.IDE0062.severity = suggestion # local to static
+dotnet_diagnostic.IDE0063.severity = error # simplify using
+dotnet_diagnostic.IDE0066.severity = suggestion # switch expression
+dotnet_diagnostic.IDE0072.severity = suggestion # Populate switch - forces population of all cases even when default specified
+dotnet_diagnostic.IDE0078.severity = suggestion # use pattern matching
+dotnet_diagnostic.IDE0090.severity = suggestion # new can be simplified
+dotnet_diagnostic.IDE0130.severity = suggestion # namespace folder structure
+dotnet_diagnostic.IDE0160.severity = silent # Use block namespaces ARE NOT required
+dotnet_diagnostic.IDE0161.severity = error # Please use file namespaces
+dotnet_diagnostic.IDE0200.severity = suggestion # lambda not needed
+dotnet_diagnostic.IDE1006.severity = suggestion # Naming rule violation: These words cannot contain lower case characters
+dotnet_diagnostic.IDE0260.severity = suggestion # Use pattern matching
+dotnet_diagnostic.IDE0270.severity = suggestion # Null check simplifcation
+dotnet_diagnostic.IDE0290.severity = error # Primary Constructor
+dotnet_diagnostic.IDE0300.severity = suggestion # Collection
+dotnet_diagnostic.IDE0305.severity = suggestion # Collection ToList
+
+dotnet_diagnostic.NX0001.severity = error
+dotnet_diagnostic.NX0002.severity = silent
+dotnet_diagnostic.NX0003.severity = silent
+
+##########################################
+# Styles
+##########################################
+
+# 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/COPILOT_AGENT_README.md

@@ -0,0 +1,15 @@
+# Copilot Coding Agent Configuration
+
+This repository includes a minimal opt-in configuration and CI workflow to allow the GitHub Copilot coding agent to open and validate PRs.
+
+- .copilot-agent.yml: opt-in config for automated agents
+- .github/agents/copilot-agent.yml: detailed agent policy configuration
+- .github/workflows/dotnetcore.yml: CI runs on PRs touching the solution, source, or tests to validate changes
+- AGENTS.md: general instructions for Copilot coding agent with project-specific guidelines
+
+Maintainers can adjust the allowed paths or disable the agent by editing or removing .copilot-agent.yml.
+
+Notes:
+- The agent can create, modify, and delete files within the allowed paths (src, tests, README.md, AGENTS.md)
+- All changes require review before merge
+- If build/test paths are different, update the workflow accordingly; this workflow targets SharpCompress.sln and the SharpCompress.Test test project.

.github/agents/copilot-agent.yml

@@ -0,0 +1,17 @@
+enabled: true
+agent:
+  name: copilot-coding-agent
+  allow:
+    - paths: ["src/**/*", "tests/**/*", "README.md", "AGENTS.md"]
+      actions: ["create", "modify", "delete"]
+  require_review_before_merge: true
+  required_approvals: 1
+  allowed_merge_strategies:
+    - squash
+    - merge
+  auto_merge_on_green: false
+  run_workflows: true
+notes: |
+  - This manifest expresses the policy for the Copilot coding agent in this repository.
+  - It does NOT install or authorize the agent; a repository admin must install the Copilot coding agent app and grant the repository the necessary permissions (contents: write, pull_requests: write, checks: write, actions: write/read, issues: write) to allow the agent to act.
+  - Keep allow paths narrow and prefer require_review_before_merge during initial rollout.

.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/" 
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "nuget"
+    directory: "/"    # change to "/src/YourProject" if .csproj files are in subfolders
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 5
+    # optional: target-branch: "master"

.github/workflows/dotnetcore.yml

@@ -1,5 +1,11 @@
 name: SharpCompress
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - 'master'
+      - 'release'
+  pull_request:
+    types: [ opened, synchronize, reopened, ready_for_review ]
 
 jobs:
   build:
@@ -9,16 +15,12 @@ jobs:
         os: [windows-latest, ubuntu-latest]
 
     steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-dotnet@v1
+    - uses: actions/checkout@v6
+    - uses: actions/setup-dotnet@v5
       with:
-        dotnet-version: 3.1.302
-    - run: dotnet run -p build/build.csproj
-    - uses: actions/upload-artifact@v2
+        dotnet-version: 8.0.x
+    - run: dotnet run --project build/build.csproj
+    - uses: actions/upload-artifact@v5
       with:
         name: ${{ matrix.os }}-sharpcompress.nupkg
         path: artifacts/*
-    - uses: actions/upload-artifact@v2
-      with:
-        name: ${{ matrix.os }}-sharpcompress.snupkg
-        path: artifacts/*

.gitignore

@@ -11,6 +11,8 @@ TestResults/
 packages/*/
 project.lock.json
 tests/TestArchives/Scratch
+tests/TestArchives/*/Scratch
+tests/TestArchives/*/Scratch2
 .vs
 tools
 .vscode

AGENTS.md

@@ -0,0 +1,118 @@
+---
+description: 'Guidelines for building SharpCompress - A C# compression library'
+applyTo: '**/*.cs'
+---
+
+# SharpCompress Development
+
+## About SharpCompress
+SharpCompress is a pure C# compression library supporting multiple archive formats (Zip, Tar, GZip, BZip2, 7Zip, Rar, LZip, XZ, ZStandard) for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0, and .NET 8.0. The library provides both seekable Archive APIs and forward-only Reader/Writer APIs for streaming scenarios.
+
+## C# Instructions
+- Always use the latest version C#, currently C# 13 features.
+- Write clear and concise comments for each function.
+- Follow the existing code style and patterns in the codebase.
+
+## General Instructions
+- Make only high confidence suggestions when reviewing code changes.
+- Write code with good maintainability practices, including comments on why certain design decisions were made.
+- Handle edge cases and write clear exception handling.
+- For libraries or external dependencies, mention their usage and purpose in comments.
+- Preserve backward compatibility when making changes to public APIs.
+
+## Naming Conventions
+
+- Follow PascalCase for component names, method names, and public members.
+- Use camelCase for private fields and local variables.
+- Prefix interface names with "I" (e.g., IUserService).
+
+## Code Formatting
+
+- Use CSharpier for code formatting to ensure consistent style across the project
+- CSharpier is configured as a local tool in `.config/dotnet-tools.json`
+- Restore tools with: `dotnet tool restore`
+- Format files from the project root with: `dotnet csharpier .`
+- **Run `dotnet csharpier .` from the project root after making code changes before committing**
+- Configure your IDE to format on save using CSharpier for the best experience
+- The project also uses `.editorconfig` for editor settings (indentation, encoding, etc.)
+- Let CSharpier handle code style while `.editorconfig` handles editor behavior
+
+## Project Setup and Structure
+
+- The project targets multiple frameworks: .NET Framework 4.62, .NET Standard 2.1, .NET 6.0, and .NET 8.0
+- Main library is in `src/SharpCompress/`
+- Tests are in `tests/SharpCompress.Test/`
+- Performance tests are in `tests/SharpCompress.Performance/`
+- Test archives are in `tests/TestArchives/`
+- Build project is in `build/`
+- Use `dotnet build` to build the solution
+- Use `dotnet test` to run tests
+- Solution file: `SharpCompress.sln`
+
+## Nullable Reference Types
+
+- Declare variables non-nullable, and check for `null` at entry points.
+- Always use `is null` or `is not null` instead of `== null` or `!= null`.
+- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null.
+
+## SharpCompress-Specific Guidelines
+
+### Supported Formats
+SharpCompress supports multiple archive and compression formats:
+- **Archive Formats**: Zip, Tar, 7Zip, Rar (read-only)
+- **Compression**: DEFLATE, BZip2, LZMA/LZMA2, PPMd, ZStandard (decompress only), Deflate64 (decompress only)
+- **Combined Formats**: Tar.GZip, Tar.BZip2, Tar.LZip, Tar.XZ, Tar.ZStandard
+- See FORMATS.md for complete format support matrix
+
+### Stream Handling Rules
+- **Disposal**: As of version 0.21, SharpCompress closes wrapped streams by default
+- Use `ReaderOptions` or `WriterOptions` with `LeaveStreamOpen = true` to control stream disposal
+- Use `NonDisposingStream` wrapper when working with compression streams directly to prevent disposal
+- Always dispose of readers, writers, and archives in `using` blocks
+- For forward-only operations, use Reader/Writer APIs; for random access, use Archive APIs
+
+### Async/Await Patterns
+- All I/O operations support async/await with `CancellationToken`
+- Async methods follow the naming convention: `MethodNameAsync`
+- Key async methods:
+  - `WriteEntryToAsync` - Extract entry asynchronously
+  - `WriteAllToDirectoryAsync` - Extract all entries asynchronously
+  - `WriteAsync` - Write entry asynchronously
+  - `WriteAllAsync` - Write directory asynchronously
+  - `OpenEntryStreamAsync` - Open entry stream asynchronously
+- Always provide `CancellationToken` parameter in async methods
+
+### Archive APIs vs Reader/Writer APIs
+- **Archive API**: Use for random access with seekable streams (e.g., `ZipArchive`, `TarArchive`)
+- **Reader API**: Use for forward-only reading on non-seekable streams (e.g., `ZipReader`, `TarReader`)
+- **Writer API**: Use for forward-only writing on streams (e.g., `ZipWriter`, `TarWriter`)
+- 7Zip only supports Archive API due to format limitations
+
+### Tar-Specific Considerations
+- Tar format requires file size in the header
+- If no size is specified to TarWriter and the stream is not seekable, an exception will be thrown
+- Tar combined with compression (GZip, BZip2, LZip, XZ) is supported
+
+### Zip-Specific Considerations
+- Supports Zip64 for large files (seekable streams only)
+- Supports PKWare and WinZip AES encryption
+- Multiple compression methods: None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA, PPMd
+- Encrypted LZMA is not supported
+
+### Performance Considerations
+- For large files, use Reader/Writer APIs with non-seekable streams to avoid loading entire file in memory
+- Leverage async I/O for better scalability
+- Consider compression level trade-offs (speed vs. size)
+- Use appropriate buffer sizes for stream operations
+
+## Testing
+
+- Always include test cases for critical paths of the application.
+- Test with multiple archive formats when making changes to core functionality.
+- Include tests for both Archive and Reader/Writer APIs when applicable.
+- Test async operations with cancellation tokens.
+- Do not emit "Act", "Arrange" or "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Use test archives from `tests/TestArchives` directory for consistency.
+- Test stream disposal and `LeaveStreamOpen` behavior.
+- Test edge cases: empty archives, large files, corrupted archives, encrypted archives.

Directory.Build.props

@@ -0,0 +1,16 @@
+<Project>
+  <PropertyGroup>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <AnalysisMode>Recommended</AnalysisMode>
+    <WarningsAsErrors>true</WarningsAsErrors>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <RunAnalyzersDuringLiveAnalysis>False</RunAnalyzersDuringLiveAnalysis>
+    <RunAnalyzersDuringBuild>False</RunAnalyzersDuringBuild>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+    <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+  </PropertyGroup>
+</Project>

Directory.Packages.props

@@ -0,0 +1,21 @@
+<Project>
+  <ItemGroup>
+    <PackageVersion Include="Bullseye" Version="6.0.0" />
+    <PackageVersion Include="AwesomeAssertions" Version="9.3.0" />
+    <PackageVersion Include="Glob" Version="1.1.9" />
+    <PackageVersion Include="JetBrains.Profiler.SelfApi" Version="2.5.14" />
+    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageVersion Include="Mono.Posix.NETStandard" Version="1.0.0" />
+    <PackageVersion Include="SimpleExec" Version="12.0.0" />
+    <PackageVersion Include="System.Buffers" Version="4.6.1" />
+    <PackageVersion Include="System.Memory" Version="4.6.3" />
+    <PackageVersion Include="System.Text.Encoding.CodePages" Version="8.0.0" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="ZstdSharp.Port" Version="0.8.6" />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="8.0.21" />
+    <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NETFramework.ReferenceAssemblies" Version="1.0.3" />
+  </ItemGroup>
+</Project>

FORMATS.md

@@ -11,15 +11,15 @@
 | Archive Format         | Compression Format(s)                             | Compress/Decompress | Archive API     | Reader API | Writer API    |
 | ---------------------- | ------------------------------------------------- | ------------------- | --------------- | ---------- | ------------- |
 | Rar                    | Rar                                               | Decompress (1)      | RarArchive      | RarReader  | N/A           |
-| Zip (2)                | None, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd | Both                | ZipArchive      | ZipReader  | ZipWriter     |
+| Zip (2)                | None, Shrink, Reduce, Implode, DEFLATE, Deflate64, BZip2, LZMA/LZMA2, PPMd                           | Both                | ZipArchive      | ZipReader  | ZipWriter     | 
 | Tar                    | None                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.GZip               | DEFLATE                                           | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.BZip2              | BZip2                                             | Both                | TarArchive      | TarReader  | TarWriter (3) |
+| Tar.Zstandard          | ZStandard                                         | Decompress          | TarArchive      | TarReader  | N/A |
 | Tar.LZip               | LZMA                                              | Both                | TarArchive      | TarReader  | TarWriter (3) |
 | Tar.XZ                 | LZMA2                                             | Decompress          | TarArchive      | TarReader  | TarWriter (3) |
 | GZip (single file)     | DEFLATE                                           | Both                | GZipArchive     | GZipReader | GZipWriter    |
 | 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.
@@ -42,6 +42,7 @@ For those who want to directly compress/decompress bits. The single file formats
 | ADCStream       | Decompress          |
 | LZipStream      | Both                |
 | XZStream        | Decompress          |
+| ZStandardStream | Decompress          |
 
 ## Archive Formats vs Compression
 

NuGet.config

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSourceMapping>
+    <!-- key value for <packageSource> should match key values from <packageSources> element -->
+    <packageSource key="nuget.org">
+      <package pattern="*" />
+    </packageSource>
+  </packageSourceMapping>
+</configuration>

README.md

@@ -1,11 +1,14 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1 and NET 4.6 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Framework 4.62, .NET Standard 2.1, .NET 6.0 and NET 8.0 that can unrar, un7zip, unzip, untar unbzip2, ungzip, unlzip, unzstd, unarc and unarj with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip/lzip are implemented.
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
+**NEW:** All I/O operations now support async/await for improved performance and scalability. See the [Async Usage](#async-usage) section below.
+
 GitHub Actions Build -
-[![GitHubActions](https://github.com/adamhathcock/sharpcompress/workflows/SharpCompress/badge.svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
+[![SharpCompress](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml/badge.svg)](https://github.com/adamhathcock/sharpcompress/actions/workflows/dotnetcore.yml)
+[![Static Badge](https://img.shields.io/badge/API%20Docs-DNDocs-190088?logo=readme&logoColor=white)](https://dndocs.com/d/sharpcompress/api/index.html)
 
 ## Need Help?
 
@@ -19,29 +22,110 @@ In general, I recommend GZip (Deflate)/BZip2 (BZip)/LZip (LZMA) as the simplicit
 
 Zip is okay, but it's a very hap-hazard format and the variation in headers and implementations makes it hard to get correct. Uses Deflate by default but supports a lot of compression methods.
 
-RAR is not recommended as it's a propriatory format and the compression is closed source. Use Tar/LZip for LZMA
+RAR is not recommended as it's a proprietary format and the compression is closed source. Use Tar/LZip for LZMA
 
 7Zip and XZ both are overly complicated. 7Zip does not support streamable formats. XZ has known holes explained here: (http://www.nongnu.org/lzip/xz_inadequate.html) Use Tar/LZip for LZMA compression instead.
 
+ZStandard is an efficient format that works well for streaming with a flexible compression level to tweak the speed/performance trade off you are looking for.  We currently only implement decompression for ZStandard but as we leverage the [ZstdSharp](https://github.com/oleg-st/ZstdSharp) library one could likely add compression support without much trouble (PRs are welcome!).
+
 ## A Simple Request
 
 Hi everyone. I hope you're using SharpCompress and finding it useful. Please give me feedback on what you'd like to see changed especially as far as usability goes. New feature suggestions are always welcome as well. I would also like to know what projects SharpCompress is being used in. I like seeing how it is used to give me ideas for future versions. Thanks!
 
 Please do not email me directly to ask for help. If you think there is a real issue, please report it here.
 
+## Async Usage
+
+SharpCompress now provides full async/await support for all I/O operations, allowing for better performance and scalability in modern applications.
+
+### Async Reading Examples
+
+Extract entries asynchronously:
+```csharp
+using (Stream stream = File.OpenRead("archive.zip"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            // Async extraction
+            await reader.WriteEntryToDirectoryAsync(
+                @"C:\temp",
+                new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+                cancellationToken
+            );
+        }
+    }
+}
+```
+
+Extract all entries to directory asynchronously:
+```csharp
+using (Stream stream = File.OpenRead("archive.tar.gz"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    await reader.WriteAllToDirectoryAsync(
+        @"C:\temp",
+        new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+        cancellationToken
+    );
+}
+```
+
+Open entry stream asynchronously:
+```csharp
+using (var archive = ZipArchive.Open("archive.zip"))
+{
+    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
+    {
+        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+        {
+            // Process stream asynchronously
+            await entryStream.CopyToAsync(outputStream, cancellationToken);
+        }
+    }
+}
+```
+
+### Async Writing Examples
+
+Write files asynchronously:
+```csharp
+using (Stream stream = File.OpenWrite("output.zip"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    await writer.WriteAsync("file1.txt", fileStream, DateTime.Now, cancellationToken);
+}
+```
+
+Write all files from directory asynchronously:
+```csharp
+using (Stream stream = File.OpenWrite("output.tar.gz"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+{
+    await writer.WriteAllAsync(@"D:\files", "*", SearchOption.AllDirectories, cancellationToken);
+}
+```
+
+All async methods support `CancellationToken` for graceful cancellation of long-running operations.
+
 ## Want to contribute?
 
 I'm always looking for help or ideas. Please submit code or email with ideas. Unfortunately, just letting me know you'd like to help is not enough because I really have no overall plan of what needs to be done. I'll definitely accept code submissions and add you as a member of the project!
 
 ## TODOs (always lots)
 
-* RAR 5 decryption support
+* RAR 5 decryption crc check support
 * 7Zip writing
 * Zip64 (Need writing and extend Reading)
 * Multi-volume Zip support.
+* ZStandard writing
 
 ## Version Log
 
+* [Releases](https://github.com/adamhathcock/sharpcompress/releases)
+
 ### Version 0.18
 
 * [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
@@ -182,6 +266,8 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 XZ implementation based on: https://github.com/sambott/XZ.NET by @sambott
 
+XZ BCJ filters support contributed by Louis-Michel Bergeron, on behalf of aDolus Technology Inc. - 2022
+
 7Zip implementation based on: https://code.google.com/p/managed-lzma/
 
 LICENSE

SharpCompress.sln

@@ -3,8 +3,6 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
 VisualStudioVersion = 15.0.26430.6
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F18F1765-4A02-42FD-9BEF-F0E2FCBD9D17}"
-EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3C5BE746-03E5-4895-9988-0B57F162F86C}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0F0901FF-E8D9-426A-B5A2-17C7F47C1529}"
@@ -15,6 +13,22 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress.Test", "tests
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "build", "build\build.csproj", "{D4D613CB-5E94-47FB-85BE-B8423D20C545}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Config", "Config", "{CDB42573-7D22-4490-BA12-1B7FB99CE7FB}"
+	ProjectSection(SolutionItems) = preProject
+		Directory.Build.props = Directory.Build.props
+		global.json = global.json
+		.editorconfig = .editorconfig
+		Directory.Packages.props = Directory.Packages.props
+		NuGet.config = NuGet.config
+		.github\workflows\dotnetcore.yml = .github\workflows\dotnetcore.yml
+		USAGE.md = USAGE.md
+		README.md = README.md
+		FORMATS.md = FORMATS.md
+		AGENTS.md = AGENTS.md
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SharpCompress.Performance", "tests\SharpCompress.Performance\SharpCompress.Performance.csproj", "{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -33,6 +47,10 @@ Global
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D4D613CB-5E94-47FB-85BE-B8423D20C545}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -40,5 +58,6 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
+		{5BDE6DBC-9E5F-4E21-AB71-F138A3E72B17} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
 	EndGlobalSection
 EndGlobal

SharpCompress.sln.DotSettings

@@ -15,17 +15,17 @@
 	
 	<s:String x:Key="/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValue">Basic Clean</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/APPLY_ON_COMPLETION/@EntryValue">True</s:Boolean>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Named</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Positional</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOR/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOREACH/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_IFELSE/@EntryValue">Required</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_WHILE/@EntryValue">Required</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_LINQ_QUERY/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARGUMENT/@EntryValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_CALLS_CHAIN/@EntryValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXTENDS_LIST/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_FOR_STMT/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_PARAMETER/@EntryValue">True</s:Boolean>
@@ -42,7 +42,7 @@
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_IFELSE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_USING_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_WHILE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">False</s:Boolean>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
@@ -50,12 +50,12 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_CONSTRUCTOR_INITIALIZER_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_EMBEDDED_STATEMENT_ON_SAME_LINE/@EntryValue">NEVER</s:String>
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">False</s:Boolean>
 	
-	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">False</s:Boolean>
 	
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_EMBEDDED_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_AFTER_TYPECAST_PARENTHESES/@EntryValue">False</s:Boolean>
@@ -67,18 +67,22 @@
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_BEFORE_TYPEOF_PARENTHESES/@EntryValue">False</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/STICK_COMMENT/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARGUMENTS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
-	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_ALWAYS</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_EXTENDS_LIST_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_LINES/@EntryValue">False</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_PARAMETERS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVarWhenEvident</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVarWhenEvident</s:String>
-	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVarWhenEvident</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVar</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVar</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVar</s:String>
 	
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=StaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=15b5b1f1_002D457c_002D4ca6_002Db278_002D5615aedc07d3/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static readonly fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=4a98fdf6_002D7d98_002D4f5a_002Dafeb_002Dea44ad98c70c/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Instance" AccessRightKinds="Private" Description="Instance fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=c873eafb_002Dd57f_002D481d_002D8c93_002D77f6863c2f88/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Protected, ProtectedInternal, Internal, Public, PrivateProtected" Description="Static readonly fields (not private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="READONLY_FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/UserRules/=f9fce829_002De6f4_002D4cb2_002D80f1_002D5497c44f51df/@EntryIndexedValue">&lt;Policy&gt;&lt;Descriptor Staticness="Static" AccessRightKinds="Private" Description="Static fields (private)"&gt;&lt;ElementKinds&gt;&lt;Kind Name="FIELD" /&gt;&lt;/ElementKinds&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/Policy&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FCONSTANT/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
@@ -118,6 +122,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CustomTools/CustomToolsData/@EntryValue"></s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
@@ -127,6 +132,7 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EPredefinedNamingRulesToUserRulesUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=6af8f80e_002D9fdd_002D4223_002D8e02_002D473db916f9b2/@EntryIndexedValue">&lt;SessionState ContinuousTestingIsOn="False" ContinuousTestingMode="0" FrameworkVersion="{x:Null}" IsLocked="False" Name="All tests from Solution" PlatformMonoPreference="{x:Null}" PlatformType="{x:Null}" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"&gt;
   &lt;Solution /&gt;
 &lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>

USAGE.md

@@ -1,5 +1,18 @@
 # SharpCompress Usage
 
+## Async/Await Support
+
+SharpCompress now provides full async/await support for all I/O operations. All `Read`, `Write`, and extraction operations have async equivalents ending in `Async` that accept an optional `CancellationToken`. This enables better performance and scalability for I/O-bound operations.
+
+**Key Async Methods:**
+- `reader.WriteEntryToAsync(stream, cancellationToken)` - Extract entry asynchronously  
+- `reader.WriteAllToDirectoryAsync(path, options, cancellationToken)` - Extract all asynchronously
+- `writer.WriteAsync(filename, stream, modTime, cancellationToken)` - Write entry asynchronously
+- `writer.WriteAllAsync(directory, pattern, searchOption, cancellationToken)` - Write directory asynchronously
+- `entry.OpenEntryStreamAsync(cancellationToken)` - Open entry stream asynchronously
+
+See [Async Examples](#async-examples) section below for usage patterns.
+
 ## Stream Rules (changed with 0.21)
 
 When dealing with Streams, the rule should be that you don't close a stream you didn't create. This, in effect, should mean you should always put a Stream in a using block to dispose it. 
@@ -27,12 +40,24 @@ To deal with the "correct" rules as well as the expectations of users, I've deci
 
 To be explicit though, consider always using the overloads that use `ReaderOptions` or `WriterOptions` and explicitly set `LeaveStreamOpen` the way you want.
 
-If using Compression Stream classes directly and you don't want the wrapped stream to be closed.  Use the `NonDisposingStream` as a wrapped to prevent the stream being disposed.  The change in 0.21 simplified a lot even though the usage is a bit more convoluted.
+If using Compression Stream classes directly and you don't want the wrapped stream to be closed.  Use the `NonDisposingStream` as a wrapper to prevent the stream being disposed.  The change in 0.21 simplified a lot even though the usage is a bit more convoluted.
 
 ## Samples
 
 Also, look over the tests for more thorough [examples](https://github.com/adamhathcock/sharpcompress/tree/master/tests/SharpCompress.Test)
 
+### Create Zip Archive from multiple files
+```C#
+using(var archive = ZipArchive.Create())
+{
+    archive.AddEntry("file01.txt", "C:\\file01.txt");
+    archive.AddEntry("file02.txt", "C:\\file02.txt");
+    ...
+    
+    archive.SaveTo("C:\\temp.zip", CompressionType.Deflate);
+}
+```
+
 ### Create Zip Archive from all files in a directory to a file
 
 ```C#
@@ -59,18 +84,34 @@ using (var archive = ZipArchive.Create())
 memoryStream.Position = 0;
 ```
 
-### Extract all files from a Rar file to a directory using RarArchive
+### Extract all files from a rar file to a directory using RarArchive
+
+Note: Extracting a solid rar or 7z file needs to be done in sequential order to get acceptable decompression speed.
+It is explicitly recommended to use `ExtractAllEntries` when extracting an entire `IArchive` instead of iterating over all its `Entries`.
+Alternatively, use `IArchive.WriteToDirectory`.
+
+```C#
+using (var archive = RarArchive.Open("Test.rar"))
+{
+    using (var reader = archive.ExtractAllEntries())
+    {
+        reader.WriteAllToDirectory(@"D:\temp", new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
+    }
+}
+```
+
+### Iterate over all files from a Rar file using RarArchive
 
 ```C#
 using (var archive = RarArchive.Open("Test.rar"))
 {
     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
     {
-        entry.WriteToDirectory("D:\\temp", new ExtractionOptions()
-        {
-            ExtractFullPath = true,
-            Overwrite = true
-        });
+        Console.WriteLine($"{entry.Key}: {entry.Size} bytes");
     }
 }
 ```
@@ -143,4 +184,134 @@ foreach(var entry in tr.Entries)
 {
     Console.WriteLine($"{entry.Key}");
 }
-```
+```
+
+## Async Examples
+
+### Async Reader Examples
+
+**Extract single entry asynchronously:**
+```C#
+using (Stream stream = File.OpenRead("archive.zip"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            using (var entryStream = reader.OpenEntryStream())
+            {
+                using (var outputStream = File.Create("output.bin"))
+                {
+                    await reader.WriteEntryToAsync(outputStream, cancellationToken);
+                }
+            }
+        }
+    }
+}
+```
+
+**Extract all entries asynchronously:**
+```C#
+using (Stream stream = File.OpenRead("archive.tar.gz"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    await reader.WriteAllToDirectoryAsync(
+        @"D:\temp",
+        new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        },
+        cancellationToken
+    );
+}
+```
+
+**Open and process entry stream asynchronously:**
+```C#
+using (var archive = ZipArchive.Open("archive.zip"))
+{
+    foreach (var entry in archive.Entries.Where(e => !e.IsDirectory))
+    {
+        using (var entryStream = await entry.OpenEntryStreamAsync(cancellationToken))
+        {
+            // Process the decompressed stream asynchronously
+            await ProcessStreamAsync(entryStream, cancellationToken);
+        }
+    }
+}
+```
+
+### Async Writer Examples
+
+**Write single file asynchronously:**
+```C#
+using (Stream archiveStream = File.OpenWrite("output.zip"))
+using (var writer = WriterFactory.Open(archiveStream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    using (Stream fileStream = File.OpenRead("input.txt"))
+    {
+        await writer.WriteAsync("entry.txt", fileStream, DateTime.Now, cancellationToken);
+    }
+}
+```
+
+**Write entire directory asynchronously:**
+```C#
+using (Stream stream = File.OpenWrite("backup.tar.gz"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)))
+{
+    await writer.WriteAllAsync(
+        @"D:\files",
+        "*",
+        SearchOption.AllDirectories,
+        cancellationToken
+    );
+}
+```
+
+**Write with progress tracking and cancellation:**
+```C#
+var cts = new CancellationTokenSource();
+
+// Set timeout or cancel from UI
+cts.CancelAfter(TimeSpan.FromMinutes(5));
+
+using (Stream stream = File.OpenWrite("archive.zip"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Zip, CompressionType.Deflate))
+{
+    try
+    {
+        await writer.WriteAllAsync(@"D:\data", "*", SearchOption.AllDirectories, cts.Token);
+    }
+    catch (OperationCanceledException)
+    {
+        Console.WriteLine("Operation was cancelled");
+    }
+}
+```
+
+### Archive Async Examples
+
+**Extract from archive asynchronously:**
+```C#
+using (var archive = ZipArchive.Open("archive.zip"))
+{
+    using (var reader = archive.ExtractAllEntries())
+    {
+        await reader.WriteAllToDirectoryAsync(
+            @"C:\output",
+            new ExtractionOptions() { ExtractFullPath = true, Overwrite = true },
+            cancellationToken
+        );
+    }
+}
+```
+
+**Benefits of Async Operations:**
+- Non-blocking I/O for better application responsiveness
+- Improved scalability for server applications
+- Support for cancellation via CancellationToken
+- Better resource utilization in async/await contexts
+- Compatible with modern .NET async patterns

build/Program.cs

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

build/build.csproj

@@ -1,14 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
-
   <ItemGroup>
-    <PackageReference Include="Bullseye" Version="3.3.0" />
-    <PackageReference Include="Glob" Version="1.1.7" />
-    <PackageReference Include="SimpleExec" Version="6.2.0" />
+    <PackageReference Include="Bullseye" />
+    <PackageReference Include="Glob" />
+    <PackageReference Include="SimpleExec" />
   </ItemGroup>
-
 </Project>

build/packages.lock.json

@@ -0,0 +1,25 @@
+{
+  "version": 2,
+  "dependencies": {
+    "net8.0": {
+      "Bullseye": {
+        "type": "Direct",
+        "requested": "[6.0.0, )",
+        "resolved": "6.0.0",
+        "contentHash": "vgwwXfzs7jJrskWH7saHRMgPzziq/e86QZNWY1MnMxd7e+De7E7EX4K3C7yrvaK9y02SJoLxNxcLG/q5qUAghw=="
+      },
+      "Glob": {
+        "type": "Direct",
+        "requested": "[1.1.9, )",
+        "resolved": "1.1.9",
+        "contentHash": "AfK5+ECWYTP7G3AAdnU8IfVj+QpGjrh9GC2mpdcJzCvtQ4pnerAGwHsxJ9D4/RnhDUz2DSzd951O/lQjQby2Sw=="
+      },
+      "SimpleExec": {
+        "type": "Direct",
+        "requested": "[12.0.0, )",
+        "resolved": "12.0.0",
+        "contentHash": "ptxlWtxC8vM6Y6e3h9ZTxBBkOWnWrm/Sa1HT+2i1xcXY3Hx2hmKDZP5RShPf8Xr9D+ivlrXNy57ktzyH8kyt+Q=="
+      }
+    }
+  }
+}

global.json

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

src/SharpCompress/Algorithms/Adler32.cs

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

src/SharpCompress/Archives/AbstractArchive.cs

@@ -1,177 +1,175 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
 {
-    public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
-        where TEntry : IArchiveEntry
-        where TVolume : IVolume
+    private readonly LazyReadOnlyCollection<TVolume> _lazyVolumes;
+    private readonly LazyReadOnlyCollection<TEntry> _lazyEntries;
+    private bool _disposed;
+    private readonly SourceStream? _sourceStream;
+
+    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
+    public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
+
+    public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
+    public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
+    protected ReaderOptions ReaderOptions { get; }
+
+    internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
     {
-        private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
-        private readonly LazyReadOnlyCollection<TEntry> lazyEntries;
+        Type = type;
+        ReaderOptions = sourceStream.ReaderOptions;
+        _sourceStream = sourceStream;
+        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(_sourceStream));
+        _lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+    }
 
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
+    internal AbstractArchive(ArchiveType type)
+    {
+        Type = type;
+        ReaderOptions = new();
+        _lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
+        _lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
+    }
 
-        public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
-        public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
+    public ArchiveType Type { get; }
 
-        protected ReaderOptions ReaderOptions { get; }
+    void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry) =>
+        EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
 
-        private bool disposed;
+    void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry) =>
+        EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
 
-        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
+    private static Stream CheckStreams(Stream stream)
+    {
+        if (!stream.CanSeek || !stream.CanRead)
         {
-            Type = type;
-            if (!fileInfo.Exists)
-            {
-                throw new ArgumentException("File does not exist: " + fileInfo.FullName);
-            }
-            ReaderOptions = readerOptions;
-            readerOptions.LeaveStreamOpen = false;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+            throw new ArchiveException("Archive streams must be Readable and Seekable");
         }
+        return stream;
+    }
 
+    /// <summary>
+    /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
+    /// </summary>
+    public virtual ICollection<TEntry> Entries => _lazyEntries;
 
-        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
+    /// <summary>
+    /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
+    /// </summary>
+    public ICollection<TVolume> Volumes => _lazyVolumes;
 
-        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
+    /// <summary>
+    /// The total size of the files compressed in the archive.
+    /// </summary>
+    public virtual long TotalSize =>
+        Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize);
+
+    /// <summary>
+    /// The total size of the files as uncompressed in the archive.
+    /// </summary>
+    public virtual long TotalUncompressSize =>
+        Entries.Aggregate(0L, (total, cf) => total + cf.Size);
+
+    protected abstract IEnumerable<TVolume> LoadVolumes(SourceStream sourceStream);
+    protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
+
+    IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
+
+    IEnumerable<IVolume> IArchive.Volumes => _lazyVolumes.Cast<IVolume>();
+
+    public virtual void Dispose()
+    {
+        if (!_disposed)
         {
-            Type = type;
-            ReaderOptions = readerOptions;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
+            _lazyVolumes.ForEach(v => v.Dispose());
+            _lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
+            _sourceStream?.Dispose();
+
+            _disposed = true;
         }
+    }
 
-#nullable disable
-        internal AbstractArchive(ArchiveType type)
-        {
-            Type = type;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
-            lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
-        }
-#nullable enable
+    void IArchiveExtractionListener.EnsureEntriesLoaded()
+    {
+        _lazyEntries.EnsureFullyLoaded();
+        _lazyVolumes.EnsureFullyLoaded();
+    }
 
-        public ArchiveType Type { get; }
-
-        void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry)
-        {
-            EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-        }
-
-        void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry)
-        {
-            EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-        }
-
-        private static Stream CheckStreams(Stream stream)
-        {
-            if (!stream.CanSeek || !stream.CanRead)
-            {
-                throw new ArgumentException("Archive streams must be Readable and Seekable");
-            }
-            return stream;
-        }
-
-        /// <summary>
-        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
-        /// </summary>
-        public virtual ICollection<TEntry> Entries { 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 { get { return lazyVolumes; } }
-
-        /// <summary>
-        /// The total size of the files compressed in the archive.
-        /// </summary>
-        public virtual long TotalSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize); } }
-
-        /// <summary>
-        /// The total size of the files as uncompressed in the archive.
-        /// </summary>
-        public virtual long TotalUncompressSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); } }
-
-        protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams);
-        protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);
-
-        IEnumerable<IArchiveEntry> IArchive.Entries { get { return Entries.Cast<IArchiveEntry>(); } }
-
-        IEnumerable<IVolume> IArchive.Volumes { get { return lazyVolumes.Cast<IVolume>(); } }
-
-        public virtual void Dispose()
-        {
-            if (!disposed)
-            {
-                lazyVolumes.ForEach(v => v.Dispose());
-                lazyEntries.GetLoaded().Cast<Entry>().ForEach(x => x.Close());
-                disposed = true;
-            }
-        }
-
-        void IArchiveExtractionListener.EnsureEntriesLoaded()
-        {
-            lazyEntries.EnsureFullyLoaded();
-            lazyVolumes.EnsureFullyLoaded();
-        }
-
-        void IExtractionListener.FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes)
-        {
-            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs(
+    void IExtractionListener.FireCompressedBytesRead(
+        long currentPartCompressedBytes,
+        long compressedReadBytes
+    ) =>
+        CompressedBytesRead?.Invoke(
+            this,
+            new CompressedBytesReadEventArgs(
                 currentFilePartCompressedBytesRead: currentPartCompressedBytes,
                 compressedBytesRead: compressedReadBytes
-            ));
-        }
+            )
+        );
 
-        void IExtractionListener.FireFilePartExtractionBegin(string name, long size, long compressedSize)
+    void IExtractionListener.FireFilePartExtractionBegin(
+        string name,
+        long size,
+        long compressedSize
+    ) =>
+        FilePartExtractionBegin?.Invoke(
+            this,
+            new FilePartExtractionBeginEventArgs(
+                compressedSize: compressedSize,
+                size: size,
+                name: name
+            )
+        );
+
+    /// <summary>
+    /// Use this method to extract all entries in an archive in order.
+    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
+    /// extracted sequentially for the best performance.
+    ///
+    /// This method will load all entry information from the archive.
+    ///
+    /// WARNING: this will reuse the underlying stream for the archive.  Errors may
+    /// occur if this is used at the same time as other extraction methods on this instance.
+    /// </summary>
+    /// <returns></returns>
+    public IReader ExtractAllEntries()
+    {
+        if (!IsSolid && Type != ArchiveType.SevenZip)
         {
-            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs(
-                compressedSize : compressedSize,
-                size           : size,
-                name           : name
-            ));
+            throw new InvalidOperationException(
+                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
+            );
         }
+        ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
+        return CreateReaderForSolidExtraction();
+    }
 
-        /// <summary>
-        /// Use this method to extract all entries in an archive in order.
-        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
-        /// extracted sequentially for the best performance.
-        ///
-        /// This method will load all entry information from the archive.
-        ///
-        /// WARNING: this will reuse the underlying stream for the archive.  Errors may
-        /// occur if this is used at the same time as other extraction methods on this instance.
-        /// </summary>
-        /// <returns></returns>
-        public IReader ExtractAllEntries()
+    protected abstract IReader CreateReaderForSolidExtraction();
+
+    /// <summary>
+    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
+    /// </summary>
+    public virtual bool IsSolid => false;
+
+    /// <summary>
+    /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
+    /// </summary>
+    public bool IsComplete
+    {
+        get
         {
             ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-            return CreateReaderForSolidExtraction();
-        }
-
-        protected abstract IReader CreateReaderForSolidExtraction();
-
-        /// <summary>
-        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-        /// </summary>
-        public virtual bool IsSolid { get { return false; } }
-
-        /// <summary>
-        /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
-        /// </summary>
-        public bool IsComplete
-        {
-            get
-            {
-                ((IArchiveExtractionListener)this).EnsureEntriesLoaded();
-                return Entries.All(x => x.IsComplete);
-            }
+            return Entries.All(x => x.IsComplete);
         }
     }
 }

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -1,145 +1,226 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
-using SharpCompress.Readers;
+using SharpCompress.IO;
 using SharpCompress.Writers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public abstract class AbstractWritableArchive<TEntry, TVolume>
+    : AbstractArchive<TEntry, TVolume>,
+        IWritableArchive
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
 {
-    public abstract class AbstractWritableArchive<TEntry, TVolume> : AbstractArchive<TEntry, TVolume>, IWritableArchive
-        where TEntry : IArchiveEntry
-        where TVolume : IVolume
+    private class RebuildPauseDisposable : IDisposable
     {
-        private readonly List<TEntry> newEntries = new List<TEntry>();
-        private readonly List<TEntry> removedEntries = new List<TEntry>();
+        private readonly AbstractWritableArchive<TEntry, TVolume> archive;
 
-        private readonly List<TEntry> modifiedEntries = new List<TEntry>();
-        private bool hasModifications;
-
-        internal AbstractWritableArchive(ArchiveType type)
-            : base(type)
+        public RebuildPauseDisposable(AbstractWritableArchive<TEntry, TVolume> archive)
         {
+            this.archive = archive;
+            archive.pauseRebuilding = true;
         }
 
-        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
-            : base(type, stream.AsEnumerable(), readerFactoryOptions)
+        public void Dispose()
         {
-        }
-
-        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
-            : base(type, fileInfo, readerFactoryOptions)
-        {
-        }
-
-        public override ICollection<TEntry> Entries
-        {
-            get
-            {
-                if (hasModifications)
-                {
-                    return modifiedEntries;
-                }
-                return base.Entries;
-            }
-        }
-
-        private void RebuildModifiedCollection()
-        {
-            hasModifications = true;
-            newEntries.RemoveAll(v => removedEntries.Contains(v));
-            modifiedEntries.Clear();
-            modifiedEntries.AddRange(OldEntries.Concat(newEntries));
-        }
-
-        private IEnumerable<TEntry> OldEntries { get { return base.Entries.Where(x => !removedEntries.Contains(x)); } }
-
-        public void RemoveEntry(TEntry entry)
-        {
-            if (!removedEntries.Contains(entry))
-            {
-                removedEntries.Add(entry);
-                RebuildModifiedCollection();
-            }
-        }
-
-        void IWritableArchive.RemoveEntry(IArchiveEntry entry)
-        {
-            RemoveEntry((TEntry)entry);
-        }
-
-        public TEntry AddEntry(string key, Stream source,
-                               long size = 0, DateTime? modified = null)
-        {
-            return AddEntry(key, source, false, size, modified);
-        }
-
-        IArchiveEntry IWritableArchive.AddEntry(string key, Stream source, bool closeStream, long size, DateTime? modified)
-        {
-            return AddEntry(key, source, closeStream, size, modified);
-        }
-
-        public TEntry AddEntry(string key, Stream source, bool closeStream,
-                               long size = 0, DateTime? modified = null)
-        {
-            if (key.StartsWith("/")
-                || key.StartsWith("\\"))
-            {
-                key = key.Substring(1);
-            }
-            if (DoesKeyMatchExisting(key))
-            {
-                throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-            }
-            var entry = CreateEntry(key, source, size, modified, closeStream);
-            newEntries.Add(entry);
-            RebuildModifiedCollection();
-            return entry;
-        }
-
-        private bool DoesKeyMatchExisting(string key)
-        {
-            foreach (var path in Entries.Select(x => x.Key))
-            {
-                var p = path.Replace('/', '\\');
-                if (p.StartsWith("\\"))
-                {
-                    p = p.Substring(1);
-                }
-                return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
-            }
-            return false;
-        }
-
-        public void SaveTo(Stream stream, WriterOptions options)
-        {
-            //reset streams of new entries
-            newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-            SaveTo(stream, options, OldEntries, newEntries);
-        }
-
-        protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
-                                     bool closeStream)
-        {
-            if (!source.CanRead || !source.CanSeek)
-            {
-                throw new ArgumentException("Streams must be readable and seekable to use the Writing Archive API");
-            }
-            return CreateEntryInternal(key, source, size, modified, closeStream);
-        }
-
-        protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
-                                                      bool closeStream);
-
-        protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
-
-        public override void Dispose()
-        {
-            base.Dispose();
-            newEntries.Cast<Entry>().ForEach(x => x.Close());
-            removedEntries.Cast<Entry>().ForEach(x => x.Close());
-            modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
+            archive.pauseRebuilding = false;
+            archive.RebuildModifiedCollection();
         }
     }
+
+    private readonly List<TEntry> newEntries = new();
+    private readonly List<TEntry> removedEntries = new();
+
+    private readonly List<TEntry> modifiedEntries = new();
+    private bool hasModifications;
+    private bool pauseRebuilding;
+
+    internal AbstractWritableArchive(ArchiveType type)
+        : base(type) { }
+
+    internal AbstractWritableArchive(ArchiveType type, SourceStream sourceStream)
+        : base(type, sourceStream) { }
+
+    public override ICollection<TEntry> Entries
+    {
+        get
+        {
+            if (hasModifications)
+            {
+                return modifiedEntries;
+            }
+            return base.Entries;
+        }
+    }
+
+    public IDisposable PauseEntryRebuilding() => new RebuildPauseDisposable(this);
+
+    private void RebuildModifiedCollection()
+    {
+        if (pauseRebuilding)
+        {
+            return;
+        }
+        hasModifications = true;
+        newEntries.RemoveAll(v => removedEntries.Contains(v));
+        modifiedEntries.Clear();
+        modifiedEntries.AddRange(OldEntries.Concat(newEntries));
+    }
+
+    private IEnumerable<TEntry> OldEntries => base.Entries.Where(x => !removedEntries.Contains(x));
+
+    public void RemoveEntry(TEntry entry)
+    {
+        if (!removedEntries.Contains(entry))
+        {
+            removedEntries.Add(entry);
+            RebuildModifiedCollection();
+        }
+    }
+
+    void IWritableArchive.RemoveEntry(IArchiveEntry entry) => RemoveEntry((TEntry)entry);
+
+    public TEntry AddEntry(string key, Stream source, long size = 0, DateTime? modified = null) =>
+        AddEntry(key, source, false, size, modified);
+
+    IArchiveEntry IWritableArchive.AddEntry(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size,
+        DateTime? modified
+    ) => AddEntry(key, source, closeStream, size, modified);
+
+    IArchiveEntry IWritableArchive.AddDirectoryEntry(string key, DateTime? modified) =>
+        AddDirectoryEntry(key, modified);
+
+    public TEntry AddEntry(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (DoesKeyMatchExisting(key))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateEntry(key, source, size, modified, closeStream);
+        newEntries.Add(entry);
+        RebuildModifiedCollection();
+        return entry;
+    }
+
+    private bool DoesKeyMatchExisting(string key)
+    {
+        foreach (var path in Entries.Select(x => x.Key))
+        {
+            if (path is null)
+            {
+                continue;
+            }
+            var p = path.Replace('/', '\\');
+            if (p.Length > 0 && p[0] == '\\')
+            {
+                p = p.Substring(1);
+            }
+            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+        }
+        return false;
+    }
+
+    public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (DoesKeyMatchExisting(key))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateDirectoryEntry(key, modified);
+        newEntries.Add(entry);
+        RebuildModifiedCollection();
+        return entry;
+    }
+
+    public void SaveTo(Stream stream, WriterOptions options)
+    {
+        //reset streams of new entries
+        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+        SaveTo(stream, options, OldEntries, newEntries);
+    }
+
+    public async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        //reset streams of new entries
+        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+        await SaveToAsync(stream, options, OldEntries, newEntries, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    protected TEntry CreateEntry(
+        string key,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    )
+    {
+        if (!source.CanRead || !source.CanSeek)
+        {
+            throw new ArchiveException(
+                "Streams must be readable and seekable to use the Writing Archive API"
+            );
+        }
+        return CreateEntryInternal(key, source, size, modified, closeStream);
+    }
+
+    protected abstract TEntry CreateEntryInternal(
+        string key,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    );
+
+    protected abstract TEntry CreateDirectoryEntry(string key, DateTime? modified);
+
+    protected abstract void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TEntry> oldEntries,
+        IEnumerable<TEntry> newEntries
+    );
+
+    protected abstract Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TEntry> oldEntries,
+        IEnumerable<TEntry> newEntries,
+        CancellationToken cancellationToken = default
+    );
+
+    public override void Dispose()
+    {
+        base.Dispose();
+        newEntries.Cast<Entry>().ForEach(x => x.Close());
+        removedEntries.Cast<Entry>().ForEach(x => x.Close());
+        modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
+    }
 }

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -1,149 +1,251 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Archives.GZip;
-using SharpCompress.Archives.Rar;
-using SharpCompress.Archives.SevenZip;
-using SharpCompress.Archives.Tar;
-using SharpCompress.Archives.Zip;
+using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.Factories;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class ArchiveFactory
 {
-    public class ArchiveFactory
+    /// <summary>
+    /// Opens an Archive for random access
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <returns></returns>
+    public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
     {
-        /// <summary>
-        /// Opens an Archive for random access
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        /// <returns></returns>
-        public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        readerOptions ??= new ReaderOptions();
+        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
+    }
+
+    public static IWritableArchive Create(ArchiveType type)
+    {
+        var factory = Factory
+            .Factories.OfType<IWriteableArchiveFactory>()
+            .FirstOrDefault(item => item.KnownArchiveType == type);
+
+        if (factory != null)
         {
-            stream.CheckNotNull(nameof(stream));
-            if (!stream.CanRead || !stream.CanSeek)
-            {
-                throw new ArgumentException("Stream should be readable and seekable");
-            }
-            readerOptions = readerOptions ?? new ReaderOptions();
-            if (ZipArchive.IsZipFile(stream, null))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return ZipArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);
-            if (SevenZipArchive.IsSevenZipFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return SevenZipArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);
-            if (GZipArchive.IsGZipFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return GZipArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);
-            if (RarArchive.IsRarFile(stream, readerOptions))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return RarArchive.Open(stream, readerOptions);
-            }
-            stream.Seek(0, SeekOrigin.Begin);
-            if (TarArchive.IsTarFile(stream))
-            {
-                stream.Seek(0, SeekOrigin.Begin);
-                return TarArchive.Open(stream, readerOptions);
-            }
-            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
+            return factory.CreateWriteableArchive();
         }
 
-        public static IWritableArchive Create(ArchiveType type)
+        throw new NotSupportedException("Cannot create Archives of type: " + type);
+    }
+
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(string filePath, ReaderOptions? options = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), options);
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+    {
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
+    }
+
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(IEnumerable<FileInfo> fileInfos, ReaderOptions? options = null)
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var filesArray = fileInfos.ToArray();
+        if (filesArray.Length == 0)
         {
-            switch (type)
+            throw new InvalidOperationException("No files to open");
+        }
+
+        var fileInfo = filesArray[0];
+        if (filesArray.Length == 1)
+        {
+            return Open(fileInfo, options);
+        }
+
+        fileInfo.NotNull(nameof(fileInfo));
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
+    }
+
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="options"></param>
+    public static IArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
+    {
+        streams.NotNull(nameof(streams));
+        var streamsArray = streams.ToArray();
+        if (streamsArray.Length == 0)
+        {
+            throw new InvalidOperationException("No streams");
+        }
+
+        var firstStream = streamsArray[0];
+        if (streamsArray.Length == 1)
+        {
+            return Open(firstStream, options);
+        }
+
+        firstStream.NotNull(nameof(firstStream));
+        options ??= new ReaderOptions();
+
+        return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
+    }
+
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        string sourceArchive,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    )
+    {
+        using var archive = Open(sourceArchive);
+        archive.WriteToDirectory(destinationDirectory, options);
+    }
+
+    private static T FindFactory<T>(FileInfo finfo)
+        where T : IFactory
+    {
+        finfo.NotNull(nameof(finfo));
+        using Stream stream = finfo.OpenRead();
+        return FindFactory<T>(stream);
+    }
+
+    private static T FindFactory<T>(Stream stream)
+        where T : IFactory
+    {
+        stream.NotNull(nameof(stream));
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var factories = Factory.Factories.OfType<T>();
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in factories)
+        {
+            stream.Seek(startPosition, SeekOrigin.Begin);
+
+            if (factory.IsArchive(stream))
             {
-                case ArchiveType.Zip:
-                {
-                    return ZipArchive.Create();
-                }
-                case ArchiveType.Tar:
-                {
-                    return TarArchive.Create();
-                }
-                case ArchiveType.GZip:
-                {
-                    return GZipArchive.Create();
-                }
-                default:
-                {
-                    throw new NotSupportedException("Cannot create Archives of type: " + type);
-                }
+                stream.Seek(startPosition, SeekOrigin.Begin);
+
+                return factory;
             }
         }
 
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="options"></param>
-        public static IArchive Open(string filePath, ReaderOptions? options = null)
+        var extensions = string.Join(", ", factories.Select(item => item.Name));
+
+        throw new InvalidOperationException(
+            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
+        );
+    }
+
+    public static bool IsArchive(
+        string filePath,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        using Stream s = File.OpenRead(filePath);
+        return IsArchive(s, out type, bufferSize);
+    }
+
+    public static bool IsArchive(
+        Stream stream,
+        out ArchiveType? type,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        type = null;
+        stream.NotNull(nameof(stream));
+
+        if (!stream.CanRead || !stream.CanSeek)
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), options);
+            throw new ArgumentException("Stream should be readable and seekable");
         }
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+        var startPosition = stream.Position;
+
+        foreach (var factory in Factory.Factories)
         {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            options = options ?? new ReaderOptions { LeaveStreamOpen = false };
-            using (var stream = fileInfo.OpenRead())
+            var isArchive = factory.IsArchive(stream);
+            stream.Position = startPosition;
+
+            if (isArchive)
             {
-                if (ZipArchive.IsZipFile(stream, null))
-                {
-                    return ZipArchive.Open(fileInfo, options);
-                }
-                stream.Seek(0, SeekOrigin.Begin);
-                if (SevenZipArchive.IsSevenZipFile(stream))
-                {
-                    return SevenZipArchive.Open(fileInfo, options);
-                }
-                stream.Seek(0, SeekOrigin.Begin);
-                if (GZipArchive.IsGZipFile(stream))
-                {
-                    return GZipArchive.Open(fileInfo, options);
-                }
-                stream.Seek(0, SeekOrigin.Begin);
-                if (RarArchive.IsRarFile(stream, options))
-                {
-                   return RarArchive.Open(fileInfo, options);
-                }
-                stream.Seek(0, SeekOrigin.Begin);
-                if (TarArchive.IsTarFile(stream))
-                {
-                    return TarArchive.Open(fileInfo, options);
-                }
-                throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
+                type = factory.KnownArchiveType;
+                return true;
             }
         }
 
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
-                                            ExtractionOptions? options = null)
+        return false;
+    }
+
+    /// <summary>
+    /// From a passed in archive (zip, rar, 7z, 001), return all parts.
+    /// </summary>
+    /// <param name="part1"></param>
+    /// <returns></returns>
+    public static IEnumerable<string> GetFileParts(string part1)
+    {
+        part1.NotNullOrEmpty(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.NotNull(nameof(part1));
+        yield return part1;
+
+        foreach (var factory in Factory.Factories.OfType<IFactory>())
         {
-            using (IArchive archive = Open(sourceArchive))
+            var i = 1;
+            var part = factory.GetFilePart(i++, part1);
+
+            if (part != null)
             {
-                foreach (IArchiveEntry entry in archive.Entries)
+                yield return part;
+                while ((part = factory.GetFilePart(i++, part1)) != null) //tests split too
                 {
-                    entry.WriteToDirectory(destinationDirectory, options);
+                    yield return part;
                 }
+
+                yield break;
             }
         }
     }
+
+    public static IArchiveFactory AutoFactory { get; } = new AutoArchiveFactory();
 }

src/SharpCompress/Archives/ArchiveVolumeFactory.cs

@@ -0,0 +1,30 @@
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace SharpCompress.Archives;
+
+internal abstract class ArchiveVolumeFactory
+{
+    internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
+    {
+        FileInfo? item = null;
+
+        //split 001, 002 ...
+        var m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
+        if (m.Success)
+            item = new FileInfo(
+                Path.Combine(
+                    part1.DirectoryName!,
+                    String.Concat(
+                        m.Groups[1].Value,
+                        (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0')
+                    )
+                )
+            );
+
+        if (item != null && item.Exists)
+            return item;
+        return null;
+    }
+}

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+class AutoArchiveFactory : IArchiveFactory
+{
+    public string Name => nameof(AutoArchiveFactory);
+
+    public ArchiveType? KnownArchiveType => null;
+
+    public IEnumerable<string> GetSupportedExtensions() => throw new NotSupportedException();
+
+    public bool IsArchive(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => throw new NotSupportedException();
+
+    public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
+
+    public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
+        ArchiveFactory.Open(stream, readerOptions);
+
+    public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
+        ArchiveFactory.Open(fileInfo, readerOptions);
+}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -1,182 +1,253 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.GZip;
 using SharpCompress.Writers;
 using SharpCompress.Writers.GZip;
 
-namespace SharpCompress.Archives.GZip
+namespace SharpCompress.Archives.GZip;
+
+public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
 {
-    public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull(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.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new GZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new GZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
         }
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+        return new GZipArchive(
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+        );
+    }
+
+    public static GZipArchive Create() => new();
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
+    private GZipArchive(SourceStream sourceStream)
+        : base(ArchiveType.GZip, sourceStream) { }
+
+    protected override IEnumerable<GZipVolume> LoadVolumes(SourceStream sourceStream)
+    {
+        sourceStream.LoadAllParts();
+        return sourceStream.Streams.Select(a => new GZipVolume(a, ReaderOptions, 0));
+    }
+
+    public static bool IsGZipFile(string filePath) => IsGZipFile(new FileInfo(filePath));
+
+    public static bool IsGZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
         {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
+            return false;
         }
 
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+        using Stream stream = fileInfo.OpenRead();
+        return IsGZipFile(stream);
+    }
+
+    public void SaveTo(string filePath) => SaveTo(new FileInfo(filePath));
+
+    public void SaveTo(FileInfo fileInfo)
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        SaveTo(stream, new WriterOptions(CompressionType.GZip));
+    }
+
+    public Task SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
+        SaveToAsync(new FileInfo(filePath), cancellationToken);
+
+    public async Task SaveToAsync(FileInfo fileInfo, CancellationToken cancellationToken = default)
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    public static bool IsGZipFile(Stream stream)
+    {
+        // read the header on the first read
+        Span<byte> header = stackalloc byte[10];
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (!stream.ReadFully(header))
         {
-            stream.CheckNotNull(nameof(stream));
-            return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
+            return false;
         }
 
-        public static GZipArchive Create()
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
         {
-            return new GZipArchive();
+            return false;
         }
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        internal GZipArchive(FileInfo fileInfo, ReaderOptions options)
-            : base(ArchiveType.GZip, fileInfo, options)
+        return true;
+    }
+
+    internal GZipArchive()
+        : base(ArchiveType.GZip) { }
+
+    protected override GZipArchiveEntry CreateEntryInternal(
+        string filePath,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    )
+    {
+        if (Entries.Any())
         {
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
         }
+        return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
+    }
 
-        protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file)
+    protected override GZipArchiveEntry CreateDirectoryEntry(
+        string directoryPath,
+        DateTime? modified
+    ) => throw new NotSupportedException("GZip archives do not support directory entries.");
+
+    protected override void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> newEntries
+    )
+    {
+        if (Entries.Count > 1)
         {
-            return new GZipVolume(file, ReaderOptions).AsEnumerable();
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
         }
-
-        public static bool IsGZipFile(string filePath)
+        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
         {
-            return IsGZipFile(new FileInfo(filePath));
-        }
-
-        public static bool IsGZipFile(FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                return false;
-            }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsGZipFile(stream);
-            }
-        }
-
-        public void SaveTo(string filePath)
-        {
-            SaveTo(new FileInfo(filePath));
-        }
-
-        public void SaveTo(FileInfo fileInfo)
-        {
-            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
-            {
-                SaveTo(stream, new WriterOptions(CompressionType.GZip));
-            }
-        }
-
-        public static bool IsGZipFile(Stream stream)
-        {
-            // read the header on the first read
-            byte[] header = new byte[10];
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (!stream.ReadFully(header))
-            {
-                return false;
-            }
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                return false;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        internal GZipArchive(Stream stream, ReaderOptions options)
-            : base(ArchiveType.GZip, stream, options)
-        {
-        }
-
-        internal GZipArchive()
-            : base(ArchiveType.GZip)
-        {
-        }
-
-        protected override GZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                                bool closeStream)
-        {
-            if (Entries.Any())
-            {
-                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
-            }
-            return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
-        }
-
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<GZipArchiveEntry> oldEntries,
-                                       IEnumerable<GZipArchiveEntry> newEntries)
-        {
-            if (Entries.Count > 1)
-            {
-                throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
-            }
-            using (var writer = new GZipWriter(stream, new GZipWriterOptions(options)))
-            {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
-                    }
-                }
-            }
-        }
-
-        protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new GZipVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
-        protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
-        {
-            Stream stream = volumes.Single().Stream;
-            yield return new GZipArchiveEntry(this, new GZipFilePart(stream, ReaderOptions.ArchiveEncoding));
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.Single().Stream;
-            stream.Position = 0;
-            return GZipReader.Open(stream);
+            using var entryStream = entry.OpenEntryStream();
+            writer.Write(
+                entry.Key.NotNull("Entry Key is null"),
+                entryStream,
+                entry.LastModifiedTime
+            );
         }
     }
+
+    protected override async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (Entries.Count > 1)
+        {
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
+        }
+        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries).Where(x => !x.IsDirectory))
+        {
+            using var entryStream = entry.OpenEntryStream();
+            await writer
+                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
+    protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
+    {
+        var stream = volumes.Single().Stream;
+        yield return new GZipArchiveEntry(
+            this,
+            new GZipFilePart(stream, ReaderOptions.ArchiveEncoding)
+        );
+    }
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return GZipReader.Open(stream);
+    }
 }

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

@@ -1,34 +1,39 @@
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.GZip;
 
-namespace SharpCompress.Archives.GZip
+namespace SharpCompress.Archives.GZip;
+
+public class GZipArchiveEntry : GZipEntry, IArchiveEntry
 {
-    public class GZipArchiveEntry : GZipEntry, IArchiveEntry
+    internal GZipArchiveEntry(GZipArchive archive, GZipFilePart? part)
+        : base(part) => Archive = archive;
+
+    public virtual Stream OpenEntryStream()
     {
-        internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
-            : base(part)
+        //this is to reset the stream to be read multiple times
+        var part = (GZipFilePart)Parts.Single();
+        var rawStream = part.GetRawStream();
+        if (rawStream.CanSeek && rawStream.Position != part.EntryStartPosition)
         {
-            Archive = archive;
+            rawStream.Position = part.EntryStartPosition;
         }
-
-        public virtual Stream OpenEntryStream()
-        {
-            //this is to reset the stream to be read multiple times
-            var part = (GZipFilePart)Parts.Single();
-            if (part.GetRawStream().Position != part.EntryStartPosition)
-            {
-                part.GetRawStream().Position = part.EntryStartPosition;
-            }
-            return Parts.Single().GetCompressedStream();
-        }
-
-        #region IArchiveEntry Members
-
-        public IArchive Archive { get; }
-
-        public bool IsComplete => true;
-
-        #endregion
+        return Parts.Single().GetCompressedStream().NotNull();
     }
-}
+
+    public virtual Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+    {
+        // GZip synchronous implementation is fast enough, just wrap it
+        return Task.FromResult(OpenEntryStream());
+    }
+
+    #region IArchiveEntry Members
+
+    public IArchive Archive { get; }
+
+    public bool IsComplete => true;
+
+    #endregion
+}

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -1,68 +1,71 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.GZip
+namespace SharpCompress.Archives.GZip;
+
+internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
 {
-    internal sealed class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
+    private readonly bool closeStream;
+    private readonly Stream stream;
+
+    internal GZipWritableArchiveEntry(
+        GZipArchive archive,
+        Stream stream,
+        string path,
+        long size,
+        DateTime? lastModified,
+        bool closeStream
+    )
+        : base(archive, null)
     {
-        private readonly bool closeStream;
-        private readonly Stream stream;
+        this.stream = stream;
+        Key = path;
+        Size = size;
+        LastModifiedTime = lastModified;
+        this.closeStream = closeStream;
+    }
 
-        internal GZipWritableArchiveEntry(GZipArchive archive, Stream stream,
-                                          string path, long size, DateTime? lastModified, bool closeStream)
-            : base(archive, null)
+    public override long Crc => 0;
+
+    public override string? Key { get; }
+
+    public override long CompressedSize => 0;
+
+    public override long Size { get; }
+
+    public override DateTime? LastModifiedTime { get; }
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => false;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
+
+    Stream IWritableArchiveEntry.Stream => stream;
+
+    public override Stream OpenEntryStream()
+    {
+        //ensure new stream is at the start, this could be reset
+        stream.Seek(0, SeekOrigin.Begin);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
+    }
+
+    internal override void Close()
+    {
+        if (closeStream)
         {
-            this.stream = stream;
-            Key = path;
-            Size = size;
-            LastModifiedTime = lastModified;
-            this.closeStream = closeStream;
-        }
-
-        public override long Crc => 0;
-
-        public override string Key { get; }
-
-        public override long CompressedSize => 0;
-
-        public override long Size { get; }
-
-        public override DateTime? LastModifiedTime { get; }
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => false;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
-
-        Stream IWritableArchiveEntry.Stream => stream;
-
-        public override Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream)
-            {
-                stream.Dispose();
-            }
+            stream.Dispose();
         }
     }
-}
+}

src/SharpCompress/Archives/IArchive.cs

@@ -1,49 +1,48 @@
-using System;
+using System;
 using System.Collections.Generic;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public interface IArchive : IDisposable
 {
-    public interface IArchive : IDisposable
-    {
-        event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
-        event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
+    event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
 
-        event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
-        event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+    event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
+    event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
 
-        IEnumerable<IArchiveEntry> Entries { get; }
-        IEnumerable<IVolume> Volumes { get; }
+    IEnumerable<IArchiveEntry> Entries { get; }
+    IEnumerable<IVolume> Volumes { get; }
 
-        ArchiveType Type { get; }
+    ArchiveType Type { get; }
 
-        /// <summary>
-        /// Use this method to extract all entries in an archive in order.
-        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
-        /// extracted sequentially for the best performance.
-        /// </summary>
-        IReader ExtractAllEntries();
+    /// <summary>
+    /// Use this method to extract all entries in an archive in order.
+    /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
+    /// extracted sequentially for the best performance.
+    /// </summary>
+    IReader ExtractAllEntries();
 
-        /// <summary>
-        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
-        /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
-        /// </summary>
-        bool IsSolid { get; }
+    /// <summary>
+    /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
+    /// Rar Archives can be SOLID while all 7Zip archives are considered SOLID.
+    /// </summary>
+    bool IsSolid { get; }
 
-        /// <summary>
-        /// This checks to see if all the known entries have IsComplete = true
-        /// </summary>
-        bool IsComplete { get; }
+    /// <summary>
+    /// This checks to see if all the known entries have IsComplete = true
+    /// </summary>
+    bool IsComplete { get; }
 
-        /// <summary>
-        /// The total size of the files compressed in the archive.
-        /// </summary>
-        long TotalSize { get; }
+    /// <summary>
+    /// The total size of the files compressed in the archive.
+    /// </summary>
+    long TotalSize { get; }
 
-        /// <summary>
-        /// The total size of the files as uncompressed in the archive.
-        /// </summary>
-        long TotalUncompressSize { get; }
-    }
-}
+    /// <summary>
+    /// The total size of the files as uncompressed in the archive.
+    /// </summary>
+    long TotalUncompressSize { get; }
+}

src/SharpCompress/Archives/IArchiveEntry.cs

@@ -1,24 +1,31 @@
-using System.IO;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public interface IArchiveEntry : IEntry
 {
-    public interface IArchiveEntry : IEntry
-    {
-        /// <summary>
-        /// Opens the current entry as a stream that will decompress as it is read.
-        /// Read the entire stream or use SkipEntry on EntryStream.
-        /// </summary>
-        Stream OpenEntryStream();
+    /// <summary>
+    /// Opens the current entry as a stream that will decompress as it is read.
+    /// Read the entire stream or use SkipEntry on EntryStream.
+    /// </summary>
+    Stream OpenEntryStream();
 
-        /// <summary>
-        /// The archive can find all the parts of the archive needed to extract this entry.
-        /// </summary>
-        bool IsComplete { get; }
+    /// <summary>
+    /// Opens the current entry as a stream that will decompress as it is read asynchronously.
+    /// Read the entire stream or use SkipEntry on EntryStream.
+    /// </summary>
+    Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default);
 
-        /// <summary>
-        /// The archive instance this entry belongs to
-        /// </summary>
-        IArchive Archive { get; }
-    }
-}
+    /// <summary>
+    /// The archive can find all the parts of the archive needed to extract this entry.
+    /// </summary>
+    bool IsComplete { get; }
+
+    /// <summary>
+    /// The archive instance this entry belongs to
+    /// </summary>
+    IArchive Archive { get; }
+}

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -1,63 +1,134 @@
-using System.IO;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class IArchiveEntryExtensions
 {
-    public static class IArchiveEntryExtensions
+    public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
     {
-        public static void WriteTo(this IArchiveEntry archiveEntry, Stream streamToWriteTo)
+        if (archiveEntry.IsDirectory)
         {
-            if (archiveEntry.IsDirectory)
-            {
-                throw new ExtractionException("Entry is a file directory and cannot be extracted.");
-            }
-
-            var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
-            streamListener.EnsureEntriesLoaded();
-            streamListener.FireEntryExtractionBegin(archiveEntry);
-            streamListener.FireFilePartExtractionBegin(archiveEntry.Key, archiveEntry.Size, archiveEntry.CompressedSize);
-            var entryStream = archiveEntry.OpenEntryStream();
-            if (entryStream is null)
-            {
-                return;
-            }
-            using (entryStream)
-            {
-                using (Stream s = new ListeningStream(streamListener, entryStream))
-                {
-                    s.TransferTo(streamToWriteTo);
-                }
-            }
-            streamListener.FireEntryExtractionEnd(archiveEntry);
-        }
-        
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory,
-                                            ExtractionOptions? options = null)
-        {
-            ExtractionMethods.WriteEntryToDirectory(entry, destinationDirectory, options,
-                                              entry.WriteToFile);
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
         }
 
-        /// <summary>
-        /// Extract to specific file
-        /// </summary>
-        public static void WriteToFile(this IArchiveEntry entry, 
-                                       string destinationFileName,
-                                       ExtractionOptions? options = null)
+        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+        streamListener.EnsureEntriesLoaded();
+        streamListener.FireEntryExtractionBegin(archiveEntry);
+        streamListener.FireFilePartExtractionBegin(
+            archiveEntry.Key ?? "Key",
+            archiveEntry.Size,
+            archiveEntry.CompressedSize
+        );
+        var entryStream = archiveEntry.OpenEntryStream();
+        using (entryStream)
         {
-            
-            ExtractionMethods.WriteEntryToFile(entry, destinationFileName, options,
-                                               (x, fm) =>
-                                               {
-                                                   using (FileStream fs = File.Open(destinationFileName, fm))
-                                                   {
-                                                       entry.WriteTo(fs);
-                                                   }
-                                               });
+            using Stream s = new ListeningStream(streamListener, entryStream);
+            s.CopyTo(streamToWriteTo);
         }
+        streamListener.FireEntryExtractionEnd(archiveEntry);
     }
-}
+
+    public static async Task WriteToAsync(
+        this IArchiveEntry archiveEntry,
+        Stream streamToWriteTo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (archiveEntry.IsDirectory)
+        {
+            throw new ExtractionException("Entry is a file directory and cannot be extracted.");
+        }
+
+        var streamListener = (IArchiveExtractionListener)archiveEntry.Archive;
+        streamListener.EnsureEntriesLoaded();
+        streamListener.FireEntryExtractionBegin(archiveEntry);
+        streamListener.FireFilePartExtractionBegin(
+            archiveEntry.Key ?? "Key",
+            archiveEntry.Size,
+            archiveEntry.CompressedSize
+        );
+        var entryStream = archiveEntry.OpenEntryStream();
+        using (entryStream)
+        {
+            using Stream s = new ListeningStream(streamListener, entryStream);
+            await s.CopyToAsync(streamToWriteTo, 81920, cancellationToken).ConfigureAwait(false);
+        }
+        streamListener.FireEntryExtractionEnd(archiveEntry);
+    }
+
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchiveEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    ) =>
+        ExtractionMethods.WriteEntryToDirectory(
+            entry,
+            destinationDirectory,
+            options,
+            entry.WriteToFile
+        );
+
+    /// <summary>
+    /// Extract to specific directory asynchronously, retaining filename
+    /// </summary>
+    public static Task WriteToDirectoryAsync(
+        this IArchiveEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    ) =>
+        ExtractionMethods.WriteEntryToDirectoryAsync(
+            entry,
+            destinationDirectory,
+            options,
+            (x, opt) => entry.WriteToFileAsync(x, opt, cancellationToken),
+            cancellationToken
+        );
+
+    /// <summary>
+    /// Extract to specific file
+    /// </summary>
+    public static void WriteToFile(
+        this IArchiveEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options = null
+    ) =>
+        ExtractionMethods.WriteEntryToFile(
+            entry,
+            destinationFileName,
+            options,
+            (x, fm) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                entry.WriteTo(fs);
+            }
+        );
+
+    /// <summary>
+    /// Extract to specific file asynchronously
+    /// </summary>
+    public static Task WriteToFileAsync(
+        this IArchiveEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options = null,
+        CancellationToken cancellationToken = default
+    ) =>
+        ExtractionMethods.WriteEntryToFileAsync(
+            entry,
+            destinationFileName,
+            options,
+            async (x, fm) =>
+            {
+                using var fs = File.Open(destinationFileName, fm);
+                await entry.WriteToAsync(fs, cancellationToken).ConfigureAwait(false);
+            },
+            cancellationToken
+        );
+}

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -1,20 +1,85 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
 using SharpCompress.Common;
+using SharpCompress.Readers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class IArchiveExtensions
 {
-    public static class IArchiveExtensions
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteToDirectory(
+        this IArchive archive,
+        string destinationDirectory,
+        ExtractionOptions? options = null
+    )
     {
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteToDirectory(this IArchive archive, string destinationDirectory,
-                                            ExtractionOptions? options = null)
+        using var reader = archive.ExtractAllEntries();
+        reader.WriteAllToDirectory(destinationDirectory, options);
+    }
+
+    /// <summary>
+    /// Extracts the archive to the destination directory. Directories will be created as needed.
+    /// </summary>
+    /// <param name="archive">The archive to extract.</param>
+    /// <param name="destination">The folder to extract into.</param>
+    /// <param name="progressReport">Optional progress report callback.</param>
+    /// <param name="cancellationToken">Optional cancellation token.</param>
+    public static void ExtractToDirectory(
+        this IArchive archive,
+        string destination,
+        Action<double>? progressReport = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Prepare for progress reporting
+        var totalBytes = archive.TotalUncompressSize;
+        var bytesRead = 0L;
+
+        // Tracking for created directories.
+        var seenDirectories = new HashSet<string>();
+
+        // Extract
+        foreach (var entry in archive.Entries)
         {
-            foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory))
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (entry.IsDirectory)
             {
-                entry.WriteToDirectory(destinationDirectory, options);
+                var dirPath = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
+                if (
+                    Path.GetDirectoryName(dirPath + "/") is { } emptyDirectory
+                    && seenDirectories.Add(dirPath)
+                )
+                {
+                    Directory.CreateDirectory(emptyDirectory);
+                }
+                continue;
             }
+
+            // Create each directory if not already created
+            var path = Path.Combine(destination, entry.Key.NotNull("Entry Key is null"));
+            if (Path.GetDirectoryName(path) is { } directory)
+            {
+                if (!Directory.Exists(directory) && !seenDirectories.Contains(directory))
+                {
+                    Directory.CreateDirectory(directory);
+                    seenDirectories.Add(directory);
+                }
+            }
+
+            // Write file
+            using var fs = File.OpenWrite(path);
+            entry.WriteTo(fs);
+
+            // Update progress
+            bytesRead += entry.Size;
+            progressReport?.Invoke(bytesRead / (double)totalBytes);
         }
     }
-}
+}

src/SharpCompress/Archives/IArchiveExtractionListener.cs

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

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -0,0 +1,35 @@
+using System.IO;
+using SharpCompress.Factories;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+/// <summary>
+/// Represents a factory used to identify and open archives.
+/// </summary>
+/// <remarks>
+/// Currently implemented by:<br/>
+/// <list type="table">
+/// <item><see cref="TarFactory"/></item>
+/// <item><see cref="RarFactory"/></item>
+/// <item><see cref="ZipFactory"/></item>
+/// <item><see cref="GZipFactory"/></item>
+/// <item><see cref="SevenZipFactory"/></item>
+/// </list>
+/// </remarks>
+public interface IArchiveFactory : IFactory
+{
+    /// <summary>
+    /// Opens an Archive for random access.
+    /// </summary>
+    /// <param name="stream">An open, readable and seekable stream.</param>
+    /// <param name="readerOptions">reading options.</param>
+    IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo">the file to open.</param>
+    /// <param name="readerOptions">reading options.</param>
+    IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
+}

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Factories;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+/// <summary>
+/// Represents a factory used to identify and open archives.
+/// </summary>
+/// <remarks>
+/// Implemented by:<br/>
+/// <list type="table">
+/// <item><see cref="TarFactory"/></item>
+/// <item><see cref="RarFactory"/></item>
+/// <item><see cref="ZipFactory"/></item>
+/// <item><see cref="GZipFactory"/></item>
+/// <item><see cref="SevenZipFactory"/></item>
+/// </list>
+/// </remarks>
+public interface IMultiArchiveFactory : IFactory
+{
+    /// <summary>
+    /// Constructor with IEnumerable FileInfo objects, multi and split support.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions">reading options.</param>
+    IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
+
+    /// <summary>
+    /// Constructor with IEnumerable Stream objects, multi and split support.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions">reading options.</param>
+    IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
+}

src/SharpCompress/Archives/IWritableArchive.cs

@@ -1,15 +1,36 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Writers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public interface IWritableArchive : IArchive
 {
-    public interface IWritableArchive : IArchive
-    {
-        void RemoveEntry(IArchiveEntry entry);
+    void RemoveEntry(IArchiveEntry entry);
 
-        IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);
+    IArchiveEntry AddEntry(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null
+    );
 
-        void SaveTo(Stream stream, WriterOptions options);
-    }
-}
+    IArchiveEntry AddDirectoryEntry(string key, DateTime? modified = null);
+
+    void SaveTo(Stream stream, WriterOptions options);
+
+    Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    );
+
+    /// <summary>
+    /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.
+    /// </summary>
+    /// <returns>IDisposeable to resume entry rebuilding</returns>
+    IDisposable PauseEntryRebuilding();
+}

src/SharpCompress/Archives/IWritableArchiveEntry.cs

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

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,54 +1,106 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Writers;
 
-namespace SharpCompress.Archives
+namespace SharpCompress.Archives;
+
+public static class IWritableArchiveExtensions
 {
-    public static class IWritableArchiveExtensions
+    public static void AddEntry(
+        this IWritableArchive writableArchive,
+        string entryPath,
+        string filePath
+    )
     {
-        public static void AddEntry(this IWritableArchive writableArchive,
-                                                     string entryPath, string filePath)
+        var fileInfo = new FileInfo(filePath);
+        if (!fileInfo.Exists)
         {
-            var fileInfo = new FileInfo(filePath);
-            if (!fileInfo.Exists)
-            {
-                throw new FileNotFoundException("Could not AddEntry: " + filePath);
-            }
-            writableArchive.AddEntry(entryPath, new FileInfo(filePath).OpenRead(), true, fileInfo.Length,
-                                     fileInfo.LastWriteTime);
+            throw new FileNotFoundException("Could not AddEntry: " + filePath);
         }
+        writableArchive.AddEntry(
+            entryPath,
+            new FileInfo(filePath).OpenRead(),
+            true,
+            fileInfo.Length,
+            fileInfo.LastWriteTime
+        );
+    }
 
-        public static void SaveTo(this IWritableArchive writableArchive, string filePath, WriterOptions options)
-        {
-            writableArchive.SaveTo(new FileInfo(filePath), options);
-        }
+    public static void SaveTo(
+        this IWritableArchive writableArchive,
+        string filePath,
+        WriterOptions options
+    ) => writableArchive.SaveTo(new FileInfo(filePath), options);
 
-        public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options)
-        {
-            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
-            {
-                writableArchive.SaveTo(stream, options);
-            }
-        }
+    public static void SaveTo(
+        this IWritableArchive writableArchive,
+        FileInfo fileInfo,
+        WriterOptions options
+    )
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        writableArchive.SaveTo(stream, options);
+    }
 
-        public static void AddAllFromDirectory(
-            this IWritableArchive writableArchive,
-            string filePath, string searchPattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories)
+    public static Task SaveToAsync(
+        this IWritableArchive writableArchive,
+        string filePath,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    ) => writableArchive.SaveToAsync(new FileInfo(filePath), options, cancellationToken);
+
+    public static async Task SaveToAsync(
+        this IWritableArchive writableArchive,
+        FileInfo fileInfo,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await writableArchive.SaveToAsync(stream, options, cancellationToken).ConfigureAwait(false);
+    }
+
+    public static void AddAllFromDirectory(
+        this IWritableArchive writableArchive,
+        string filePath,
+        string searchPattern = "*.*",
+        SearchOption searchOption = SearchOption.AllDirectories
+    )
+    {
+        using (writableArchive.PauseEntryRebuilding())
         {
             foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
             {
                 var fileInfo = new FileInfo(path);
-                writableArchive.AddEntry(path.Substring(filePath.Length), fileInfo.OpenRead(), true, fileInfo.Length,
-                                         fileInfo.LastWriteTime);
+                writableArchive.AddEntry(
+                    path.Substring(filePath.Length),
+                    fileInfo.OpenRead(),
+                    true,
+                    fileInfo.Length,
+                    fileInfo.LastWriteTime
+                );
             }
         }
-        public static IArchiveEntry AddEntry(this IWritableArchive writableArchive, string key, FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                throw new ArgumentException("FileInfo does not exist.");
-            }
-            return writableArchive.AddEntry(key, fileInfo.OpenRead(), true, fileInfo.Length, fileInfo.LastWriteTime);
-        }
     }
-}
+
+    public static IArchiveEntry AddEntry(
+        this IWritableArchive writableArchive,
+        string key,
+        FileInfo fileInfo
+    )
+    {
+        if (!fileInfo.Exists)
+        {
+            throw new ArgumentException("FileInfo does not exist.");
+        }
+        return writableArchive.AddEntry(
+            key,
+            fileInfo.OpenRead(),
+            true,
+            fileInfo.Length,
+            fileInfo.LastWriteTime
+        );
+    }
+}

src/SharpCompress/Archives/IWriteableArchiveFactory.cs

@@ -0,0 +1,20 @@
+namespace SharpCompress.Archives;
+
+/// <summary>
+/// Decorator for <see cref="Factories.Factory"/> used to declare an archive format as able to create writeable archives
+/// </summary>
+/// <remarks>
+/// Implemented by:<br/>
+/// <list type="table">
+/// <item><see cref="Factories.TarFactory"/></item>
+/// <item><see cref="Factories.ZipFactory"/></item>
+/// <item><see cref="Factories.GZipFactory"/></item>
+/// </list>
+public interface IWriteableArchiveFactory : Factories.IFactory
+{
+    /// <summary>
+    /// Creates a new, empty archive, ready to be written.
+    /// </summary>
+    /// <returns></returns>
+    IWritableArchive CreateWriteableArchive();
+}

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

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

src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs

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

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

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

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -5,135 +6,203 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Rar;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
 {
-    public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
+    private bool _disposed;
+    internal Lazy<IRarUnpack> UnpackV2017 { get; } =
+        new(() => new Compressors.Rar.UnpackV2017.Unpack());
+    internal Lazy<IRarUnpack> UnpackV1 { get; } = new(() => new Compressors.Rar.UnpackV1.Unpack());
+
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
+    private RarArchive(SourceStream sourceStream)
+        : base(ArchiveType.Rar, sourceStream) { }
+
+    public override void Dispose()
     {
-        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)
+        if (!_disposed)
         {
-        }
-
-        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
-        {
-            return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
-        }
-
-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="streams"></param>
-        /// <param name="options"></param>
-        internal RarArchive(IEnumerable<Stream> streams, ReaderOptions options)
-            : base(ArchiveType.Rar, streams, options)
-        {
-        }
-
-        protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes)
-        {
-            return RarArchiveEntryFactory.GetEntries(this, volumes);
-        }
-
-        protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return RarArchiveVolumeFactory.GetParts(streams, ReaderOptions);
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.First().Stream;
-            stream.Position = 0;
-            return RarReader.Open(stream, ReaderOptions);
-        }
-
-        public override bool IsSolid => Volumes.First().IsSolidArchive;
-
-        #region Creation
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="options"></param>
-        public static RarArchive Open(string filePath, ReaderOptions? options = null)
-        {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
-        }
-
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
-        {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new RarArchive(fileInfo, options ?? new ReaderOptions());
-        }
-
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        public static RarArchive Open(Stream stream, ReaderOptions? options = null)
-        {
-            stream.CheckNotNull(nameof(stream));
-            return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
-        }
-
-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="streams"></param>
-        /// <param name="options"></param>
-        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
-        {
-            streams.CheckNotNull(nameof(streams));
-            return new RarArchive(streams, options ?? new ReaderOptions());
-        }
-
-        public static bool IsRarFile(string filePath)
-        {
-            return IsRarFile(new FileInfo(filePath));
-        }
-
-        public static bool IsRarFile(FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
+            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
             {
-                return false;
+                unpackV1.Dispose();
             }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsRarFile(stream);
-            }
-        }
-        
-        public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
-        {
-            try
-            {
-                MarkHeader.Read(stream, true, false);
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
-        }
 
-        #endregion
+            _disposed = true;
+            base.Dispose();
+        }
     }
+
+    protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
+        RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
+
+    protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
+    {
+        sourceStream.LoadAllParts(); //request all streams
+        var streams = sourceStream.Streams.ToArray();
+        var i = 0;
+        if (streams.Length > 1 && IsRarFile(streams[1], ReaderOptions)) //test part 2 - true = multipart not split
+        {
+            sourceStream.IsVolumes = true;
+            streams[1].Position = 0;
+            sourceStream.Position = 0;
+
+            return sourceStream.Streams.Select(a => new StreamRarArchiveVolume(
+                a,
+                ReaderOptions,
+                i++
+            ));
+        }
+
+        //split mode or single file
+        return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
+    }
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        if (this.IsMultipartVolume())
+        {
+            var streams = Volumes.Select(volume =>
+            {
+                volume.Stream.Position = 0;
+                return volume.Stream;
+            });
+            return RarReader.Open(streams, ReaderOptions);
+        }
+
+        var stream = Volumes.First().Stream;
+        stream.Position = 0;
+        return RarReader.Open(stream, ReaderOptions);
+    }
+
+    public override bool IsSolid => Volumes.First().IsSolidArchive;
+
+    public virtual int MinVersion => Volumes.First().MinVersion;
+    public virtual int MaxVersion => Volumes.First().MaxVersion;
+
+    #region Creation
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    public static RarArchive Open(string filePath, ReaderOptions? options = null)
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        var fileInfo = new FileInfo(filePath);
+        return new RarArchive(
+            new SourceStream(
+                fileInfo,
+                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                options ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
+    {
+        fileInfo.NotNull(nameof(fileInfo));
+        return new RarArchive(
+            new SourceStream(
+                fileInfo,
+                i => RarArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                options ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="options"></param>
+    public static RarArchive Open(Stream stream, ReaderOptions? options = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
+        {
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
+        }
+
+        return new RarArchive(new SourceStream(stream, _ => null, options ?? new ReaderOptions()));
+    }
+
+    /// <summary>
+    /// 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.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new RarArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new RarArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
+
+    public static bool IsRarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
+        {
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsRarFile(stream);
+    }
+
+    public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
+    {
+        try
+        {
+            MarkHeader.Read(stream, true, false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    #endregion
 }

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -2,83 +2,136 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Compressors.Rar;
+using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+public class RarArchiveEntry : RarEntry, IArchiveEntry
 {
-    public class RarArchiveEntry : RarEntry, IArchiveEntry
+    private readonly ICollection<RarFilePart> parts;
+    private readonly RarArchive archive;
+    private readonly ReaderOptions readerOptions;
+
+    internal RarArchiveEntry(
+        RarArchive archive,
+        IEnumerable<RarFilePart> parts,
+        ReaderOptions readerOptions
+    )
     {
-        private readonly ICollection<RarFilePart> parts;
-        private readonly RarArchive archive;
+        this.parts = parts.ToList();
+        this.archive = archive;
+        this.readerOptions = readerOptions;
+        IsSolid = FileHeader.IsSolid;
+    }
 
-        internal RarArchiveEntry(RarArchive archive, IEnumerable<RarFilePart> parts)
+    public override CompressionType CompressionType => CompressionType.Rar;
+
+    public IArchive Archive => archive;
+
+    internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();
+
+    internal override FileHeader FileHeader => parts.First().FileHeader;
+
+    public override long Crc
+    {
+        get
         {
-            this.parts = parts.ToList();
-            this.archive = archive;
-        }
-
-        public override CompressionType CompressionType => CompressionType.Rar;
-
-        public IArchive Archive => archive;
-
-        internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();
-
-        internal override FileHeader FileHeader => parts.First().FileHeader;
-
-        public override long Crc
-        {
-            get
-            {
-                CheckIncomplete();
-                return parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc;
-            }
-        }
-
-        public override long Size
-        {
-            get
-            {
-                CheckIncomplete();
-                return parts.First().FileHeader.UncompressedSize;
-            }
-        }
-
-        public override long CompressedSize
-        {
-            get
-            {
-                CheckIncomplete();
-                return parts.Aggregate(0L, (total, fp) => total + fp.FileHeader.CompressedSize);
-            }
-        }
-
-        public Stream OpenEntryStream()
-        {
-            if (IsRarV3)
-            {
-                return new RarStream(archive.UnpackV1.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
-            }
-            
-            return new RarStream(archive.UnpackV2017.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
-        }
-
-        public bool IsComplete 
-        { 
-            get 
-            { 
-                return parts.Select(fp => fp.FileHeader).Any(fh => !fh.IsSplitAfter); 
-            } 
-        }
-
-        private void CheckIncomplete()
-        {
-            if (!IsComplete)
-            {
-                throw new IncompleteArchiveException("ArchiveEntry is incomplete and cannot perform this operation.");
-            }
+            CheckIncomplete();
+            return BitConverter.ToUInt32(
+                parts.Select(fp => fp.FileHeader).Single(fh => !fh.IsSplitAfter).FileCrc.NotNull(),
+                0
+            );
         }
     }
-}
+
+    public override long Size
+    {
+        get
+        {
+            CheckIncomplete();
+            return parts.First().FileHeader.UncompressedSize;
+        }
+    }
+
+    public override long CompressedSize
+    {
+        get
+        {
+            CheckIncomplete();
+            return parts.Aggregate(0L, (total, fp) => total + fp.FileHeader.CompressedSize);
+        }
+    }
+
+    public Stream OpenEntryStream()
+    {
+        RarStream stream;
+        if (IsRarV3)
+        {
+            stream = new RarStream(
+                archive.UnpackV1.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+
+        stream.Initialize();
+        return stream;
+    }
+
+    public async Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default)
+    {
+        RarStream stream;
+        if (IsRarV3)
+        {
+            stream = new RarStream(
+                archive.UnpackV1.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive)
+            );
+        }
+
+        await stream.InitializeAsync(cancellationToken);
+        return stream;
+    }
+
+    public bool IsComplete
+    {
+        get
+        {
+            var headers = parts.Select(x => x.FileHeader);
+            return !headers.First().IsSplitBefore && !headers.Last().IsSplitAfter;
+        }
+    }
+
+    private void CheckIncomplete()
+    {
+        if (!readerOptions.DisableCheckIncomplete && !IsComplete)
+        {
+            throw new IncompleteArchiveException(
+                "ArchiveEntry is incomplete and cannot perform this operation."
+            );
+        }
+    }
+}

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

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

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -1,142 +1,52 @@
-using System;
-using System.Collections.Generic;
+using System;
 using System.IO;
-using SharpCompress.Common.Rar;
-using SharpCompress.Readers;
-using System.Linq;
-using System.Text;
-using SharpCompress.Common.Rar.Headers;
+using System.Text.RegularExpressions;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+internal static class RarArchiveVolumeFactory
 {
-    internal static class RarArchiveVolumeFactory
+    internal static FileInfo? GetFilePart(int index, FileInfo part1) //base the name on the first part
     {
-        internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, ReaderOptions options)
-        {
-            foreach (Stream s in streams)
-            {
-                if (!s.CanRead || !s.CanSeek)
-                {
-                    throw new ArgumentException("Stream is not readable and seekable");
-                }
-                StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, options);
-                yield return part;
-            }
-        }
-        
-        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
-        {
-            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
-            yield return part;
+        FileInfo? item = null;
 
-            ArchiveHeader ah = part.ArchiveHeader;
-            if (!ah.IsVolume)
-            {
-                yield break; //if file isn't volume then there is no reason to look
-            }
-            fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
-            //we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
-            while (fileInfo != null && fileInfo.Exists)
-            {
-                part = new FileInfoRarArchiveVolume(fileInfo, options);
-
-                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
-                yield return part;
-            }
+        //new style rar - ..part1 | /part01 | part001 ....
+        var m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
+        if (m.Success)
+            item = new FileInfo(
+                Path.Combine(
+                    part1.DirectoryName!,
+                    String.Concat(
+                        m.Groups[1].Value,
+                        (index + 1).ToString().PadLeft(m.Groups[2].Value.Length, '0'),
+                        m.Groups[3].Value
+                    )
+                )
+            );
+        else
+        {
+            //old style - ...rar, .r00, .r01 ...
+            m = Regex.Match(part1.Name, @"^(.*\.)([r-z{])(ar|[0-9]+)$", RegexOptions.IgnoreCase);
+            if (m.Success)
+                item = new FileInfo(
+                    Path.Combine(
+                        part1.DirectoryName!,
+                        String.Concat(
+                            m.Groups[1].Value,
+                            index == 0
+                                ? m.Groups[2].Value + m.Groups[3].Value
+                                : (char)(m.Groups[2].Value[0] + ((index - 1) / 100))
+                                    + (index - 1).ToString("D4").Substring(2)
+                        )
+                    )
+                );
+            else //split .001, .002 ....
+                return ArchiveVolumeFactory.GetFilePart(index, part1);
         }
 
-        private static FileInfo? GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart? currentFilePart)
-        {
-            if (currentFilePart is null)
-            {
-                return null;
-            }
-            bool oldNumbering = ah.OldNumberingFormat
-                                || currentFilePart.MarkHeader.OldNumberingFormat;
-            if (oldNumbering)
-            {
-                return FindNextFileWithOldNumbering(currentFilePart.FileInfo);
-            }
-            else
-            {
-                return FindNextFileWithNewNumbering(currentFilePart.FileInfo);
-            }
-        }
+        if (item != null && item.Exists)
+            return item;
 
-        private static FileInfo FindNextFileWithOldNumbering(FileInfo currentFileInfo)
-        {
-            // .rar, .r00, .r01, ...
-            string extension = currentFileInfo.Extension;
-
-            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
-            buffer.Append(currentFileInfo.FullName.Substring(0,
-                                                             currentFileInfo.FullName.Length - extension.Length));
-            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) == 0)
-            {
-                buffer.Append(".r00");
-            }
-            else
-            {
-                int num = 0;
-                if (int.TryParse(extension.Substring(2, 2), out num))
-                {
-                    num++;
-                    buffer.Append(".r");
-                    if (num < 10)
-                    {
-                        buffer.Append('0');
-                    }
-                    buffer.Append(num);
-                }
-                else
-                {
-                    ThrowInvalidFileName(currentFileInfo);
-                }
-            }
-            return new FileInfo(buffer.ToString());
-        }
-
-        private static FileInfo FindNextFileWithNewNumbering(FileInfo currentFileInfo)
-        {
-            // part1.rar, part2.rar, ...
-            string extension = currentFileInfo.Extension;
-            if (string.Compare(extension, ".rar", StringComparison.OrdinalIgnoreCase) != 0)
-            {
-                throw new ArgumentException("Invalid extension, expected 'rar': " + currentFileInfo.FullName);
-            }
-            int startIndex = currentFileInfo.FullName.LastIndexOf(".part");
-            if (startIndex < 0)
-            {
-                ThrowInvalidFileName(currentFileInfo);
-            }
-            StringBuilder buffer = new StringBuilder(currentFileInfo.FullName.Length);
-            buffer.Append(currentFileInfo.FullName, 0, startIndex);
-            int num = 0;
-            string numString = currentFileInfo.FullName.Substring(startIndex + 5,
-                                                                  currentFileInfo.FullName.IndexOf('.', startIndex + 5) -
-                                                                  startIndex - 5);
-            buffer.Append(".part");
-            if (int.TryParse(numString, out num))
-            {
-                num++;
-                for (int i = 0; i < numString.Length - num.ToString().Length; i++)
-                {
-                    buffer.Append('0');
-                }
-                buffer.Append(num);
-            }
-            else
-            {
-                ThrowInvalidFileName(currentFileInfo);
-            }
-            buffer.Append(".rar");
-            return new FileInfo(buffer.ToString());
-        }
-
-        private static void ThrowInvalidFileName(FileInfo fileInfo)
-        {
-            throw new ArgumentException("Filename invalid or next archive could not be found:"
-                                        + fileInfo.FullName);
-        }
+        return null; //no more items
     }
-}
+}

src/SharpCompress/Archives/Rar/SeekableFilePart.cs

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

src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs

@@ -1,27 +1,19 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.Rar
+namespace SharpCompress.Archives.Rar;
+
+internal class StreamRarArchiveVolume : RarVolume
 {
-    internal class StreamRarArchiveVolume : RarVolume
-    {
-        internal StreamRarArchiveVolume(Stream stream, ReaderOptions options)
-            : base(StreamingMode.Seekable, stream, options)
-        {
-        }
+    internal StreamRarArchiveVolume(Stream stream, ReaderOptions options, int index)
+        : base(StreamingMode.Seekable, stream, options, index) { }
 
-        internal override IEnumerable<RarFilePart> ReadFileParts()
-        {
-            return GetVolumeFileParts();
-        }
+    internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
 
-        internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader)
-        {
-            return new SeekableFilePart(markHeader, fileHeader, Stream, ReaderOptions.Password);
-        }
-    }
-}
+    internal override RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader) =>
+        new SeekableFilePart(markHeader, fileHeader, Index, Stream, ReaderOptions.Password);
+}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -10,213 +8,266 @@ using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Archives.SevenZip
+namespace SharpCompress.Archives.SevenZip;
+
+public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
 {
-    public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
+    private ArchiveDatabase? _database;
+
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        private ArchiveDatabase database;
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static SevenZipArchive Open(string filePath, ReaderOptions readerOptions = null)
+        filePath.NotNullOrEmpty("filePath");
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull("fileInfo");
+        return new SevenZipArchive(
+            new SourceStream(
+                fileInfo,
+                i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all file parts passed in
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new SevenZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(
+        IEnumerable<Stream> streams,
+        ReaderOptions? readerOptions = null
+    )
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new SevenZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static SevenZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull("stream");
+
+        if (stream is not { CanSeek: true })
         {
-            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
         }
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
-        {
-            fileInfo.CheckNotNull("fileInfo");
-            return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
-        }
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
-        {
-            stream.CheckNotNull("stream");
-            return new SevenZipArchive(stream, readerOptions ?? new ReaderOptions());
-        }
+        return new SevenZipArchive(
+            new SourceStream(stream, _ => null, readerOptions ?? new ReaderOptions())
+        );
+    }
 
-        internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
-            : base(ArchiveType.SevenZip, fileInfo, readerOptions)
-        {
-        }
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
+    private SevenZipArchive(SourceStream sourceStream)
+        : base(ArchiveType.SevenZip, sourceStream) { }
 
-        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
-        {
-            return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
-        }
+    protected override IEnumerable<SevenZipVolume> LoadVolumes(SourceStream sourceStream)
+    {
+        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
+        return new SevenZipVolume(sourceStream, ReaderOptions, 0).AsEnumerable(); //simple single volume or split, multivolume not supported
+    }
 
-        public static bool IsSevenZipFile(string filePath)
-        {
-            return IsSevenZipFile(new FileInfo(filePath));
-        }
+    public static bool IsSevenZipFile(string filePath) => IsSevenZipFile(new FileInfo(filePath));
 
-        public static bool IsSevenZipFile(FileInfo fileInfo)
+    public static bool IsSevenZipFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
         {
-            if (!fileInfo.Exists)
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsSevenZipFile(stream);
+    }
+
+    internal SevenZipArchive()
+        : base(ArchiveType.SevenZip) { }
+
+    protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(
+        IEnumerable<SevenZipVolume> volumes
+    )
+    {
+        var stream = volumes.Single().Stream;
+        LoadFactory(stream);
+        if (_database is null)
+        {
+            return Enumerable.Empty<SevenZipArchiveEntry>();
+        }
+        var entries = new SevenZipArchiveEntry[_database._files.Count];
+        for (var i = 0; i < _database._files.Count; i++)
+        {
+            var file = _database._files[i];
+            entries[i] = new SevenZipArchiveEntry(
+                this,
+                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
+            );
+        }
+        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+        {
+            var isSolid = false;
+            foreach (var entry in group)
             {
-                return false;
-            }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsSevenZipFile(stream);
+                entry.IsSolid = isSolid;
+                isSolid = true; //mark others in this group as solid - same as rar behaviour.
             }
         }
 
-        internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
-            : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
+        return entries;
+    }
+
+    private void LoadFactory(Stream stream)
+    {
+        if (_database is null)
         {
-        }
-
-        internal SevenZipArchive()
-            : base(ArchiveType.SevenZip)
-        {
-        }
-
-        protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            foreach (Stream s in streams)
-            {
-                if (!s.CanRead || !s.CanSeek)
-                {
-                    throw new ArgumentException("Stream is not readable and seekable");
-                }
-                SevenZipVolume volume = new SevenZipVolume(s, ReaderOptions);
-                yield return volume;
-            }
-        }
-
-        protected override IEnumerable<SevenZipArchiveEntry> LoadEntries(IEnumerable<SevenZipVolume> volumes)
-        {
-            var stream = volumes.Single().Stream;
-            LoadFactory(stream);
-            for (int i = 0; i < database._files.Count; i++)
-            {
-                var file = database._files[i];
-                yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding));
-            }
-        }
-
-        private void LoadFactory(Stream stream)
-        {
-            if (database is null)
-            {
-                stream.Position = 0;
-                var reader = new ArchiveReader();
-                reader.Open(stream);
-                database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
-            }
-        }
-
-        public static bool IsSevenZipFile(Stream stream)
-        {
-            try
-            {
-                return SignatureMatch(stream);
-            }
-            catch
-            {
-                return false;
-            }
-        }
-
-        private static ReadOnlySpan<byte> SIGNATURE => new byte[] {(byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C};
-
-        private static bool SignatureMatch(Stream stream)
-        {
-            BinaryReader reader = new BinaryReader(stream);
-            ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
-            return signatureBytes.SequenceEqual(SIGNATURE);
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            return new SevenZipReader(ReaderOptions, this);
-        }
-
-        public override bool IsSolid { get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; } }
-
-        public override long TotalSize
-        {
-            get
-            {
-                int i = Entries.Count;
-                return database._packSizes.Aggregate(0L, (total, packSize) => total + packSize);
-            }
-        }
-
-        private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
-        {
-            private readonly SevenZipArchive archive;
-            private CFolder currentFolder;
-            private Stream currentStream;
-            private CFileItem currentItem;
-
-            internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-                : base(readerOptions, ArchiveType.SevenZip)
-            {
-                this.archive = archive;
-            }
-
-            public override SevenZipVolume Volume => archive.Volumes.Single();
-
-            protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
-            {
-                List<SevenZipArchiveEntry> entries = archive.Entries.ToList();
-                stream.Position = 0;
-                foreach (var dir in entries.Where(x => x.IsDirectory))
-                {
-                    yield return dir;
-                }
-                foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
-                {
-                    currentFolder = group.Key;
-                    if (group.Key is null)
-                    {
-                        currentStream = Stream.Null;
-                    }
-                    else
-                    {
-                        currentStream = archive.database.GetFolderStream(stream, currentFolder, new PasswordProvider(Options.Password));
-                    }
-                    foreach (var entry in group)
-                    {
-                        currentItem = entry.FilePart.Header;
-                        yield return entry;
-                    }
-                }
-            }
-
-            protected override EntryStream GetEntryStream()
-            {
-                return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
-            }
-        }
-
-        private class PasswordProvider : IPasswordProvider
-        {
-            private readonly string _password;
-
-            public PasswordProvider(string password)
-            {
-                _password = password;
-            }
-
-            public string CryptoGetTextPassword()
-            {
-                return _password;
-            }
+            stream.Position = 0;
+            var reader = new ArchiveReader();
+            reader.Open(stream, lookForHeader: ReaderOptions.LookForHeader);
+            _database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
         }
     }
+
+    public static bool IsSevenZipFile(Stream stream)
+    {
+        try
+        {
+            return SignatureMatch(stream);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private static ReadOnlySpan<byte> Signature =>
+        new byte[] { (byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C };
+
+    private static bool SignatureMatch(Stream stream)
+    {
+        var reader = new BinaryReader(stream);
+        ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
+        return signatureBytes.SequenceEqual(Signature);
+    }
+
+    protected override IReader CreateReaderForSolidExtraction() =>
+        new SevenZipReader(ReaderOptions, this);
+
+    public override bool IsSolid =>
+        Entries
+            .Where(x => !x.IsDirectory)
+            .GroupBy(x => x.FilePart.Folder)
+            .Any(folder => folder.Count() > 1);
+
+    public override long TotalSize =>
+        _database?._packSizes.Aggregate(0L, (total, packSize) => total + packSize) ?? 0;
+
+    private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+    {
+        private readonly SevenZipArchive _archive;
+        private CFolder? _currentFolder;
+        private Stream? _currentStream;
+        private CFileItem? _currentItem;
+
+        internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
+            : base(readerOptions, ArchiveType.SevenZip) => this._archive = archive;
+
+        public override SevenZipVolume Volume => _archive.Volumes.Single();
+
+        protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
+        {
+            var entries = _archive.Entries.ToList();
+            stream.Position = 0;
+            foreach (var dir in entries.Where(x => x.IsDirectory))
+            {
+                yield return dir;
+            }
+            foreach (
+                var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder)
+            )
+            {
+                _currentFolder = group.Key;
+                if (group.Key is null)
+                {
+                    _currentStream = Stream.Null;
+                }
+                else
+                {
+                    _currentStream = _archive._database?.GetFolderStream(
+                        stream,
+                        _currentFolder,
+                        new PasswordProvider(Options.Password)
+                    );
+                }
+                foreach (var entry in group)
+                {
+                    _currentItem = entry.FilePart.Header;
+                    yield return entry;
+                }
+            }
+        }
+
+        protected override EntryStream GetEntryStream() =>
+            CreateEntryStream(
+                new ReadOnlySubStream(
+                    _currentStream.NotNull("currentStream is not null"),
+                    _currentItem?.Size ?? 0
+                )
+            );
+    }
+
+    private class PasswordProvider : IPasswordProvider
+    {
+        private readonly string? _password;
+
+        public PasswordProvider(string? password) => _password = password;
+
+        public string? CryptoGetTextPassword() => _password;
+    }
 }

src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs

@@ -1,28 +1,26 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.SevenZip;
 
-namespace SharpCompress.Archives.SevenZip
+namespace SharpCompress.Archives.SevenZip;
+
+public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
 {
-    public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
-    {
-        internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
-            : base(part)
-        {
-            Archive = archive;
-        }
+    internal SevenZipArchiveEntry(SevenZipArchive archive, SevenZipFilePart part)
+        : base(part) => Archive = archive;
 
-        public Stream OpenEntryStream()
-        {
-            return FilePart.GetCompressedStream();
-        }
+    public Stream OpenEntryStream() => FilePart.GetCompressedStream();
 
-        public IArchive Archive { get; }
+    public Task<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
+        Task.FromResult(OpenEntryStream());
 
-        public bool IsComplete => true;
+    public IArchive Archive { get; }
 
-        /// <summary>
-        /// This is a 7Zip Anti item
-        /// </summary>
-        public bool IsAnti => FilePart.Header.IsAnti;
-    }
-}
+    public bool IsComplete => true;
+
+    /// <summary>
+    /// This is a 7Zip Anti item
+    /// </summary>
+    public bool IsAnti => FilePart.Header.IsAnti;
+}

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -1,7 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
@@ -11,187 +13,293 @@ using SharpCompress.Readers.Tar;
 using SharpCompress.Writers;
 using SharpCompress.Writers.Tar;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
 {
-    public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
+    /// <summary>
+    /// Constructor expects a filepath to an existing file.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
     {
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
+
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull(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.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new TarArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new TarArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
         }
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-        {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
-        }
+        return new TarArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
 
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-        {
-            stream.CheckNotNull(nameof(stream));
-            return new TarArchive(stream, readerOptions ?? new ReaderOptions());
-        }
+    public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
 
-        public static bool IsTarFile(string filePath)
+    public static bool IsTarFile(FileInfo fileInfo)
+    {
+        if (!fileInfo.Exists)
         {
-            return IsTarFile(new FileInfo(filePath));
-        }
-
-        public static bool IsTarFile(FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                return false;
-            }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsTarFile(stream);
-            }
-        }
-
-        public static bool IsTarFile(Stream stream)
-        {
-            try
-            {
-                TarHeader tarHeader = new TarHeader(new ArchiveEncoding());
-                bool readSucceeded = tarHeader.Read(new BinaryReader(stream));
-                bool isEmptyArchive = tarHeader.Name.Length == 0 && tarHeader.Size == 0 && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
-                return readSucceeded || isEmptyArchive;
-            }
-            catch
-            {
-            }
             return false;
         }
-        
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        internal TarArchive(FileInfo fileInfo, ReaderOptions readerOptions)
-            : base(ArchiveType.Tar, fileInfo, readerOptions)
-        {
-        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsTarFile(stream);
+    }
 
-        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
+    public static bool IsTarFile(Stream stream)
+    {
+        try
         {
-            return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
+            var tarHeader = new TarHeader(new ArchiveEncoding());
+            var readSucceeded = tarHeader.Read(new BinaryReader(stream));
+            var isEmptyArchive =
+                tarHeader.Name?.Length == 0
+                && tarHeader.Size == 0
+                && Enum.IsDefined(typeof(EntryType), tarHeader.EntryType);
+            return readSucceeded || isEmptyArchive;
         }
+        catch { }
+        return false;
+    }
 
-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        internal TarArchive(Stream stream, ReaderOptions readerOptions)
-            : base(ArchiveType.Tar, stream, readerOptions)
-        {
-        }
+    protected override IEnumerable<TarVolume> LoadVolumes(SourceStream sourceStream)
+    {
+        sourceStream.NotNull("SourceStream is null").LoadAllParts(); //request all streams
+        return new TarVolume(sourceStream, ReaderOptions, 1).AsEnumerable(); //simple single volume or split, multivolume not supported
+    }
 
-        internal TarArchive()
-            : base(ArchiveType.Tar)
-        {
-        }
+    /// <summary>
+    /// Constructor with a SourceStream able to handle FileInfo and Streams.
+    /// </summary>
+    /// <param name="sourceStream"></param>
+    private TarArchive(SourceStream sourceStream)
+        : base(ArchiveType.Tar, sourceStream) { }
 
-        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new TarVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
+    private TarArchive()
+        : base(ArchiveType.Tar) { }
 
-        protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
+    protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
+    {
+        var stream = volumes.Single().Stream;
+        TarHeader? previousHeader = null;
+        foreach (
+            var header in TarHeaderFactory.ReadHeader(
+                StreamingMode.Seekable,
+                stream,
+                ReaderOptions.ArchiveEncoding
+            )
+        )
         {
-            Stream stream = volumes.Single().Stream;
-            TarHeader? previousHeader = null;
-            foreach (TarHeader? header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
+            if (header != null)
             {
-                if (header != null)
+                if (header.EntryType == EntryType.LongName)
                 {
-                    if (header.EntryType == EntryType.LongName)
+                    previousHeader = header;
+                }
+                else
+                {
+                    if (previousHeader != null)
                     {
-                        previousHeader = header;
-                    }
-                    else
-                    {
-                        if (previousHeader != null)
+                        var entry = new TarArchiveEntry(
+                            this,
+                            new TarFilePart(previousHeader, stream),
+                            CompressionType.None
+                        );
+
+                        var oldStreamPos = stream.Position;
+
+                        using (var entryStream = entry.OpenEntryStream())
                         {
-                            var entry = new TarArchiveEntry(this, new TarFilePart(previousHeader, stream),
-                                                            CompressionType.None);
+                            using var memoryStream = new MemoryStream();
+                            entryStream.CopyTo(memoryStream);
+                            memoryStream.Position = 0;
+                            var bytes = memoryStream.ToArray();
 
-                            var oldStreamPos = stream.Position;
-
-                            using (var entryStream = entry.OpenEntryStream())
-                            {
-                                using (var memoryStream = new MemoryStream())
-                                {
-                                    entryStream.TransferTo(memoryStream);
-                                    memoryStream.Position = 0;
-                                    var bytes = memoryStream.ToArray();
-
-                                    header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
-                                }
-                            }
-
-                            stream.Position = oldStreamPos;
-
-                            previousHeader = null;
+                            header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
                         }
-                        yield return new TarArchiveEntry(this, new TarFilePart(header, stream), CompressionType.None);
+
+                        stream.Position = oldStreamPos;
+
+                        previousHeader = null;
                     }
+                    yield return new TarArchiveEntry(
+                        this,
+                        new TarFilePart(header, stream),
+                        CompressionType.None
+                    );
                 }
             }
-        }
-
-        public static TarArchive Create()
-        {
-            return new TarArchive();
-        }
-
-        protected override TarArchiveEntry CreateEntryInternal(string filePath, Stream source,
-                                                               long size, DateTime? modified, bool closeStream)
-        {
-            return new TarWritableArchiveEntry(this, source, CompressionType.Unknown, filePath, size, modified,
-                                               closeStream);
-        }
-
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<TarArchiveEntry> oldEntries,
-                                       IEnumerable<TarArchiveEntry> newEntries)
-        {
-            using (var writer = new TarWriter(stream, new TarWriterOptions(options)))
+            else
             {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
-                    }
-                }
+                throw new IncompleteArchiveException("Failed to read TAR header");
             }
         }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.Single().Stream;
-            stream.Position = 0;
-            return TarReader.Open(stream);
-        }
+    }
+
+    public static TarArchive Create() => new();
+
+    protected override TarArchiveEntry CreateEntryInternal(
+        string filePath,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    ) =>
+        new TarWritableArchiveEntry(
+            this,
+            source,
+            CompressionType.Unknown,
+            filePath,
+            size,
+            modified,
+            closeStream
+        );
+
+    protected override TarArchiveEntry CreateDirectoryEntry(
+        string directoryPath,
+        DateTime? modified
+    ) => new TarWritableArchiveEntry(this, directoryPath, modified);
+
+    protected override void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<TarArchiveEntry> newEntries
+    )
+    {
+        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries))
+        {
+            if (entry.IsDirectory)
+            {
+                writer.WriteDirectory(
+                    entry.Key.NotNull("Entry Key is null"),
+                    entry.LastModifiedTime
+                );
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                writer.Write(
+                    entry.Key.NotNull("Entry Key is null"),
+                    entryStream,
+                    entry.LastModifiedTime,
+                    entry.Size
+                );
+            }
+        }
+    }
+
+    protected override async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<TarArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries))
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        entry.LastModifiedTime,
+                        entry.Size,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return TarReader.Open(stream);
     }
 }

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -1,29 +1,28 @@
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+public class TarArchiveEntry : TarEntry, IArchiveEntry
 {
-    public class TarArchiveEntry : TarEntry, IArchiveEntry
-    {
-        internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
-            : base(part, compressionType)
-        {
-            Archive = archive;
-        }
+    internal TarArchiveEntry(TarArchive archive, TarFilePart? part, CompressionType compressionType)
+        : base(part, compressionType) => Archive = archive;
 
-        public virtual Stream OpenEntryStream()
-        {
-            return Parts.Single().GetCompressedStream();
-        }
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-        #region IArchiveEntry Members
+    public virtual Task<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => Task.FromResult(OpenEntryStream());
 
-        public IArchive Archive { get; }
+    #region IArchiveEntry Members
 
-        public bool IsComplete => true;
+    public IArchive Archive { get; }
 
-        #endregion
-    }
-}
+    public bool IsComplete => true;
+
+    #endregion
+}

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -1,67 +1,92 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.Tar
+namespace SharpCompress.Archives.Tar;
+
+internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
 {
-    internal sealed class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
+    private readonly bool closeStream;
+    private readonly Stream? stream;
+    private readonly bool isDirectory;
+
+    internal TarWritableArchiveEntry(
+        TarArchive archive,
+        Stream stream,
+        CompressionType compressionType,
+        string path,
+        long size,
+        DateTime? lastModified,
+        bool closeStream
+    )
+        : base(archive, null, compressionType)
     {
-        private readonly bool closeStream;
-        private readonly Stream stream;
+        this.stream = stream;
+        Key = path;
+        Size = size;
+        LastModifiedTime = lastModified;
+        this.closeStream = closeStream;
+        isDirectory = false;
+    }
 
-        internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType,
-                                         string path, long size, DateTime? lastModified, bool closeStream)
-            : base(archive, null, compressionType)
+    internal TarWritableArchiveEntry(
+        TarArchive archive,
+        string directoryPath,
+        DateTime? lastModified
+    )
+        : base(archive, null, CompressionType.None)
+    {
+        stream = null;
+        Key = directoryPath;
+        Size = 0;
+        LastModifiedTime = lastModified;
+        closeStream = false;
+        isDirectory = true;
+    }
+
+    public override long Crc => 0;
+
+    public override string Key { get; }
+
+    public override long CompressedSize => 0;
+
+    public override long Size { get; }
+
+    public override DateTime? LastModifiedTime { get; }
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => isDirectory;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
+    Stream IWritableArchiveEntry.Stream => stream ?? Stream.Null;
+
+    public override Stream OpenEntryStream()
+    {
+        if (stream is null)
         {
-            this.stream = stream;
-            Key = path;
-            Size = size;
-            LastModifiedTime = lastModified;
-            this.closeStream = closeStream;
+            return Stream.Null;
         }
+        //ensure new stream is at the start, this could be reset
+        stream.Seek(0, SeekOrigin.Begin);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
+    }
 
-        public override long Crc => 0;
-
-        public override string Key { get; }
-
-        public override long CompressedSize => 0;
-
-        public override long Size { get; }
-
-        public override DateTime? LastModifiedTime { get; }
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => false;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
-        Stream IWritableArchiveEntry.Stream => stream;
-
-        public override Stream OpenEntryStream()
+    internal override void Close()
+    {
+        if (closeStream && stream is not null)
         {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream)
-            {
-                stream.Dispose();
-            }
+            stream.Dispose();
         }
     }
-}
+}

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -1,207 +1,388 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Zip;
 using SharpCompress.Writers;
 using SharpCompress.Writers.Zip;
 
-namespace SharpCompress.Archives.Zip
+namespace SharpCompress.Archives.Zip;
+
+public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
 {
-    public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
+    private readonly SeekableZipHeaderFactory? headerFactory;
+
+    /// <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="sourceStream"></param>
+    /// <param name="options"></param>
+    internal ZipArchive(SourceStream sourceStream)
+        : base(ArchiveType.Zip, sourceStream) =>
+        headerFactory = new SeekableZipHeaderFactory(
+            sourceStream.ReaderOptions.Password,
+            sourceStream.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)
     {
-#nullable disable
-        private readonly SeekableZipHeaderFactory headerFactory;
-#nullable enable
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+    }
 
-        /// <summary>
-        /// Gets or sets the compression level applied to files added to the archive,
-        /// if the compression method is set to deflate
-        /// </summary>
-        public CompressionLevel DeflateCompressionLevel { get; set; }
-        
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="readerOptions"></param>
-        public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
+    /// <summary>
+    /// Constructor with a FileInfo object to an existing file.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
+    {
+        fileInfo.NotNull(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.NotNull(nameof(fileInfos));
+        var files = fileInfos.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                files[0],
+                i => i < files.Length ? files[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Constructor with all stream parts passed in
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(IEnumerable<Stream> streams, ReaderOptions? readerOptions = null)
+    {
+        streams.NotNull(nameof(streams));
+        var strms = streams.ToArray();
+        return new ZipArchive(
+            new SourceStream(
+                strms[0],
+                i => i < strms.Length ? strms[i] : null,
+                readerOptions ?? new ReaderOptions()
+            )
+        );
+    }
+
+    /// <summary>
+    /// Takes a seekable Stream as a source
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
+    {
+        stream.NotNull(nameof(stream));
+
+        if (stream is not { CanSeek: true })
         {
-            filePath.CheckNotNullOrEmpty(nameof(filePath));
-            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+            throw new ArgumentException("Stream must be seekable", nameof(stream));
         }
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
-        {
-            fileInfo.CheckNotNull(nameof(fileInfo));
-            return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
-        }
+        return new ZipArchive(
+            new SourceStream(stream, i => null, readerOptions ?? new ReaderOptions())
+        );
+    }
 
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
-        {
-            stream.CheckNotNull(nameof(stream));
-            return new ZipArchive(stream, readerOptions ?? new ReaderOptions());
-        }
-        
-        public static bool IsZipFile(string filePath, string? password = null)
-        {
-            return IsZipFile(new FileInfo(filePath), password);
-        }
+    public static bool IsZipFile(
+        string filePath,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    ) => IsZipFile(new FileInfo(filePath), password, bufferSize);
 
-        public static bool IsZipFile(FileInfo fileInfo, string? password = null)
+    public static bool IsZipFile(
+        FileInfo fileInfo,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        if (!fileInfo.Exists)
         {
-            if (!fileInfo.Exists)
+            return false;
+        }
+        using Stream stream = fileInfo.OpenRead();
+        return IsZipFile(stream, password, bufferSize);
+    }
+
+    public static bool IsZipFile(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
             {
                 return false;
             }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsZipFile(stream, password);
-            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
         }
-
-        public static bool IsZipFile(Stream stream, string? password = null)
+        catch (CryptographicException)
         {
-            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
-            try
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static bool IsZipMulti(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize
+    )
+    {
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
             {
-                ZipHeader header =
-                    headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-                if (header is null)
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
                 {
                     return false;
                 }
-                return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
-            }
-            catch (CryptographicException)
-            {
-                return true;
-            }
-            catch
-            {
-                return false;
             }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
         }
-        
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="readerOptions"></param>
-        internal ZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
-            : base(ArchiveType.Zip, fileInfo, readerOptions)
+        catch (CryptographicException)
         {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+            return true;
         }
-
-        protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
+        catch
         {
-            return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
-        }
-
-        internal ZipArchive()
-            : base(ArchiveType.Zip)
-        {
-        }
-
-        /// <summary>
-        /// Takes multiple seekable Streams for a multi-part archive
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="readerOptions"></param>
-        internal ZipArchive(Stream stream, ReaderOptions readerOptions)
-            : base(ArchiveType.Zip, stream, readerOptions)
-        {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
-        }
-
-        protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams)
-        {
-            return new ZipVolume(streams.First(), ReaderOptions).AsEnumerable();
-        }
-
-        protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
-        {
-            var volume = volumes.Single();
-            Stream stream = volume.Stream;
-            foreach (ZipHeader h in headerFactory.ReadSeekableHeader(stream))
-            {
-                if (h != null)
-                {
-                    switch (h.ZipHeaderType)
-                    {
-                        case ZipHeaderType.DirectoryEntry:
-                            {
-                                yield return new ZipArchiveEntry(this,
-                                                                 new SeekableZipFilePart(headerFactory,
-                                                                                         (DirectoryEntryHeader)h,
-                                                                                         stream));
-                            }
-                            break;
-                        case ZipHeaderType.DirectoryEnd:
-                            {
-                                byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                                volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                                yield break;
-                            }
-                    }
-                }
-            }
-        }
-
-        public void SaveTo(Stream stream)
-        {
-            SaveTo(stream, new WriterOptions(CompressionType.Deflate));
-        }
-
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<ZipArchiveEntry> oldEntries,
-                                       IEnumerable<ZipArchiveEntry> newEntries)
-        {
-            using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
-            {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
-                    }
-                }
-            }
-        }
-
-        protected override ZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                               bool closeStream)
-        {
-            return new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
-        }
-
-        public static ZipArchive Create()
-        {
-            return new ZipArchive();
-        }
-
-        protected override IReader CreateReaderForSolidExtraction()
-        {
-            var stream = Volumes.Single().Stream;
-            stream.Position = 0;
-            return ZipReader.Open(stream, ReaderOptions);
+            return false;
         }
     }
+
+    protected override IEnumerable<ZipVolume> LoadVolumes(SourceStream stream)
+    {
+        stream.LoadAllParts(); //request all streams
+        stream.Position = 0;
+
+        var streams = stream.Streams.ToList();
+        var idx = 0;
+        if (streams.Count() > 1) //test part 2 - true = multipart not split
+        {
+            streams[1].Position += 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
+            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
+            streams[1].Position -= 4;
+            if (isZip)
+            {
+                stream.IsVolumes = true;
+
+                var tmp = streams[0]; //arcs as zip, z01 ... swap the zip the end
+                streams.RemoveAt(0);
+                streams.Add(tmp);
+
+                //streams[0].Position = 4; //skip the POST_DATA_DESCRIPTOR to prevent an exception
+                return streams.Select(a => new ZipVolume(a, ReaderOptions, idx++));
+            }
+        }
+
+        //split mode or single file
+        return new ZipVolume(stream, ReaderOptions, idx++).AsEnumerable();
+    }
+
+    internal ZipArchive()
+        : base(ArchiveType.Zip) { }
+
+    protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
+    {
+        var vols = volumes.ToArray();
+        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
+        {
+            if (h != null)
+            {
+                switch (h.ZipHeaderType)
+                {
+                    case ZipHeaderType.DirectoryEntry:
+                        {
+                            var deh = (DirectoryEntryHeader)h;
+                            Stream s;
+                            if (
+                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
+                                > vols[deh.DiskNumberStart].Stream.Length
+                            )
+                            {
+                                var v = vols.Skip(deh.DiskNumberStart).ToArray();
+                                s = new SourceStream(
+                                    v[0].Stream,
+                                    i => i < v.Length ? v[i].Stream : null,
+                                    new ReaderOptions() { LeaveStreamOpen = true }
+                                );
+                            }
+                            else
+                            {
+                                s = vols[deh.DiskNumberStart].Stream;
+                            }
+
+                            yield return new ZipArchiveEntry(
+                                this,
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                            );
+                        }
+                        break;
+                    case ZipHeaderType.DirectoryEnd:
+                    {
+                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
+                        vols.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                        yield break;
+                    }
+                }
+            }
+        }
+    }
+
+    public void SaveTo(Stream stream) => SaveTo(stream, new WriterOptions(CompressionType.Deflate));
+
+    protected override void SaveTo(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<ZipArchiveEntry> oldEntries,
+        IEnumerable<ZipArchiveEntry> newEntries
+    )
+    {
+        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries))
+        {
+            if (entry.IsDirectory)
+            {
+                writer.WriteDirectory(
+                    entry.Key.NotNull("Entry Key is null"),
+                    entry.LastModifiedTime
+                );
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                writer.Write(
+                    entry.Key.NotNull("Entry Key is null"),
+                    entryStream,
+                    entry.LastModifiedTime
+                );
+            }
+        }
+    }
+
+    protected override async Task SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IEnumerable<ZipArchiveEntry> oldEntries,
+        IEnumerable<ZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        foreach (var entry in oldEntries.Concat(newEntries))
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    protected override ZipArchiveEntry CreateEntryInternal(
+        string filePath,
+        Stream source,
+        long size,
+        DateTime? modified,
+        bool closeStream
+    ) => new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
+
+    protected override ZipArchiveEntry CreateDirectoryEntry(
+        string directoryPath,
+        DateTime? modified
+    ) => new ZipWritableArchiveEntry(this, directoryPath, modified);
+
+    public static ZipArchive Create() => new();
+
+    protected override IReader CreateReaderForSolidExtraction()
+    {
+        var stream = Volumes.Single().Stream;
+        ((IStreamStack)stream).StackSeek(0);
+        return ZipReader.Open(stream, ReaderOptions, Entries);
+    }
 }

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -1,30 +1,27 @@
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip;
 
-namespace SharpCompress.Archives.Zip
+namespace SharpCompress.Archives.Zip;
+
+public class ZipArchiveEntry : ZipEntry, IArchiveEntry
 {
-    public class ZipArchiveEntry : ZipEntry, IArchiveEntry
-    {
-        internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
-            : base(part)
-        {
-            Archive = archive;
-        }
+    internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
+        : base(part) => Archive = archive;
 
-        public virtual Stream OpenEntryStream()
-        {
-            return Parts.Single().GetCompressedStream();
-        }
+    public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-        #region IArchiveEntry Members
+    public virtual Task<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => Task.FromResult(OpenEntryStream());
 
-        public IArchive Archive { get; }
+    #region IArchiveEntry Members
 
-        public bool IsComplete => true;
+    public IArchive Archive { get; }
 
-        #endregion
+    public bool IsComplete => true;
 
-        public string? Comment => ((SeekableZipFilePart)Parts.Single()).Comment;
-    }
-}
+    #endregion
+}

src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs

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

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -1,68 +1,94 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
 
-namespace SharpCompress.Archives.Zip
+namespace SharpCompress.Archives.Zip;
+
+internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
 {
-    internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
+    private readonly bool closeStream;
+    private readonly Stream? stream;
+    private readonly bool isDirectory;
+    private bool isDisposed;
+
+    internal ZipWritableArchiveEntry(
+        ZipArchive archive,
+        Stream stream,
+        string path,
+        long size,
+        DateTime? lastModified,
+        bool closeStream
+    )
+        : base(archive, null)
     {
-        private readonly bool closeStream;
-        private readonly Stream stream;
-        private bool isDisposed;
+        this.stream = stream;
+        Key = path;
+        Size = size;
+        LastModifiedTime = lastModified;
+        this.closeStream = closeStream;
+        isDirectory = false;
+    }
 
-        internal ZipWritableArchiveEntry(ZipArchive archive, Stream stream, string path, long size,
-                                         DateTime? lastModified, bool closeStream)
-            : base(archive, null)
+    internal ZipWritableArchiveEntry(
+        ZipArchive archive,
+        string directoryPath,
+        DateTime? lastModified
+    )
+        : base(archive, null)
+    {
+        stream = null;
+        Key = directoryPath;
+        Size = 0;
+        LastModifiedTime = lastModified;
+        closeStream = false;
+        isDirectory = true;
+    }
+
+    public override long Crc => 0;
+
+    public override string Key { get; }
+
+    public override long CompressedSize => 0;
+
+    public override long Size { get; }
+
+    public override DateTime? LastModifiedTime { get; }
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => isDirectory;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
+
+    Stream IWritableArchiveEntry.Stream => stream ?? Stream.Null;
+
+    public override Stream OpenEntryStream()
+    {
+        if (stream is null)
         {
-            this.stream = stream;
-            Key = path;
-            Size = size;
-            LastModifiedTime = lastModified;
-            this.closeStream = closeStream;
+            return Stream.Null;
         }
+        //ensure new stream is at the start, this could be reset
+        stream.Seek(0, SeekOrigin.Begin);
+        return SharpCompressStream.Create(stream, leaveOpen: true);
+    }
 
-        public override long Crc => 0;
-
-        public override string Key { get; }
-
-        public override long CompressedSize => 0;
-
-        public override long Size { get; }
-
-        public override DateTime? LastModifiedTime { get; }
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => false;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
-
-        Stream IWritableArchiveEntry.Stream => stream;
-
-        public override Stream OpenEntryStream()
+    internal override void Close()
+    {
+        if (closeStream && !isDisposed && stream is not null)
         {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream && !isDisposed)
-            {
-                stream.Dispose();
-                isDisposed = true;
-            }
+            stream.Dispose();
+            isDisposed = true;
         }
     }
-}
+}

src/SharpCompress/AssemblyInfo.cs

@@ -1,24 +1,7 @@
-using System;
-using System.Reflection;
+using System;
 using System.Runtime.CompilerServices;
 
-[assembly: AssemblyTitle("SharpCompress")]
-[assembly: AssemblyProduct("SharpCompress")]
-[assembly: InternalsVisibleTo("SharpCompress.Test" + SharpCompress.AssemblyInfo.PublicKeySuffix)]
 [assembly: CLSCompliant(true)]
-
-namespace SharpCompress
-{
-    /// <summary>
-    /// Just a static class to house the public key, to avoid repetition.
-    /// </summary>
-    internal static class AssemblyInfo
-    {
-        internal const string PublicKeySuffix =
-            ",PublicKey=002400000480000094000000060200000024000052534131000400000100010059acfa17d26c44" +
-            "7a4d03f16eaa72c9187c04f16e6569dd168b080e39a6f5c9fd00f28c768cd8e9a089d5a0e1b34c" +
-            "cd971488e7afe030ce5ce8df2053cf12ec89f6d38065c434c09ee6af3ee284c5dc08f44774b679" +
-            "bf39298e57efe30d4b00aecf9e4f6f8448b2cb0146d8956dfcab606cc64a0ac38c60a7d78b0d65" +
-            "d3b98dc0";
-    }
-}
+[assembly: InternalsVisibleTo(
+    "SharpCompress.Test,PublicKey=0024000004800000940000000602000000240000525341310004000001000100158bebf1433f76dffc356733c138babea7a47536c65ed8009b16372c6f4edbb20554db74a62687f56b97c20a6ce8c4b123280279e33c894e7b3aa93ab3c573656fde4db576cfe07dba09619ead26375b25d2c4a8e43f7be257d712b0dd2eb546f67adb09281338618a58ac834fc038dd7e2740a7ab3591826252e4f4516306dc"
+)]

src/SharpCompress/Common/Arc/ArcEntry.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.GZip;
+using SharpCompress.Common.Tar;
+
+namespace SharpCompress.Common.Arc
+{
+    public class ArcEntry : Entry
+    {
+        private readonly ArcFilePart? _filePart;
+
+        internal ArcEntry(ArcFilePart? filePart)
+        {
+            _filePart = filePart;
+        }
+
+        public override long Crc
+        {
+            get
+            {
+                if (_filePart == null)
+                {
+                    return 0;
+                }
+                return _filePart.Header.Crc16;
+            }
+        }
+
+        public override string? Key => _filePart?.Header.Name;
+
+        public override string? LinkTarget => null;
+
+        public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
+
+        public override CompressionType CompressionType =>
+            _filePart?.Header.CompressionMethod ?? CompressionType.Unknown;
+
+        public override long Size => throw new NotImplementedException();
+
+        public override DateTime? LastModifiedTime => null;
+
+        public override DateTime? CreatedTime => null;
+
+        public override DateTime? LastAccessedTime => null;
+
+        public override DateTime? ArchivedTime => null;
+
+        public override bool IsEncrypted => false;
+
+        public override bool IsDirectory => false;
+
+        public override bool IsSplitAfter => false;
+
+        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+    }
+}

src/SharpCompress/Common/Arc/ArcEntryHeader.cs

@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace SharpCompress.Common.Arc
+{
+    public class ArcEntryHeader
+    {
+        public ArchiveEncoding ArchiveEncoding { get; }
+        public CompressionType CompressionMethod { get; private set; }
+        public string? Name { get; private set; }
+        public long CompressedSize { get; private set; }
+        public DateTime DateTime { get; private set; }
+        public int Crc16 { get; private set; }
+        public long OriginalSize { get; private set; }
+        public long DataStartPosition { get; private set; }
+
+        public ArcEntryHeader(ArchiveEncoding archiveEncoding)
+        {
+            this.ArchiveEncoding = archiveEncoding;
+        }
+
+        public ArcEntryHeader? ReadHeader(Stream stream)
+        {
+            byte[] headerBytes = new byte[29];
+            if (stream.Read(headerBytes, 0, headerBytes.Length) != headerBytes.Length)
+            {
+                return null;
+            }
+            DataStartPosition = stream.Position;
+            return LoadFrom(headerBytes);
+        }
+
+        public ArcEntryHeader LoadFrom(byte[] headerBytes)
+        {
+            CompressionMethod = GetCompressionType(headerBytes[1]);
+
+            // Read name
+            int nameEnd = Array.IndexOf(headerBytes, (byte)0, 1); // Find null terminator
+            Name = Encoding.UTF8.GetString(headerBytes, 2, nameEnd > 0 ? nameEnd - 2 : 12);
+
+            int offset = 15;
+            CompressedSize = BitConverter.ToUInt32(headerBytes, offset);
+            offset += 4;
+            uint rawDateTime = BitConverter.ToUInt32(headerBytes, offset);
+            DateTime = ConvertToDateTime(rawDateTime);
+            offset += 4;
+            Crc16 = BitConverter.ToUInt16(headerBytes, offset);
+            offset += 2;
+            OriginalSize = BitConverter.ToUInt32(headerBytes, offset);
+            return this;
+        }
+
+        private CompressionType GetCompressionType(byte value)
+        {
+            return value switch
+            {
+                1 or 2 => CompressionType.None,
+                3 => CompressionType.Packed,
+                4 => CompressionType.Squeezed,
+                5 or 6 or 7 or 8 => CompressionType.Crunched,
+                9 => CompressionType.Squashed,
+                10 => CompressionType.Crushed,
+                11 => CompressionType.Distilled,
+                _ => CompressionType.Unknown,
+            };
+        }
+
+        public static DateTime ConvertToDateTime(long rawDateTime)
+        {
+            // Convert Unix timestamp to DateTime (UTC)
+            return DateTimeOffset.FromUnixTimeSeconds(rawDateTime).UtcDateTime;
+        }
+    }
+}

src/SharpCompress/Common/Arc/ArcFilePart.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.GZip;
+using SharpCompress.Common.Tar;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.Common.Zip.Headers;
+using SharpCompress.Compressors.Lzw;
+using SharpCompress.Compressors.RLE90;
+using SharpCompress.Compressors.Squeezed;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Arc
+{
+    public class ArcFilePart : FilePart
+    {
+        private readonly Stream? _stream;
+
+        internal ArcFilePart(ArcEntryHeader localArcHeader, Stream? seekableStream)
+            : base(localArcHeader.ArchiveEncoding)
+        {
+            _stream = seekableStream;
+            Header = localArcHeader;
+        }
+
+        internal ArcEntryHeader Header { get; set; }
+
+        internal override string? FilePartName => Header.Name;
+
+        internal override Stream GetCompressedStream()
+        {
+            if (_stream != null)
+            {
+                Stream compressedStream;
+                switch (Header.CompressionMethod)
+                {
+                    case CompressionType.None:
+                        compressedStream = new ReadOnlySubStream(
+                            _stream,
+                            Header.DataStartPosition,
+                            Header.CompressedSize
+                        );
+                        break;
+                    case CompressionType.Packed:
+                        compressedStream = new RunLength90Stream(
+                            _stream,
+                            (int)Header.CompressedSize
+                        );
+                        break;
+                    case CompressionType.Squeezed:
+                        compressedStream = new SqueezeStream(_stream, (int)Header.CompressedSize);
+                        break;
+                    case CompressionType.Crunched:
+                        if (Header.OriginalSize > 128 * 1024)
+                        {
+                            throw new NotSupportedException(
+                                "CompressionMethod: "
+                                    + Header.CompressionMethod
+                                    + " with size > 128KB"
+                            );
+                        }
+                        compressedStream = new ArcLzwStream(
+                            _stream,
+                            (int)Header.CompressedSize,
+                            true
+                        );
+                        break;
+                    default:
+                        throw new NotSupportedException(
+                            "CompressionMethod: " + Header.CompressionMethod
+                        );
+                }
+                return compressedStream;
+            }
+            return _stream.NotNull();
+        }
+
+        internal override Stream? GetRawStream() => _stream;
+    }
+}

src/SharpCompress/Common/Arc/ArcVolume.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Common.Arc
+{
+    public class ArcVolume : Volume
+    {
+        public ArcVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+            : base(stream, readerOptions, index) { }
+    }
+}

src/SharpCompress/Common/ArchiveEncoding.cs

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

src/SharpCompress/Common/ArchiveException.cs

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

src/SharpCompress/Common/ArchiveExtractionEventArgs.cs

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

src/SharpCompress/Common/ArchiveType.cs

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

src/SharpCompress/Common/Arj/ArjEntry.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.Arc;
+using SharpCompress.Common.Arj.Headers;
+
+namespace SharpCompress.Common.Arj
+{
+    public class ArjEntry : Entry
+    {
+        private readonly ArjFilePart _filePart;
+
+        internal ArjEntry(ArjFilePart filePart)
+        {
+            _filePart = filePart;
+        }
+
+        public override long Crc => _filePart.Header.OriginalCrc32;
+
+        public override string? Key => _filePart?.Header.Name;
+
+        public override string? LinkTarget => null;
+
+        public override long CompressedSize => _filePart?.Header.CompressedSize ?? 0;
+
+        public override CompressionType CompressionType
+        {
+            get
+            {
+                if (_filePart.Header.CompressionMethod == CompressionMethod.Stored)
+                {
+                    return CompressionType.None;
+                }
+                return CompressionType.ArjLZ77;
+            }
+        }
+
+        public override long Size => _filePart?.Header.OriginalSize ?? 0;
+
+        public override DateTime? LastModifiedTime => _filePart.Header.DateTimeModified.DateTime;
+
+        public override DateTime? CreatedTime => _filePart.Header.DateTimeCreated.DateTime;
+
+        public override DateTime? LastAccessedTime => _filePart.Header.DateTimeAccessed.DateTime;
+
+        public override DateTime? ArchivedTime => null;
+
+        public override bool IsEncrypted => false;
+
+        public override bool IsDirectory => _filePart.Header.FileType == FileType.Directory;
+
+        public override bool IsSplitAfter => false;
+
+        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+    }
+}

src/SharpCompress/Common/Arj/ArjFilePart.cs

@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.Arj.Headers;
+using SharpCompress.Compressors.Arj;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Arj
+{
+    public class ArjFilePart : FilePart
+    {
+        private readonly Stream _stream;
+        internal ArjLocalHeader Header { get; set; }
+
+        internal ArjFilePart(ArjLocalHeader localArjHeader, Stream seekableStream)
+            : base(localArjHeader.ArchiveEncoding)
+        {
+            _stream = seekableStream;
+            Header = localArjHeader;
+        }
+
+        internal override string? FilePartName => Header.Name;
+
+        internal override Stream GetCompressedStream()
+        {
+            if (_stream != null)
+            {
+                Stream compressedStream;
+                switch (Header.CompressionMethod)
+                {
+                    case CompressionMethod.Stored:
+                        compressedStream = new ReadOnlySubStream(
+                            _stream,
+                            Header.DataStartPosition,
+                            Header.CompressedSize
+                        );
+                        break;
+                    case CompressionMethod.CompressedMost:
+                    case CompressionMethod.Compressed:
+                    case CompressionMethod.CompressedFaster:
+                        if (Header.OriginalSize > 128 * 1024)
+                        {
+                            throw new NotSupportedException(
+                                "CompressionMethod: "
+                                    + Header.CompressionMethod
+                                    + " with size > 128KB"
+                            );
+                        }
+                        compressedStream = new LhaStream<Lh7DecoderCfg>(
+                            _stream,
+                            (int)Header.OriginalSize
+                        );
+                        break;
+                    case CompressionMethod.CompressedFastest:
+                        compressedStream = new LHDecoderStream(_stream, (int)Header.OriginalSize);
+                        break;
+                    default:
+                        throw new NotSupportedException(
+                            "CompressionMethod: " + Header.CompressionMethod
+                        );
+                }
+                return compressedStream;
+            }
+            return _stream.NotNull();
+        }
+
+        internal override Stream GetRawStream() => _stream;
+    }
+}

src/SharpCompress/Common/Arj/ArjVolume.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.Common.Rar.Headers;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Common.Arj
+{
+    public class ArjVolume : Volume
+    {
+        public ArjVolume(Stream stream, ReaderOptions readerOptions, int index = 0)
+            : base(stream, readerOptions, index) { }
+
+        public override bool IsFirstVolume
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// ArjArchive is part of a multi-part archive.
+        /// </summary>
+        public override bool IsMultiVolume
+        {
+            get { return false; }
+        }
+
+        internal IEnumerable<ArjFilePart> GetVolumeFileParts()
+        {
+            return new List<ArjFilePart>();
+        }
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjHeader.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using SharpCompress.Common.Zip.Headers;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Arj.Headers
+{
+    public enum ArjHeaderType
+    {
+        MainHeader,
+        LocalHeader,
+    }
+
+    public abstract class ArjHeader
+    {
+        private const int FIRST_HDR_SIZE = 34;
+        private const ushort ARJ_MAGIC = 0xEA60;
+
+        public ArjHeader(ArjHeaderType type)
+        {
+            ArjHeaderType = type;
+        }
+
+        public ArjHeaderType ArjHeaderType { get; }
+        public byte Flags { get; set; }
+        public FileType FileType { get; set; }
+
+        public abstract ArjHeader? Read(Stream reader);
+
+        public byte[] ReadHeader(Stream stream)
+        {
+            // check for magic bytes
+            Span<byte> magic = stackalloc byte[2];
+            if (stream.Read(magic) != 2)
+            {
+                return Array.Empty<byte>();
+            }
+
+            var magicValue = (ushort)(magic[0] | magic[1] << 8);
+            if (magicValue != ARJ_MAGIC)
+            {
+                throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
+            }
+
+            // read header_size
+            byte[] headerBytes = new byte[2];
+            stream.Read(headerBytes, 0, 2);
+            var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
+            if (headerSize < 1)
+            {
+                return Array.Empty<byte>();
+            }
+
+            var body = new byte[headerSize];
+            var read = stream.Read(body, 0, headerSize);
+            if (read < headerSize)
+            {
+                return Array.Empty<byte>();
+            }
+
+            byte[] crc = new byte[4];
+            read = stream.Read(crc, 0, 4);
+            var checksum = Crc32Stream.Compute(body);
+            // Compute the hash value
+            if (checksum != BitConverter.ToUInt32(crc, 0))
+            {
+                throw new InvalidDataException("Header checksum is invalid");
+            }
+            return body;
+        }
+
+        protected List<byte[]> ReadExtendedHeaders(Stream reader)
+        {
+            List<byte[]> extendedHeader = new List<byte[]>();
+            byte[] buffer = new byte[2];
+
+            while (true)
+            {
+                int bytesRead = reader.Read(buffer, 0, 2);
+                if (bytesRead < 2)
+                {
+                    throw new EndOfStreamException(
+                        "Unexpected end of stream while reading extended header size."
+                    );
+                }
+
+                var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
+                if (extHeaderSize == 0)
+                {
+                    return extendedHeader;
+                }
+
+                byte[] header = new byte[extHeaderSize];
+                bytesRead = reader.Read(header, 0, extHeaderSize);
+                if (bytesRead < extHeaderSize)
+                {
+                    throw new EndOfStreamException(
+                        "Unexpected end of stream while reading extended header data."
+                    );
+                }
+
+                byte[] crc = new byte[4];
+                bytesRead = reader.Read(crc, 0, 4);
+                if (bytesRead < 4)
+                {
+                    throw new EndOfStreamException(
+                        "Unexpected end of stream while reading extended header CRC."
+                    );
+                }
+
+                var checksum = Crc32Stream.Compute(header);
+                if (checksum != BitConverter.ToUInt32(crc, 0))
+                {
+                    throw new InvalidDataException("Extended header checksum is invalid");
+                }
+
+                extendedHeader.Add(header);
+            }
+        }
+
+        // Flag helpers
+        public bool IsGabled => (Flags & 0x01) != 0;
+        public bool IsAnsiPage => (Flags & 0x02) != 0;
+        public bool IsVolume => (Flags & 0x04) != 0;
+        public bool IsArjProtected => (Flags & 0x08) != 0;
+        public bool IsPathSym => (Flags & 0x10) != 0;
+        public bool IsBackup => (Flags & 0x20) != 0;
+        public bool IsSecured => (Flags & 0x40) != 0;
+        public bool IsAltName => (Flags & 0x80) != 0;
+
+        public static FileType FileTypeFromByte(byte value)
+        {
+            return Enum.IsDefined(typeof(FileType), value)
+                ? (FileType)value
+                : Headers.FileType.Unknown;
+        }
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Arj.Headers
+{
+    public class ArjLocalHeader : ArjHeader
+    {
+        public ArchiveEncoding ArchiveEncoding { get; }
+        public long DataStartPosition { get; protected set; }
+
+        public byte ArchiverVersionNumber { get; set; }
+        public byte MinVersionToExtract { get; set; }
+        public HostOS HostOS { get; set; }
+        public CompressionMethod CompressionMethod { get; set; }
+        public DosDateTime DateTimeModified { get; set; } = new DosDateTime(0);
+        public long CompressedSize { get; set; }
+        public long OriginalSize { get; set; }
+        public long OriginalCrc32 { get; set; }
+        public int FileSpecPosition { get; set; }
+        public int FileAccessMode { get; set; }
+        public byte FirstChapter { get; set; }
+        public byte LastChapter { get; set; }
+        public long ExtendedFilePosition { get; set; }
+        public DosDateTime DateTimeAccessed { get; set; } = new DosDateTime(0);
+        public DosDateTime DateTimeCreated { get; set; } = new DosDateTime(0);
+        public long OriginalSizeEvenForVolumes { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string Comment { get; set; } = string.Empty;
+
+        private const byte StdHdrSize = 30;
+        private const byte R9HdrSize = 46;
+
+        public ArjLocalHeader(ArchiveEncoding archiveEncoding)
+            : base(ArjHeaderType.LocalHeader)
+        {
+            ArchiveEncoding =
+                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
+        }
+
+        public override ArjHeader? Read(Stream stream)
+        {
+            var body = ReadHeader(stream);
+            if (body.Length > 0)
+            {
+                ReadExtendedHeaders(stream);
+                var header = LoadFrom(body);
+                header.DataStartPosition = stream.Position;
+                return header;
+            }
+            return null;
+        }
+
+        public ArjLocalHeader LoadFrom(byte[] headerBytes)
+        {
+            int offset = 0;
+
+            int ReadInt16()
+            {
+                if (offset + 1 >= headerBytes.Length)
+                {
+                    throw new EndOfStreamException();
+                }
+                var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
+                offset += 2;
+                return v;
+            }
+            long ReadInt32()
+            {
+                if (offset + 3 >= headerBytes.Length)
+                {
+                    throw new EndOfStreamException();
+                }
+                long v =
+                    headerBytes[offset] & 0xFF
+                    | (headerBytes[offset + 1] & 0xFF) << 8
+                    | (headerBytes[offset + 2] & 0xFF) << 16
+                    | (headerBytes[offset + 3] & 0xFF) << 24;
+                offset += 4;
+                return v;
+            }
+
+            byte headerSize = headerBytes[offset++];
+            ArchiverVersionNumber = headerBytes[offset++];
+            MinVersionToExtract = headerBytes[offset++];
+            HostOS hostOS = (HostOS)headerBytes[offset++];
+            Flags = headerBytes[offset++];
+            CompressionMethod = CompressionMethodFromByte(headerBytes[offset++]);
+            FileType = FileTypeFromByte(headerBytes[offset++]);
+
+            offset++; // Skip 1 byte
+
+            var rawTimestamp = ReadInt32();
+            DateTimeModified =
+                rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
+
+            CompressedSize = ReadInt32();
+            OriginalSize = ReadInt32();
+            OriginalCrc32 = ReadInt32();
+            FileSpecPosition = ReadInt16();
+            FileAccessMode = ReadInt16();
+
+            FirstChapter = headerBytes[offset++];
+            LastChapter = headerBytes[offset++];
+
+            ExtendedFilePosition = 0;
+            OriginalSizeEvenForVolumes = 0;
+
+            if (headerSize > StdHdrSize)
+            {
+                ExtendedFilePosition = ReadInt32();
+
+                if (headerSize >= R9HdrSize)
+                {
+                    rawTimestamp = ReadInt32();
+                    DateTimeAccessed =
+                        rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
+                    rawTimestamp = ReadInt32();
+                    DateTimeCreated =
+                        rawTimestamp != 0 ? new DosDateTime(rawTimestamp) : new DosDateTime(0);
+                    OriginalSizeEvenForVolumes = ReadInt32();
+                }
+            }
+
+            Name = Encoding.ASCII.GetString(
+                headerBytes,
+                offset,
+                Array.IndexOf(headerBytes, (byte)0, offset) - offset
+            );
+            offset += Name.Length + 1;
+
+            Comment = Encoding.ASCII.GetString(
+                headerBytes,
+                offset,
+                Array.IndexOf(headerBytes, (byte)0, offset) - offset
+            );
+            offset += Comment.Length + 1;
+
+            return this;
+        }
+
+        public static CompressionMethod CompressionMethodFromByte(byte value)
+        {
+            return value switch
+            {
+                0 => CompressionMethod.Stored,
+                1 => CompressionMethod.CompressedMost,
+                2 => CompressionMethod.Compressed,
+                3 => CompressionMethod.CompressedFaster,
+                4 => CompressionMethod.CompressedFastest,
+                8 => CompressionMethod.NoDataNoCrc,
+                9 => CompressionMethod.NoData,
+                _ => CompressionMethod.Unknown,
+            };
+        }
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjMainHeader.cs

@@ -0,0 +1,138 @@
+using System;
+using System.IO;
+using System.Text;
+using SharpCompress.Compressors.Deflate;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Arj.Headers
+{
+    public class ArjMainHeader : ArjHeader
+    {
+        private const int FIRST_HDR_SIZE = 34;
+        private const ushort ARJ_MAGIC = 0xEA60;
+
+        public ArchiveEncoding ArchiveEncoding { get; }
+
+        public int ArchiverVersionNumber { get; private set; }
+        public int MinVersionToExtract { get; private set; }
+        public HostOS HostOs { get; private set; }
+        public int SecurityVersion { get; private set; }
+        public DosDateTime CreationDateTime { get; private set; } = new DosDateTime(0);
+        public long CompressedSize { get; private set; }
+        public long ArchiveSize { get; private set; }
+        public long SecurityEnvelope { get; private set; }
+        public int FileSpecPosition { get; private set; }
+        public int SecurityEnvelopeLength { get; private set; }
+        public int EncryptionVersion { get; private set; }
+        public int LastChapter { get; private set; }
+
+        public int ArjProtectionFactor { get; private set; }
+        public int Flags2 { get; private set; }
+        public string Name { get; private set; } = string.Empty;
+        public string Comment { get; private set; } = string.Empty;
+
+        public ArjMainHeader(ArchiveEncoding archiveEncoding)
+            : base(ArjHeaderType.MainHeader)
+        {
+            ArchiveEncoding =
+                archiveEncoding ?? throw new ArgumentNullException(nameof(archiveEncoding));
+        }
+
+        public override ArjHeader? Read(Stream stream)
+        {
+            var body = ReadHeader(stream);
+            ReadExtendedHeaders(stream);
+            return LoadFrom(body);
+        }
+
+        public ArjMainHeader LoadFrom(byte[] headerBytes)
+        {
+            var offset = 1;
+
+            byte ReadByte()
+            {
+                if (offset >= headerBytes.Length)
+                {
+                    throw new EndOfStreamException();
+                }
+                return (byte)(headerBytes[offset++] & 0xFF);
+            }
+
+            int ReadInt16()
+            {
+                if (offset + 1 >= headerBytes.Length)
+                {
+                    throw new EndOfStreamException();
+                }
+                var v = headerBytes[offset] & 0xFF | (headerBytes[offset + 1] & 0xFF) << 8;
+                offset += 2;
+                return v;
+            }
+
+            long ReadInt32()
+            {
+                if (offset + 3 >= headerBytes.Length)
+                {
+                    throw new EndOfStreamException();
+                }
+                long v =
+                    headerBytes[offset] & 0xFF
+                    | (headerBytes[offset + 1] & 0xFF) << 8
+                    | (headerBytes[offset + 2] & 0xFF) << 16
+                    | (headerBytes[offset + 3] & 0xFF) << 24;
+                offset += 4;
+                return v;
+            }
+            string ReadNullTerminatedString(byte[] x, int startIndex)
+            {
+                var result = new StringBuilder();
+                int i = startIndex;
+
+                while (i < x.Length && x[i] != 0)
+                {
+                    result.Append((char)x[i]);
+                    i++;
+                }
+
+                // Skip the null terminator
+                i++;
+                if (i < x.Length)
+                {
+                    byte[] remainder = new byte[x.Length - i];
+                    Array.Copy(x, i, remainder, 0, remainder.Length);
+                    x = remainder;
+                }
+
+                return result.ToString();
+            }
+
+            ArchiverVersionNumber = ReadByte();
+            MinVersionToExtract = ReadByte();
+
+            var hostOsByte = ReadByte();
+            HostOs = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
+
+            Flags = ReadByte();
+            SecurityVersion = ReadByte();
+            FileType = FileTypeFromByte(ReadByte());
+
+            offset++; // skip reserved
+
+            CreationDateTime = new DosDateTime((int)ReadInt32());
+            CompressedSize = ReadInt32();
+            ArchiveSize = ReadInt32();
+
+            SecurityEnvelope = ReadInt32();
+            FileSpecPosition = ReadInt16();
+            SecurityEnvelopeLength = ReadInt16();
+
+            EncryptionVersion = ReadByte();
+            LastChapter = ReadByte();
+
+            Name = ReadNullTerminatedString(headerBytes, offset);
+            Comment = ReadNullTerminatedString(headerBytes, offset + 1 + Name.Length);
+
+            return this;
+        }
+    }
+}

src/SharpCompress/Common/Arj/Headers/CompressionMethod.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Arj.Headers
+{
+    public enum CompressionMethod
+    {
+        Stored = 0,
+        CompressedMost = 1,
+        Compressed = 2,
+        CompressedFaster = 3,
+        CompressedFastest = 4,
+        NoDataNoCrc = 8,
+        NoData = 9,
+        Unknown,
+    }
+}

src/SharpCompress/Common/Arj/Headers/DosDateTime.cs

@@ -0,0 +1,37 @@
+using System;
+
+namespace SharpCompress.Common.Arj.Headers
+{
+    public class DosDateTime
+    {
+        public DateTime DateTime { get; }
+
+        public DosDateTime(long dosValue)
+        {
+            // Ensure only the lower 32 bits are used
+            int value = unchecked((int)(dosValue & 0xFFFFFFFF));
+
+            var date = (value >> 16) & 0xFFFF;
+            var time = value & 0xFFFF;
+
+            var day = date & 0x1F;
+            var month = (date >> 5) & 0x0F;
+            var year = ((date >> 9) & 0x7F) + 1980;
+
+            var second = (time & 0x1F) * 2;
+            var minute = (time >> 5) & 0x3F;
+            var hour = (time >> 11) & 0x1F;
+
+            try
+            {
+                DateTime = new DateTime(year, month, day, hour, minute, second);
+            }
+            catch
+            {
+                DateTime = DateTime.MinValue;
+            }
+        }
+
+        public override string ToString() => DateTime.ToString("yyyy-MM-dd HH:mm:ss");
+    }
+}

src/SharpCompress/Common/Arj/Headers/FileType.cs

@@ -0,0 +1,13 @@
+namespace SharpCompress.Common.Arj.Headers
+{
+    public enum FileType : byte
+    {
+        Binary = 0,
+        Text7Bit = 1,
+        CommentHeader = 2,
+        Directory = 3,
+        VolumeLabel = 4,
+        ChapterLabel = 5,
+        Unknown = 255,
+    }
+}

src/SharpCompress/Common/Arj/Headers/HostOS.cs

@@ -0,0 +1,19 @@
+namespace SharpCompress.Common.Arj.Headers
+{
+    public enum HostOS
+    {
+        MsDos = 0,
+        PrimOS = 1,
+        Unix = 2,
+        Amiga = 3,
+        MacOs = 4,
+        OS2 = 5,
+        AppleGS = 6,
+        AtariST = 7,
+        NeXT = 8,
+        VaxVMS = 9,
+        Win95 = 10,
+        Win32 = 11,
+        Unknown = 255,
+    }
+}

src/SharpCompress/Common/CompressedBytesReadEventArgs.cs

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

src/SharpCompress/Common/CompressionType.cs

@@ -1,19 +1,33 @@
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public enum CompressionType
 {
-    public enum CompressionType
-    {
-        None,
-        GZip,
-        BZip2,
-        PPMd,
-        Deflate,
-        Rar,
-        LZMA,
-        BCJ,
-        BCJ2,
-        LZip,
-        Xz,
-        Unknown,
-        Deflate64
-    }
-}
+    None,
+    GZip,
+    BZip2,
+    PPMd,
+    Deflate,
+    Rar,
+    LZMA,
+    BCJ,
+    BCJ2,
+    LZip,
+    Xz,
+    Unknown,
+    Deflate64,
+    Shrink,
+    Lzw,
+    Reduce1,
+    Reduce2,
+    Reduce3,
+    Reduce4,
+    Explode,
+    Squeezed,
+    Packed,
+    Crunched,
+    Squashed,
+    Crushed,
+    Distilled,
+    ZStandard,
+    ArjLZ77,
+}

src/SharpCompress/Common/CryptographicException.cs

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

src/SharpCompress/Common/Entry.cs

@@ -1,89 +1,90 @@
-using System;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public abstract class Entry : IEntry
 {
-    public abstract class Entry : IEntry
-    {
-        /// <summary>
-        /// The File's 32 bit CRC Hash
-        /// </summary>
-        public abstract long Crc { get; }
+    /// <summary>
+    /// The File's 32 bit CRC Hash
+    /// </summary>
+    public abstract long Crc { get; }
 
-        /// <summary>
-        /// The string key of the file internal to the Archive.
-        /// </summary>
-        public abstract string Key { get; }
+    /// <summary>
+    /// The string key of the file internal to the Archive.
+    /// </summary>
+    public abstract string? Key { get; }
 
-        /// <summary>
-        /// The target of a symlink entry internal to the Archive. Will be null if not a symlink.
-        /// </summary>
-        public abstract string? LinkTarget { get; }
+    /// <summary>
+    /// The target of a symlink entry internal to the Archive. Will be null if not a symlink.
+    /// </summary>
+    public abstract string? LinkTarget { get; }
 
-        /// <summary>
-        /// The compressed file size
-        /// </summary>
-        public abstract long CompressedSize { get; }
+    /// <summary>
+    /// The compressed file size
+    /// </summary>
+    public abstract long CompressedSize { get; }
 
-        /// <summary>
-        /// The compression type
-        /// </summary>
-        public abstract CompressionType CompressionType { get; }
+    /// <summary>
+    /// The compression type
+    /// </summary>
+    public abstract CompressionType CompressionType { get; }
 
-        /// <summary>
-        /// The uncompressed file size
-        /// </summary>
-        public abstract long Size { get; }
+    /// <summary>
+    /// The uncompressed file size
+    /// </summary>
+    public abstract long Size { get; }
 
-        /// <summary>
-        /// The entry last modified time in the archive, if recorded
-        /// </summary>
-        public abstract DateTime? LastModifiedTime { get; }
+    /// <summary>
+    /// The entry last modified time in the archive, if recorded
+    /// </summary>
+    public abstract DateTime? LastModifiedTime { get; }
 
-        /// <summary>
-        /// The entry create time in the archive, if recorded
-        /// </summary>
-        public abstract DateTime? CreatedTime { get; }
+    /// <summary>
+    /// The entry create time in the archive, if recorded
+    /// </summary>
+    public abstract DateTime? CreatedTime { get; }
 
-        /// <summary>
-        /// The entry last accessed time in the archive, if recorded
-        /// </summary>
-        public abstract DateTime? LastAccessedTime { get; }
+    /// <summary>
+    /// The entry last accessed time in the archive, if recorded
+    /// </summary>
+    public abstract DateTime? LastAccessedTime { get; }
 
-        /// <summary>
-        /// The entry time when archived, if recorded
-        /// </summary>
-        public abstract DateTime? ArchivedTime { get; }
+    /// <summary>
+    /// The entry time when archived, if recorded
+    /// </summary>
+    public abstract DateTime? ArchivedTime { get; }
 
-        /// <summary>
-        /// Entry is password protected and encrypted and cannot be extracted.
-        /// </summary>
-        public abstract bool IsEncrypted { get; }
+    /// <summary>
+    /// Entry is password protected and encrypted and cannot be extracted.
+    /// </summary>
+    public abstract bool IsEncrypted { get; }
 
-        /// <summary>
-        /// Entry is directory.
-        /// </summary>
-        public abstract bool IsDirectory { get; }
+    /// <summary>
+    /// Entry is directory.
+    /// </summary>
+    public abstract bool IsDirectory { get; }
 
-        /// <summary>
-        /// Entry is split among multiple volumes
-        /// </summary>
-        public abstract bool IsSplitAfter { get; }
+    /// <summary>
+    /// Entry is split among multiple volumes
+    /// </summary>
+    public abstract bool IsSplitAfter { get; }
 
-        /// <inheritdoc/>
-        public override string ToString() => Key;
+    public int VolumeIndexFirst => Parts.FirstOrDefault()?.Index ?? 0;
+    public int VolumeIndexLast => Parts.LastOrDefault()?.Index ?? 0;
 
-        internal abstract IEnumerable<FilePart> Parts { get; }
+    /// <inheritdoc/>
+    public override string ToString() => Key ?? "Entry";
 
-        internal bool IsSolid { get; set; }
+    internal abstract IEnumerable<FilePart> Parts { get; }
 
-        internal virtual void Close()
-        {
-        }
+    public bool IsSolid { get; set; }
 
-        /// <summary>
-        /// Entry file attribute.
-        /// </summary>
-        public virtual int? Attrib => throw new NotImplementedException();
-    }
+    internal virtual void Close() { }
+
+    /// <summary>
+    /// Entry file attribute.
+    /// </summary>
+    public virtual int? Attrib => throw new NotImplementedException();
 }

src/SharpCompress/Common/EntryStream.cs

@@ -1,92 +1,212 @@
-using System;
+using System;
 using System.IO;
+using System.IO.Compression;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common
-{
-    public class EntryStream : Stream
-    {
-        private readonly IReader _reader;
-        private readonly Stream _stream;
-        private bool _completed;
-        private bool _isDisposed;
+namespace SharpCompress.Common;
 
-        internal EntryStream(IReader reader, Stream stream)
+public class EntryStream : Stream, IStreamStack
+{
+#if DEBUG_STREAMS
+    long IStreamStack.InstanceId { get; set; }
+#endif
+    int IStreamStack.DefaultBufferSize { get; set; }
+
+    Stream IStreamStack.BaseStream() => _stream;
+
+    int IStreamStack.BufferSize
+    {
+        get => 0;
+        set { }
+    }
+    int IStreamStack.BufferPosition
+    {
+        get => 0;
+        set { }
+    }
+
+    void IStreamStack.SetPosition(long position) { }
+
+    private readonly IReader _reader;
+    private readonly Stream _stream;
+    private bool _completed;
+    private bool _isDisposed;
+
+    internal EntryStream(IReader reader, Stream stream)
+    {
+        _reader = reader;
+        _stream = stream;
+#if DEBUG_STREAMS
+        this.DebugConstruct(typeof(EntryStream));
+#endif
+    }
+
+    /// <summary>
+    /// When reading a stream from OpenEntryStream, the stream must be completed so use this to finish reading the entire entry.
+    /// </summary>
+    public void SkipEntry()
+    {
+        this.Skip();
+        _completed = true;
+    }
+
+    /// <summary>
+    /// Asynchronously skip the rest of the entry stream.
+    /// </summary>
+    public async Task SkipEntryAsync(CancellationToken cancellationToken = default)
+    {
+        await this.SkipAsync(cancellationToken).ConfigureAwait(false);
+        _completed = true;
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (_isDisposed)
         {
-            _reader = reader;
-            _stream = stream;
+            return;
+        }
+        _isDisposed = true;
+        if (!(_completed || _reader.Cancelled))
+        {
+            SkipEntry();
         }
 
-        /// <summary>
-        /// When reading a stream from OpenEntryStream, the stream must be completed so use this to finish reading the entire entry.
-        /// </summary>
-        public void SkipEntry()
+        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
+        if (_stream is IStreamStack ss)
+        {
+            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
+            {
+                deflateStream.Flush(); //Deflate over reads. Knock it back
+            }
+            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
+            {
+                lzmaStream.Flush(); //Lzma over reads. Knock it back
+            }
+        }
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(EntryStream));
+#endif
+        base.Dispose(disposing);
+        _stream.Dispose();
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask DisposeAsync()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
+        if (!(_completed || _reader.Cancelled))
+        {
+            await SkipEntryAsync().ConfigureAwait(false);
+        }
+
+        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
+        if (_stream is IStreamStack ss)
+        {
+            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
+            {
+                await deflateStream.FlushAsync().ConfigureAwait(false);
+            }
+            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
+            {
+                await lzmaStream.FlushAsync().ConfigureAwait(false);
+            }
+        }
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(EntryStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+        await _stream.DisposeAsync().ConfigureAwait(false);
+    }
+#endif
+
+    public override bool CanRead => true;
+
+    public override bool CanSeek => false;
+
+    public override bool CanWrite => false;
+
+    public override void Flush() { }
+
+    public override Task FlushAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+
+    public override long Length => _stream.Length;
+
+    public override long Position
+    {
+        get => _stream.Position; //throw new NotSupportedException();
+        set => throw new NotSupportedException();
+    }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        var read = _stream.Read(buffer, offset, count);
+        if (read <= 0)
         {
-            this.Skip();
             _completed = true;
         }
-
-        protected override void Dispose(bool disposing)
-        {
-            if (!(_completed || _reader.Cancelled))
-            {
-                SkipEntry();
-            }
-            if (_isDisposed)
-            {
-                return;
-            }
-            _isDisposed = true;
-            base.Dispose(disposing);
-            _stream.Dispose();
-        }
-
-        public override bool CanRead => true;
-
-        public override bool CanSeek => false;
-
-        public override bool CanWrite => false;
-
-        public override void Flush() {
-        }
-
-        public override long Length => _stream.Length;
-
-        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            int read = _stream.Read(buffer, offset, count);
-            if (read <= 0)
-            {
-                _completed = true;
-            }
-            return read;
-        }
-
-        public override int ReadByte()
-        {
-            int value = _stream.ReadByte();
-            if (value == -1)
-            {
-                _completed = true;
-            }
-            return value;
-        }
-
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            throw new NotSupportedException();
-        }
+        return read;
     }
-}
+
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var read = await _stream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+        if (read <= 0)
+        {
+            _completed = true;
+        }
+        return read;
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var read = await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+        if (read <= 0)
+        {
+            _completed = true;
+        }
+        return read;
+    }
+#endif
+
+    public override int ReadByte()
+    {
+        var value = _stream.ReadByte();
+        if (value == -1)
+        {
+            _completed = true;
+        }
+        return value;
+    }
+
+    public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
+
+    public override void SetLength(long value) => throw new NotSupportedException();
+
+    public override void Write(byte[] buffer, int offset, int count) =>
+        throw new NotSupportedException();
+
+    public override Task WriteAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    ) => throw new NotSupportedException();
+}

src/SharpCompress/Common/ExtractionException.cs

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

src/SharpCompress/Common/ExtractionMethods.cs

@@ -1,95 +1,232 @@
-using System;
+using System;
 using System.IO;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+internal static class ExtractionMethods
 {
-    internal static class ExtractionMethods
+    /// <summary>
+    /// Gets the appropriate StringComparison for path checks based on the file system.
+    /// Windows uses case-insensitive file systems, while Unix-like systems use case-sensitive file systems.
+    /// </summary>
+    private static StringComparison PathComparison =>
+        RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? StringComparison.OrdinalIgnoreCase
+            : StringComparison.Ordinal;
+
+    /// <summary>
+    /// Extract to specific directory, retaining filename
+    /// </summary>
+    public static void WriteEntryToDirectory(
+        IEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options,
+        Action<string, ExtractionOptions?> write
+    )
     {
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
-        public static void WriteEntryToDirectory(IEntry entry, 
-                                                 string destinationDirectory,
-                                                 ExtractionOptions? options, 
-                                                 Action<string, ExtractionOptions?> write)
+        string destinationFileName;
+        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
+
+        //check for trailing slash.
+        if (
+            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
+            != Path.DirectorySeparatorChar
+        )
         {
-            string destinationFileName;
-            string file = Path.GetFileName(entry.Key);
-            string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
-
-            options ??= new ExtractionOptions()
-                        {
-                            Overwrite = true
-                        };
-
-            if (options.ExtractFullPath)
-            {
-                string folder = Path.GetDirectoryName(entry.Key);
-                string destdir = Path.GetFullPath(
-                                                  Path.Combine(fullDestinationDirectoryPath, folder)
-                                                 );
-
-                if (!Directory.Exists(destdir))
-                {
-                    if (!destdir.StartsWith(fullDestinationDirectoryPath))
-                    {
-                        throw new ExtractionException("Entry is trying to create a directory outside of the destination directory.");
-                    }
-
-                    Directory.CreateDirectory(destdir);
-                }
-                destinationFileName = Path.Combine(destdir, file);
-            }
-            else
-            {        
-                destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
-
-            }
-
-            if (!entry.IsDirectory)
-            {
-                destinationFileName = Path.GetFullPath(destinationFileName);
-
-                if (!destinationFileName.StartsWith(fullDestinationDirectoryPath))
-                {
-                    throw new ExtractionException("Entry is trying to write a file outside of the destination directory.");
-                }
-                write(destinationFileName, options);
-            }
-            else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
-            {
-                Directory.CreateDirectory(destinationFileName);
-            }
+            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
         }
-        
-        public static void WriteEntryToFile(IEntry entry, string destinationFileName,
-                                            ExtractionOptions? options,
-                                            Action<string, FileMode> openAndWrite)
+
+        if (!Directory.Exists(fullDestinationDirectoryPath))
         {
-            if (entry.LinkTarget != null)
-            {
-                if (options?.WriteSymbolicLink is null)
-                {
-                    throw new ExtractionException("Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null");
-                }
-                options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
-            }
-            else
-            {
-                FileMode fm = FileMode.Create;
-                options ??= new ExtractionOptions()
-                                {
-                                    Overwrite = true
-                                };
+            throw new ExtractionException(
+                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
+            );
+        }
 
-                if (!options.Overwrite)
+        options ??= new ExtractionOptions() { Overwrite = true };
+
+        var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
+        file = Utility.ReplaceInvalidFileNameChars(file);
+        if (options.ExtractFullPath)
+        {
+            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
+                .NotNull("Directory is null");
+            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+
+            if (!Directory.Exists(destdir))
+            {
+                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
                 {
-                    fm = FileMode.CreateNew;
+                    throw new ExtractionException(
+                        "Entry is trying to create a directory outside of the destination directory."
+                    );
                 }
 
-                openAndWrite(destinationFileName, fm);
-                entry.PreserveExtractionOptions(destinationFileName, options);
+                Directory.CreateDirectory(destdir);
             }
+            destinationFileName = Path.Combine(destdir, file);
+        }
+        else
+        {
+            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
+        }
+
+        if (!entry.IsDirectory)
+        {
+            destinationFileName = Path.GetFullPath(destinationFileName);
+
+            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
+            {
+                throw new ExtractionException(
+                    "Entry is trying to write a file outside of the destination directory."
+                );
+            }
+            write(destinationFileName, options);
+        }
+        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
+        {
+            Directory.CreateDirectory(destinationFileName);
         }
     }
-}
+
+    public static void WriteEntryToFile(
+        IEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options,
+        Action<string, FileMode> openAndWrite
+    )
+    {
+        if (entry.LinkTarget != null)
+        {
+            if (options?.WriteSymbolicLink is null)
+            {
+                throw new ExtractionException(
+                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
+                );
+            }
+            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
+        }
+        else
+        {
+            var fm = FileMode.Create;
+            options ??= new ExtractionOptions() { Overwrite = true };
+
+            if (!options.Overwrite)
+            {
+                fm = FileMode.CreateNew;
+            }
+
+            openAndWrite(destinationFileName, fm);
+            entry.PreserveExtractionOptions(destinationFileName, options);
+        }
+    }
+
+    public static async Task WriteEntryToDirectoryAsync(
+        IEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options,
+        Func<string, ExtractionOptions?, Task> writeAsync,
+        CancellationToken cancellationToken = default
+    )
+    {
+        string destinationFileName;
+        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
+
+        //check for trailing slash.
+        if (
+            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
+            != Path.DirectorySeparatorChar
+        )
+        {
+            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
+        }
+
+        if (!Directory.Exists(fullDestinationDirectoryPath))
+        {
+            throw new ExtractionException(
+                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
+            );
+        }
+
+        options ??= new ExtractionOptions() { Overwrite = true };
+
+        var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
+        file = Utility.ReplaceInvalidFileNameChars(file);
+        if (options.ExtractFullPath)
+        {
+            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
+                .NotNull("Directory is null");
+            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+
+            if (!Directory.Exists(destdir))
+            {
+                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
+                {
+                    throw new ExtractionException(
+                        "Entry is trying to create a directory outside of the destination directory."
+                    );
+                }
+
+                Directory.CreateDirectory(destdir);
+            }
+            destinationFileName = Path.Combine(destdir, file);
+        }
+        else
+        {
+            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
+        }
+
+        if (!entry.IsDirectory)
+        {
+            destinationFileName = Path.GetFullPath(destinationFileName);
+
+            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
+            {
+                throw new ExtractionException(
+                    "Entry is trying to write a file outside of the destination directory."
+                );
+            }
+            await writeAsync(destinationFileName, options).ConfigureAwait(false);
+        }
+        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
+        {
+            Directory.CreateDirectory(destinationFileName);
+        }
+    }
+
+    public static async Task WriteEntryToFileAsync(
+        IEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options,
+        Func<string, FileMode, Task> openAndWriteAsync,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (entry.LinkTarget != null)
+        {
+            if (options?.WriteSymbolicLink is null)
+            {
+                throw new ExtractionException(
+                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
+                );
+            }
+            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
+        }
+        else
+        {
+            var fm = FileMode.Create;
+            options ??= new ExtractionOptions() { Overwrite = true };
+
+            if (!options.Overwrite)
+            {
+                fm = FileMode.CreateNew;
+            }
+
+            await openAndWriteAsync(destinationFileName, fm).ConfigureAwait(false);
+            entry.PreserveExtractionOptions(destinationFileName, options);
+        }
+    }
+}

src/SharpCompress/Common/ExtractionOptions.cs

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

src/SharpCompress/Common/FilePart.cs

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

src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs

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

src/SharpCompress/Common/FlagUtility.cs

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

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -2,48 +2,44 @@
 using System.Collections.Generic;
 using System.IO;
 
-namespace SharpCompress.Common.GZip
+namespace SharpCompress.Common.GZip;
+
+public class GZipEntry : Entry
 {
-    public class GZipEntry : Entry
+    private readonly GZipFilePart? _filePart;
+
+    internal GZipEntry(GZipFilePart? filePart) => _filePart = filePart;
+
+    public override CompressionType CompressionType => CompressionType.GZip;
+
+    public override long Crc => _filePart?.Crc ?? 0;
+
+    public override string? Key => _filePart?.FilePartName;
+
+    public override string? LinkTarget => null;
+
+    public override long CompressedSize => 0;
+
+    public override long Size => _filePart?.UncompressedSize ?? 0;
+
+    public override DateTime? LastModifiedTime => _filePart?.DateModified;
+
+    public override DateTime? CreatedTime => null;
+
+    public override DateTime? LastAccessedTime => null;
+
+    public override DateTime? ArchivedTime => null;
+
+    public override bool IsEncrypted => false;
+
+    public override bool IsDirectory => false;
+
+    public override bool IsSplitAfter => false;
+
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
+
+    internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
     {
-        private readonly GZipFilePart _filePart;
-
-        internal GZipEntry(GZipFilePart filePart)
-        {
-            _filePart = filePart;
-        }
-
-        public override CompressionType CompressionType => CompressionType.GZip;
-
-        public override long Crc => 0;
-
-        public override string Key => _filePart.FilePartName;
-
-        public override string? LinkTarget => null;
-
-        public override long CompressedSize => 0;
-
-        public override long Size => 0;
-
-        public override DateTime? LastModifiedTime => _filePart.DateModified;
-
-        public override DateTime? CreatedTime => null;
-
-        public override DateTime? LastAccessedTime => null;
-
-        public override DateTime? ArchivedTime => null;
-
-        public override bool IsEncrypted => false;
-
-        public override bool IsDirectory => false;
-
-        public override bool IsSplitAfter => false;
-
-        internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();
-
-        internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
-        {
-            yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
-        }
+        yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
     }
-}
+}

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
@@ -6,114 +6,132 @@ using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 
-namespace SharpCompress.Common.GZip
+namespace SharpCompress.Common.GZip;
+
+internal sealed class GZipFilePart : FilePart
 {
-    internal class GZipFilePart : FilePart
+    private string? _name;
+    private readonly Stream _stream;
+
+    internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
+        : base(archiveEncoding)
     {
-        private string? _name;
-        private readonly Stream _stream;
-
-        internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
-            : base(archiveEncoding)
+        _stream = stream;
+        ReadAndValidateGzipHeader();
+        if (stream.CanSeek)
         {
-            ReadAndValidateGzipHeader(stream);
-            EntryStartPosition = stream.Position;
-            _stream = stream;
+            var position = stream.Position;
+            stream.Position = stream.Length - 8;
+            ReadTrailer();
+            stream.Position = position;
+            EntryStartPosition = position;
         }
-
-        internal long EntryStartPosition { get; }
-
-        internal DateTime? DateModified { get; private set; }
-
-        internal override string FilePartName => _name!;
-
-        internal override Stream GetCompressedStream()
+        else
         {
-            return new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
-        }
-
-        internal override Stream GetRawStream()
-        {
-            return _stream;
-        }
-
-        private void ReadAndValidateGzipHeader(Stream stream)
-        {
-            // read the header on the first read
-            byte[] header = new byte[10];
-            int n = stream.Read(header, 0, header.Length);
-
-            // workitem 8501: handle edge case (decompress empty stream)
-            if (n == 0)
-            {
-                return;
-            }
-
-            if (n != 10)
-            {
-                throw new ZlibException("Not a valid GZIP stream.");
-            }
-
-            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-            {
-                throw new ZlibException("Bad GZIP header.");
-            }
-
-            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
-            DateModified = TarHeader.EPOCH.AddSeconds(timet);
-            if ((header[3] & 0x04) == 0x04)
-            {
-                // read and discard extra field
-                n = stream.Read(header, 0, 2); // 2-byte length field
-
-                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
-                byte[] extra = new byte[extraLength];
-
-                if (!stream.ReadFully(extra))
-                {
-                    throw new ZlibException("Unexpected end-of-file reading GZIP header.");
-                }
-                n = extraLength;
-            }
-            if ((header[3] & 0x08) == 0x08)
-            {
-                _name = ReadZeroTerminatedString(stream);
-            }
-            if ((header[3] & 0x10) == 0x010)
-            {
-                ReadZeroTerminatedString(stream);
-            }
-            if ((header[3] & 0x02) == 0x02)
-            {
-                stream.ReadByte(); // CRC16, ignore
-            }
-        }
-
-        private string ReadZeroTerminatedString(Stream stream)
-        {
-            byte[] buf1 = new byte[1];
-            var list = new List<byte>();
-            bool done = false;
-            do
-            {
-                // workitem 7740
-                int n = stream.Read(buf1, 0, 1);
-                if (n != 1)
-                {
-                    throw new ZlibException("Unexpected EOF reading GZIP header.");
-                }
-                if (buf1[0] == 0)
-                {
-                    done = true;
-                }
-                else
-                {
-                    list.Add(buf1[0]);
-                }
-            }
-            while (!done);
-            byte[] buffer = list.ToArray();
-            return ArchiveEncoding.Decode(buffer);
+            // For non-seekable streams, we can't read the trailer or track position.
+            // Set to 0 since the stream will be read sequentially from its current position.
+            EntryStartPosition = 0;
         }
     }
+
+    internal long EntryStartPosition { get; }
+
+    internal DateTime? DateModified { get; private set; }
+    internal uint? Crc { get; private set; }
+    internal uint? UncompressedSize { get; private set; }
+
+    internal override string? FilePartName => _name;
+
+    internal override Stream GetCompressedStream() =>
+        new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
+
+    internal override Stream GetRawStream() => _stream;
+
+    private void ReadTrailer()
+    {
+        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
+        Span<byte> trailer = stackalloc byte[8];
+        var n = _stream.Read(trailer);
+
+        Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
+        UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.Slice(4));
+    }
+
+    private void ReadAndValidateGzipHeader()
+    {
+        // read the header on the first read
+        Span<byte> header = stackalloc byte[10];
+        var n = _stream.Read(header);
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (n == 0)
+        {
+            return;
+        }
+
+        if (n != 10)
+        {
+            throw new ZlibException("Not a valid GZIP stream.");
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            throw new ZlibException("Bad GZIP header.");
+        }
+
+        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.Slice(4));
+        DateModified = TarHeader.EPOCH.AddSeconds(timet);
+        if ((header[3] & 0x04) == 0x04)
+        {
+            // read and discard extra field
+            n = _stream.Read(header.Slice(0, 2)); // 2-byte length field
+
+            var extraLength = (short)(header[0] + (header[1] * 256));
+            var extra = new byte[extraLength];
+
+            if (!_stream.ReadFully(extra))
+            {
+                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+            }
+            n = extraLength;
+        }
+        if ((header[3] & 0x08) == 0x08)
+        {
+            _name = ReadZeroTerminatedString(_stream);
+        }
+        if ((header[3] & 0x10) == 0x010)
+        {
+            ReadZeroTerminatedString(_stream);
+        }
+        if ((header[3] & 0x02) == 0x02)
+        {
+            _stream.ReadByte(); // CRC16, ignore
+        }
+    }
+
+    private string ReadZeroTerminatedString(Stream stream)
+    {
+        Span<byte> buf1 = stackalloc byte[1];
+        var list = new List<byte>();
+        var done = false;
+        do
+        {
+            // workitem 7740
+            var n = stream.Read(buf1);
+            if (n != 1)
+            {
+                throw new ZlibException("Unexpected EOF reading GZIP header.");
+            }
+            if (buf1[0] == 0)
+            {
+                done = true;
+            }
+            else
+            {
+                list.Add(buf1[0]);
+            }
+        } while (!done);
+        var buffer = list.ToArray();
+        return ArchiveEncoding.Decode(buffer);
+    }
 }

src/SharpCompress/Common/GZip/GZipVolume.cs

@@ -1,23 +1,17 @@
-using System.IO;
+using System.IO;
 using SharpCompress.Readers;
 
-namespace SharpCompress.Common.GZip
+namespace SharpCompress.Common.GZip;
+
+public class GZipVolume : Volume
 {
-    public class GZipVolume : Volume
-    {
-        public GZipVolume(Stream stream, ReaderOptions options)
-            : base(stream, options)
-        {
-        }
+    public GZipVolume(Stream stream, ReaderOptions? options, int index)
+        : base(stream, options, index) { }
 
-        public GZipVolume(FileInfo fileInfo, ReaderOptions options)
-            : base(fileInfo.OpenRead(), options)
-        {
-            options.LeaveStreamOpen = false;
-        }
+    public GZipVolume(FileInfo fileInfo, ReaderOptions options)
+        : base(fileInfo.OpenRead(), options) => options.LeaveStreamOpen = false;
 
-        public override bool IsFirstVolume => true;
+    public override bool IsFirstVolume => true;
 
-        public override bool IsMultiVolume => true;
-    }
-}
+    public override bool IsMultiVolume => true;
+}

src/SharpCompress/Common/IEntry.Extensions.cs

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

src/SharpCompress/Common/IEntry.cs

@@ -1,22 +1,24 @@
-using System;
+using System;
 
-namespace SharpCompress.Common
+namespace SharpCompress.Common;
+
+public interface IEntry
 {
-    public interface IEntry
-    {
-        CompressionType CompressionType { get; }
-        DateTime? ArchivedTime { get; }
-        long CompressedSize { get; }
-        long Crc { get; }
-        DateTime? CreatedTime { get; }
-        string Key { get; }
-        string? LinkTarget { get; }
-        bool IsDirectory { get; }
-        bool IsEncrypted { get; }
-        bool IsSplitAfter { get; }
-        DateTime? LastAccessedTime { get; }
-        DateTime? LastModifiedTime { get; }
-        long Size { get; }
-        int? Attrib { get; }
-    }
-}
+    CompressionType CompressionType { get; }
+    DateTime? ArchivedTime { get; }
+    long CompressedSize { get; }
+    long Crc { get; }
+    DateTime? CreatedTime { get; }
+    string? Key { get; }
+    string? LinkTarget { get; }
+    bool IsDirectory { get; }
+    bool IsEncrypted { get; }
+    bool IsSplitAfter { get; }
+    bool IsSolid { get; }
+    int VolumeIndexFirst { get; }
+    int VolumeIndexLast { get; }
+    DateTime? LastAccessedTime { get; }
+    DateTime? LastModifiedTime { get; }
+    long Size { get; }
+    int? Attrib { get; }
+}

src/SharpCompress/Common/IExtractionListener.cs

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

src/SharpCompress/Common/IVolume.cs

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

src/SharpCompress/Common/IncompleteArchiveException.cs

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

src/SharpCompress/Common/InvalidFormatException.cs

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

src/SharpCompress/Common/MultiVolumeExtractionException.cs

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

src/SharpCompress/Common/MultipartStreamRequiredException.cs

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