Fix CI again

[PR] The proj files have been updated to enable SourceLink

.circleci/config.yml

@@ -1,15 +0,0 @@
-version: 2
-jobs:
-  build:
-    docker:
-      - image: microsoft/dotnet:2.1.301-sdk
-    steps:
-      - checkout
-      - run:
-          name: Install unzip
-          command: |
-            apt-get update
-            apt-get install -y unzip
-      - run:
-          name: Build
-          command: ./build.sh

.github/workflows/dotnetcore.yml

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

.gitignore

@@ -17,3 +17,4 @@ tools
 .idea/
 
 .DS_Store
+*.snupkg

README.md

@@ -1,14 +1,11 @@
 # SharpCompress
 
-SharpCompress is a compression library in pure C# for .NET 3.5, 4.5, .NET Standard 1.0, 1.3 that can unrar, un7zip, unzip, untar unbzip2 and ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip are implemented.
+SharpCompress is a compression library in pure C# for .NET Standard 2.0, 2.1 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.
 
 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream).
 
-AppVeyor Build -
-[![Build status](https://ci.appveyor.com/api/projects/status/voxg971oemmvxh1e/branch/master?svg=true)](https://ci.appveyor.com/project/adamhathcock/sharpcompress/branch/master)
-
-Circle CI Build -
-[![CircleCI](https://circleci.com/gh/adamhathcock/sharpcompress.svg?style=svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
+GitHub Actions Build -
+[![GitHubActions](https://github.com/adamhathcock/sharpcompress/workflows/SharpCompress/badge.svg)](https://circleci.com/gh/adamhathcock/sharpcompress)
 
 ## Need Help?
 

SharpCompress.sln

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

SharpCompress.sln.DotSettings

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

appveyor.yml

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

build.cake

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

build.ps1

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

build.sh

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

build/Program.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+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)
+    {
+        Target(Clean,
+            ForEach("**/bin", "**/obj"),
+            dir =>
+            {
+                IEnumerable<string> GetDirectories(string d)
+                {
+                    return Glob.Directories(".", d);
+                }
+
+                void RemoveDirectory(string d)
+                {
+                    if (Directory.Exists(d))
+                    {
+                        Console.WriteLine(d);
+                        Directory.Delete(d, true);
+                    }
+                }
+
+                foreach (var d in GetDirectories(dir))
+                {
+                    RemoveDirectory(d);
+                }
+            });
+
+        Target(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);
+    }
+}

build/build.csproj

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

global.json

@@ -0,0 +1,5 @@
+{
+  "sdk": {
+    "version": "3.1.302"
+  }
+}

src/SharpCompress/Archives/AbstractArchive.cs

@@ -14,17 +14,16 @@ namespace SharpCompress.Archives
         private readonly LazyReadOnlyCollection<TVolume> lazyVolumes;
         private readonly LazyReadOnlyCollection<TEntry> lazyEntries;
 
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionBegin;
-        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>> EntryExtractionEnd;
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionBegin;
+        public event EventHandler<ArchiveExtractionEventArgs<IArchiveEntry>>? EntryExtractionEnd;
 
-        public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
-        public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;
+        public event EventHandler<CompressedBytesReadEventArgs>? CompressedBytesRead;
+        public event EventHandler<FilePartExtractionBeginEventArgs>? FilePartExtractionBegin;
 
         protected ReaderOptions ReaderOptions { get; }
 
         private bool disposed;
 
-#if !NO_FILE
         internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
         {
             Type = type;
@@ -40,7 +39,6 @@ namespace SharpCompress.Archives
 
 
         protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
-#endif
 
         internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
         {
@@ -50,12 +48,14 @@ namespace SharpCompress.Archives
             lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
         }
 
+#nullable disable
         internal AbstractArchive(ArchiveType type)
         {
             Type = type;
             lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
             lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
         }
+#nullable enable
 
         public ArchiveType Type { get; }
 
@@ -123,31 +123,29 @@ namespace SharpCompress.Archives
 
         void IExtractionListener.FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes)
         {
-            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs
-            {
-                CurrentFilePartCompressedBytesRead = currentPartCompressedBytes,
-                CompressedBytesRead = compressedReadBytes
-            });
+            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs(
+                currentFilePartCompressedBytesRead: currentPartCompressedBytes,
+                compressedBytesRead: compressedReadBytes
+            ));
         }
 
         void IExtractionListener.FireFilePartExtractionBegin(string name, long size, long compressedSize)
         {
-            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs
-            {
-                CompressedSize = compressedSize,
-                Size = size,
-                Name = name
-            });
+            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs(
+                compressedSize : compressedSize,
+                size           : size,
+                name           : name
+            ));
         }
 
         /// <summary>
         /// Use this method to extract all entries in an archive in order.
-        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
+        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
         /// extracted sequentially for the best performance.
-        /// 
+        ///
         /// This method will load all entry information from the archive.
-        /// 
-        /// WARNING: this will reuse the underlying stream for the archive.  Errors may 
+        ///
+        /// WARNING: this will reuse the underlying stream for the archive.  Errors may
         /// occur if this is used at the same time as other extraction methods on this instance.
         /// </summary>
         /// <returns></returns>
@@ -176,4 +174,4 @@ namespace SharpCompress.Archives
             }
         }
     }
-}
+}

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -28,12 +28,10 @@ namespace SharpCompress.Archives
         {
         }
 
-#if !NO_FILE
         internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
             : base(type, fileInfo, readerFactoryOptions)
         {
         }
-#endif
 
         public override ICollection<TEntry> Entries
         {
@@ -144,4 +142,4 @@ namespace SharpCompress.Archives
             modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
         }
     }
-}
+}

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -6,7 +6,6 @@ using SharpCompress.Archives.SevenZip;
 using SharpCompress.Archives.Tar;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
-using SharpCompress.Compressors.LZMA;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Archives
@@ -19,9 +18,9 @@ namespace SharpCompress.Archives
         /// <param name="stream"></param>
         /// <param name="readerOptions"></param>
         /// <returns></returns>
-        public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
+        public static IArchive Open(Stream stream, ReaderOptions? readerOptions = null)
         {
-            stream.CheckNotNull("stream");
+            stream.CheckNotNull(nameof(stream));
             if (!stream.CanRead || !stream.CanSeek)
             {
                 throw new ArgumentException("Stream should be readable and seekable");
@@ -82,17 +81,15 @@ namespace SharpCompress.Archives
             }
         }
 
-#if !NO_FILE
-
         /// <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)
+        public static IArchive Open(string filePath, ReaderOptions? options = null)
         {
-            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options ?? new ReaderOptions());
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
+            return Open(new FileInfo(filePath), options);
         }
 
         /// <summary>
@@ -100,39 +97,34 @@ namespace SharpCompress.Archives
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="options"></param>
-        public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null)
+        public static IArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
         {
-            fileInfo.CheckNotNull("fileInfo");
-            options = options ?? new ReaderOptions();
+            fileInfo.CheckNotNull(nameof(fileInfo));
+            options = options ?? new ReaderOptions { LeaveStreamOpen = false };
             using (var stream = fileInfo.OpenRead())
             {
                 if (ZipArchive.IsZipFile(stream, null))
                 {
-                    stream.Dispose();
                     return ZipArchive.Open(fileInfo, options);
                 }
                 stream.Seek(0, SeekOrigin.Begin);
                 if (SevenZipArchive.IsSevenZipFile(stream))
                 {
-                    stream.Dispose();
                     return SevenZipArchive.Open(fileInfo, options);
                 }
                 stream.Seek(0, SeekOrigin.Begin);
                 if (GZipArchive.IsGZipFile(stream))
                 {
-                    stream.Dispose();
                     return GZipArchive.Open(fileInfo, options);
                 }
                 stream.Seek(0, SeekOrigin.Begin);
                 if (RarArchive.IsRarFile(stream, options))
                 {
-                   stream.Dispose();
                    return RarArchive.Open(fileInfo, options);
                 }
                 stream.Seek(0, SeekOrigin.Begin);
                 if (TarArchive.IsTarFile(stream))
                 {
-                    stream.Dispose();
                     return TarArchive.Open(fileInfo, options);
                 }
                 throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
@@ -143,7 +135,7 @@ namespace SharpCompress.Archives
         /// Extract to specific directory, retaining filename
         /// </summary>
         public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
-                                            ExtractionOptions options = null)
+                                            ExtractionOptions? options = null)
         {
             using (IArchive archive = Open(sourceArchive))
             {
@@ -153,6 +145,5 @@ namespace SharpCompress.Archives
                 }
             }
         }
-#endif
     }
-}
+}

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -13,16 +13,14 @@ namespace SharpCompress.Archives.GZip
 {
     public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
-#if !NO_FILE
-
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="readerOptions"></param>
-        public static GZipArchive Open(string filePath, ReaderOptions readerOptions = null)
+        public static GZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
         {
-            filePath.CheckNotNullOrEmpty("filePath");
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
         }
 
@@ -31,21 +29,20 @@ namespace SharpCompress.Archives.GZip
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="readerOptions"></param>
-        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
+        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
         {
-            fileInfo.CheckNotNull("fileInfo");
+            fileInfo.CheckNotNull(nameof(fileInfo));
             return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
-#endif
 
         /// <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)
+        public static GZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
         {
-            stream.CheckNotNull("stream");
+            stream.CheckNotNull(nameof(stream));
             return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
         }
 
@@ -54,8 +51,6 @@ namespace SharpCompress.Archives.GZip
             return new GZipArchive();
         }
 
-#if !NO_FILE
-
         /// <summary>
         /// Constructor with a FileInfo object to an existing file.
         /// </summary>
@@ -100,7 +95,6 @@ namespace SharpCompress.Archives.GZip
                 SaveTo(stream, new WriterOptions(CompressionType.GZip));
             }
         }
-#endif
 
         public static bool IsGZipFile(Stream stream)
         {
@@ -185,4 +179,4 @@ namespace SharpCompress.Archives.GZip
             return GZipReader.Open(stream);
         }
     }
-}
+}

src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs

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

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

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

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

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

src/SharpCompress/Archives/IArchiveExtensions.cs

@@ -1,26 +1,20 @@
-#if !NO_FILE
-using System.Linq;
+using System.Linq;
 using SharpCompress.Common;
 
-#endif
-
 namespace SharpCompress.Archives
 {
     public static class IArchiveExtensions
     {
-#if !NO_FILE
-
-/// <summary>
-/// Extract to specific directory, retaining filename
-/// </summary>
+        /// <summary>
+        /// Extract to specific directory, retaining filename
+        /// </summary>
         public static void WriteToDirectory(this IArchive archive, string destinationDirectory,
-                                            ExtractionOptions options = null)
+                                            ExtractionOptions? options = null)
         {
             foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory))
             {
                 entry.WriteToDirectory(destinationDirectory, options);
             }
         }
-#endif
     }
 }

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,6 +1,4 @@
-#if !NO_FILE
-using System;
-#endif
+using System;
 using System.IO;
 using SharpCompress.Writers;
 
@@ -8,8 +6,6 @@ namespace SharpCompress.Archives
 {
     public static class IWritableArchiveExtensions
     {
-#if !NO_FILE
-
         public static void AddEntry(this IWritableArchive writableArchive,
                                                      string entryPath, string filePath)
         {
@@ -39,11 +35,7 @@ namespace SharpCompress.Archives
             this IWritableArchive writableArchive,
             string filePath, string searchPattern = "*.*", SearchOption searchOption = SearchOption.AllDirectories)
         {
-#if NET35
-            foreach (var path in Directory.GetFiles(filePath, searchPattern, searchOption))
-#else
             foreach (var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption))
-#endif
             {
                 var fileInfo = new FileInfo(path);
                 writableArchive.AddEntry(path.Substring(filePath.Length), fileInfo.OpenRead(), true, fileInfo.Length,
@@ -58,6 +50,5 @@ namespace SharpCompress.Archives
             }
             return writableArchive.AddEntry(key, fileInfo.OpenRead(), true, fileInfo.Length, fileInfo.LastWriteTime);
         }
-#endif
     }
 }

src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs

@@ -1,7 +1,6 @@
-
-#if !NO_FILE
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
@@ -18,7 +17,7 @@ namespace SharpCompress.Archives.Rar
             : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options))
         {
             FileInfo = fileInfo;
-            FileParts = GetVolumeFileParts().ToReadOnly();
+            FileParts = GetVolumeFileParts().ToArray().ToReadOnly();
         }
 
         private static ReaderOptions FixOptions(ReaderOptions options)
@@ -43,4 +42,3 @@ namespace SharpCompress.Archives.Rar
         }
     }
 }
-#endif

src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs

@@ -1,13 +1,11 @@
-
-#if !NO_FILE
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar.Headers;
 
 namespace SharpCompress.Archives.Rar
 {
-    internal class FileInfoRarFilePart : SeekableFilePart
+    internal sealed class FileInfoRarFilePart : SeekableFilePart
     {
-        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string password, MarkHeader mh, FileHeader fh, FileInfo fi)
+        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string? password, MarkHeader mh, FileHeader fh, FileInfo fi)
             : base(mh, fh, volume.Stream, password)
         {
             FileInfo = fi;
@@ -25,4 +23,3 @@ namespace SharpCompress.Archives.Rar
         }
     }
 }
-#endif

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -15,8 +15,6 @@ namespace SharpCompress.Archives.Rar
         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());
 
-#if !NO_FILE
-
         /// <summary>
         /// Constructor with a FileInfo object to an existing file.
         /// </summary>
@@ -31,7 +29,6 @@ namespace SharpCompress.Archives.Rar
         {
             return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
         }
-#endif
 
         /// <summary>
         /// Takes multiple seekable Streams for a multi-part archive
@@ -63,17 +60,14 @@ namespace SharpCompress.Archives.Rar
         public override bool IsSolid => Volumes.First().IsSolidArchive;
 
         #region Creation
-
-#if !NO_FILE
-
         /// <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)
+        public static RarArchive Open(string filePath, ReaderOptions? options = null)
         {
-            filePath.CheckNotNullOrEmpty("filePath");
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
             return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
         }
 
@@ -82,21 +76,20 @@ namespace SharpCompress.Archives.Rar
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="options"></param>
-        public static RarArchive Open(FileInfo fileInfo, ReaderOptions options = null)
+        public static RarArchive Open(FileInfo fileInfo, ReaderOptions? options = null)
         {
-            fileInfo.CheckNotNull("fileInfo");
+            fileInfo.CheckNotNull(nameof(fileInfo));
             return new RarArchive(fileInfo, options ?? new ReaderOptions());
         }
-#endif
 
         /// <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)
+        public static RarArchive Open(Stream stream, ReaderOptions? options = null)
         {
-            stream.CheckNotNull("stream");
+            stream.CheckNotNull(nameof(stream));
             return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
         }
 
@@ -105,13 +98,12 @@ namespace SharpCompress.Archives.Rar
         /// </summary>
         /// <param name="streams"></param>
         /// <param name="options"></param>
-        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions options = null)
+        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions? options = null)
         {
-            streams.CheckNotNull("streams");
+            streams.CheckNotNull(nameof(streams));
             return new RarArchive(streams, options ?? new ReaderOptions());
         }
 
-#if !NO_FILE
         public static bool IsRarFile(string filePath)
         {
             return IsRarFile(new FileInfo(filePath));
@@ -128,9 +120,8 @@ namespace SharpCompress.Archives.Rar
                 return IsRarFile(stream);
             }
         }
-#endif
         
-        public static bool IsRarFile(Stream stream, ReaderOptions options = null)
+        public static bool IsRarFile(Stream stream, ReaderOptions? options = null)
         {
             try
             {
@@ -145,4 +136,4 @@ namespace SharpCompress.Archives.Rar
 
         #endregion
     }
-}
+}

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -57,11 +57,6 @@ namespace SharpCompress.Archives.Rar
 
         public Stream OpenEntryStream()
         {
-            if (archive.IsSolid)
-            {
-                throw new InvalidOperationException("Use ExtractAllEntries to extract SOLID archives.");
-            }
-
             if (IsRarV3)
             {
                 return new RarStream(archive.UnpackV1.Value, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -3,11 +3,9 @@ using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Readers;
-#if !NO_FILE
 using System.Linq;
 using System.Text;
 using SharpCompress.Common.Rar.Headers;
-#endif
 
 namespace SharpCompress.Archives.Rar
 {
@@ -25,8 +23,7 @@ namespace SharpCompress.Archives.Rar
                 yield return part;
             }
         }
-
-#if !NO_FILE
+        
         internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
         {
             FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
@@ -37,20 +34,20 @@ namespace SharpCompress.Archives.Rar
             {
                 yield break; //if file isn't volume then there is no reason to look
             }
-            fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
+            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);
+                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart)!;
                 yield return part;
             }
         }
 
-        private static FileInfo GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart currentFilePart)
+        private static FileInfo? GetNextFileInfo(ArchiveHeader ah, FileInfoRarFilePart? currentFilePart)
         {
-            if (currentFilePart == null)
+            if (currentFilePart is null)
             {
                 return null;
             }
@@ -141,7 +138,5 @@ namespace SharpCompress.Archives.Rar
             throw new ArgumentException("Filename invalid or next archive could not be found:"
                                         + fileInfo.FullName);
         }
-
-#endif
     }
 }

src/SharpCompress/Archives/Rar/SeekableFilePart.cs

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

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -1,4 +1,6 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -13,8 +15,6 @@ namespace SharpCompress.Archives.SevenZip
     public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
     {
         private ArchiveDatabase database;
-#if !NO_FILE
-
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
@@ -36,7 +36,6 @@ namespace SharpCompress.Archives.SevenZip
             fileInfo.CheckNotNull("fileInfo");
             return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
-#endif
         /// <summary>
         /// Takes a seekable Stream as a source
         /// </summary>
@@ -48,7 +47,6 @@ namespace SharpCompress.Archives.SevenZip
             return new SevenZipArchive(stream, readerOptions ?? new ReaderOptions());
         }
 
-#if !NO_FILE
         internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
             : base(ArchiveType.SevenZip, fileInfo, readerOptions)
         {
@@ -75,7 +73,6 @@ namespace SharpCompress.Archives.SevenZip
                 return IsSevenZipFile(stream);
             }
         }
-#endif
 
         internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
             : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
@@ -113,7 +110,7 @@ namespace SharpCompress.Archives.SevenZip
 
         private void LoadFactory(Stream stream)
         {
-            if (database == null)
+            if (database is null)
             {
                 stream.Position = 0;
                 var reader = new ArchiveReader();
@@ -134,13 +131,13 @@ namespace SharpCompress.Archives.SevenZip
             }
         }
 
-        private static readonly byte[] SIGNATURE = {(byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C};
+        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);
-            byte[] signatureBytes = reader.ReadBytes(6);
-            return signatureBytes.BinaryEquals(SIGNATURE);
+            ReadOnlySpan<byte> signatureBytes = reader.ReadBytes(6);
+            return signatureBytes.SequenceEqual(SIGNATURE);
         }
 
         protected override IReader CreateReaderForSolidExtraction()
@@ -159,7 +156,7 @@ namespace SharpCompress.Archives.SevenZip
             }
         }
 
-        private class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
+        private sealed class SevenZipReader : AbstractReader<SevenZipEntry, SevenZipVolume>
         {
             private readonly SevenZipArchive archive;
             private CFolder currentFolder;
@@ -185,7 +182,7 @@ namespace SharpCompress.Archives.SevenZip
                 foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
                 {
                     currentFolder = group.Key;
-                    if (group.Key == null)
+                    if (group.Key is null)
                     {
                         currentStream = Stream.Null;
                     }
@@ -206,7 +203,7 @@ namespace SharpCompress.Archives.SevenZip
                 return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
             }
         }
-        
+
         private class PasswordProvider : IPasswordProvider
         {
             private readonly string _password;
@@ -214,7 +211,6 @@ namespace SharpCompress.Archives.SevenZip
             public PasswordProvider(string password)
             {
                 _password = password;
-
             }
 
             public string CryptoGetTextPassword()

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -15,16 +15,14 @@ namespace SharpCompress.Archives.Tar
 {
     public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     {
-#if !NO_FILE
-
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="readerOptions"></param>
-        public static TarArchive Open(string filePath, ReaderOptions readerOptions = null)
+        public static TarArchive Open(string filePath, ReaderOptions? readerOptions = null)
         {
-            filePath.CheckNotNullOrEmpty("filePath");
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
         }
 
@@ -33,26 +31,23 @@ namespace SharpCompress.Archives.Tar
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="readerOptions"></param>
-        public static TarArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
+        public static TarArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
         {
-            fileInfo.CheckNotNull("fileInfo");
+            fileInfo.CheckNotNull(nameof(fileInfo));
             return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
-#endif
 
         /// <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)
+        public static TarArchive Open(Stream stream, ReaderOptions? readerOptions = null)
         {
-            stream.CheckNotNull("stream");
+            stream.CheckNotNull(nameof(stream));
             return new TarArchive(stream, readerOptions ?? new ReaderOptions());
         }
 
-#if !NO_FILE
-
         public static bool IsTarFile(string filePath)
         {
             return IsTarFile(new FileInfo(filePath));
@@ -69,24 +64,22 @@ namespace SharpCompress.Archives.Tar
                 return IsTarFile(stream);
             }
         }
-#endif
 
         public static bool IsTarFile(Stream stream)
         {
             try
             {
-                TarHeader tar = new TarHeader(new ArchiveEncoding());
-                tar.Read(new BinaryReader(stream));
-                return tar.Name.Length > 0 && Enum.IsDefined(typeof(EntryType), tar.EntryType);
+                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;
         }
-
-#if !NO_FILE
-
+        
         /// <summary>
         /// Constructor with a FileInfo object to an existing file.
         /// </summary>
@@ -101,7 +94,6 @@ namespace SharpCompress.Archives.Tar
         {
             return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
         }
-#endif
 
         /// <summary>
         /// Takes multiple seekable Streams for a multi-part archive
@@ -126,8 +118,8 @@ namespace SharpCompress.Archives.Tar
         protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
         {
             Stream stream = volumes.Single().Stream;
-            TarHeader previousHeader = null;
-            foreach (TarHeader header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
+            TarHeader? previousHeader = null;
+            foreach (TarHeader? header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
             {
                 if (header != null)
                 {
@@ -202,4 +194,4 @@ namespace SharpCompress.Archives.Tar
             return TarReader.Open(stream);
         }
     }
-}
+}

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

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

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -15,24 +15,24 @@ namespace SharpCompress.Archives.Zip
 {
     public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     {
+#nullable disable
         private readonly SeekableZipHeaderFactory headerFactory;
+#nullable enable
 
         /// <summary>
         /// Gets or sets the compression level applied to files added to the archive,
         /// if the compression method is set to deflate
         /// </summary>
         public CompressionLevel DeflateCompressionLevel { get; set; }
-
-#if !NO_FILE
-
+        
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
         /// <param name="filePath"></param>
         /// <param name="readerOptions"></param>
-        public static ZipArchive Open(string filePath, ReaderOptions readerOptions = null)
+        public static ZipArchive Open(string filePath, ReaderOptions? readerOptions = null)
         {
-            filePath.CheckNotNullOrEmpty("filePath");
+            filePath.CheckNotNullOrEmpty(nameof(filePath));
             return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
         }
 
@@ -41,32 +41,29 @@ namespace SharpCompress.Archives.Zip
         /// </summary>
         /// <param name="fileInfo"></param>
         /// <param name="readerOptions"></param>
-        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
+        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null)
         {
-            fileInfo.CheckNotNull("fileInfo");
+            fileInfo.CheckNotNull(nameof(fileInfo));
             return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
-#endif
 
         /// <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)
+        public static ZipArchive Open(Stream stream, ReaderOptions? readerOptions = null)
         {
-            stream.CheckNotNull("stream");
+            stream.CheckNotNull(nameof(stream));
             return new ZipArchive(stream, readerOptions ?? new ReaderOptions());
         }
-
-#if !NO_FILE
-
-        public static bool IsZipFile(string filePath, string password = null)
+        
+        public static bool IsZipFile(string filePath, string? password = null)
         {
             return IsZipFile(new FileInfo(filePath), password);
         }
 
-        public static bool IsZipFile(FileInfo fileInfo, string password = null)
+        public static bool IsZipFile(FileInfo fileInfo, string? password = null)
         {
             if (!fileInfo.Exists)
             {
@@ -77,16 +74,15 @@ namespace SharpCompress.Archives.Zip
                 return IsZipFile(stream, password);
             }
         }
-#endif
 
-        public static bool IsZipFile(Stream stream, string password = null)
+        public static bool IsZipFile(Stream stream, string? password = null)
         {
             StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
             try
             {
                 ZipHeader header =
                     headerFactory.ReadStreamHeader(stream).FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
-                if (header == null)
+                if (header is null)
                 {
                     return false;
                 }
@@ -101,9 +97,7 @@ namespace SharpCompress.Archives.Zip
                 return false;
             }
         }
-
-#if !NO_FILE
-
+        
         /// <summary>
         /// Constructor with a FileInfo object to an existing file.
         /// </summary>
@@ -119,7 +113,6 @@ namespace SharpCompress.Archives.Zip
         {
             return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
         }
-#endif
 
         internal ZipArchive()
             : base(ArchiveType.Zip)
@@ -156,13 +149,13 @@ namespace SharpCompress.Archives.Zip
                             {
                                 yield return new ZipArchiveEntry(this,
                                                                  new SeekableZipFilePart(headerFactory,
-                                                                                         h as DirectoryEntryHeader,
+                                                                                         (DirectoryEntryHeader)h,
                                                                                          stream));
                             }
                             break;
                         case ZipHeaderType.DirectoryEnd:
                             {
-                                byte[] bytes = (h as DirectoryEndHeader).Comment;
+                                byte[] bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
                                 volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
                                 yield break;
                             }
@@ -211,4 +204,4 @@ namespace SharpCompress.Archives.Zip
             return ZipReader.Open(stream, ReaderOptions);
         }
     }
-}
+}

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

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

src/SharpCompress/AssemblyInfo.cs

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

src/SharpCompress/Buffers/ArrayPool.cs

@@ -1,119 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-#if NETCORE
-using System.Runtime.CompilerServices;
-using System.Threading;
-
-namespace SharpCompress.Buffers
-{
-    /// <summary>
-    /// Provides a resource pool that enables reusing instances of type <see cref="T:T[]"/>. 
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// Renting and returning buffers with an <see cref="ArrayPool{T}"/> can increase performance
-    /// in situations where arrays are created and destroyed frequently, resulting in significant
-    /// memory pressure on the garbage collector.
-    /// </para>
-    /// <para>
-    /// This class is thread-safe.  All members may be used by multiple threads concurrently.
-    /// </para>
-    /// </remarks>
-    internal abstract class ArrayPool<T>
-    {
-        /// <summary>The lazily-initialized shared pool instance.</summary>
-        private static ArrayPool<T> s_sharedInstance = null;
-
-        /// <summary>
-        /// Retrieves a shared <see cref="ArrayPool{T}"/> instance.
-        /// </summary>
-        /// <remarks>
-        /// The shared pool provides a default implementation of <see cref="ArrayPool{T}"/>
-        /// that's intended for general applicability.  It maintains arrays of multiple sizes, and 
-        /// may hand back a larger array than was actually requested, but will never hand back a smaller 
-        /// array than was requested. Renting a buffer from it with <see cref="Rent"/> will result in an 
-        /// existing buffer being taken from the pool if an appropriate buffer is available or in a new 
-        /// buffer being allocated if one is not available.
-        /// </remarks>
-        public static ArrayPool<T> Shared
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get { return Volatile.Read(ref s_sharedInstance) ?? EnsureSharedCreated(); }
-        }
-
-        /// <summary>Ensures that <see cref="s_sharedInstance"/> has been initialized to a pool and returns it.</summary>
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private static ArrayPool<T> EnsureSharedCreated()
-        {
-            Interlocked.CompareExchange(ref s_sharedInstance, Create(), null);
-            return s_sharedInstance;
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="ArrayPool{T}"/> instance using default configuration options.
-        /// </summary>
-        /// <returns>A new <see cref="ArrayPool{T}"/> instance.</returns>
-        public static ArrayPool<T> Create()
-        {
-            return new DefaultArrayPool<T>();
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="ArrayPool{T}"/> instance using custom configuration options.
-        /// </summary>
-        /// <param name="maxArrayLength">The maximum length of array instances that may be stored in the pool.</param>
-        /// <param name="maxArraysPerBucket">
-        /// The maximum number of array instances that may be stored in each bucket in the pool.  The pool
-        /// groups arrays of similar lengths into buckets for faster access.
-        /// </param>
-        /// <returns>A new <see cref="ArrayPool{T}"/> instance with the specified configuration options.</returns>
-        /// <remarks>
-        /// The created pool will group arrays into buckets, with no more than <paramref name="maxArraysPerBucket"/>
-        /// in each bucket and with those arrays not exceeding <paramref name="maxArrayLength"/> in length.
-        /// </remarks>
-        public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket)
-        {
-            return new DefaultArrayPool<T>(maxArrayLength, maxArraysPerBucket);
-        }
-
-        /// <summary>
-        /// Retrieves a buffer that is at least the requested length.
-        /// </summary>
-        /// <param name="minimumLength">The minimum length of the array needed.</param>
-        /// <returns>
-        /// An <see cref="T:T[]"/> that is at least <paramref name="minimumLength"/> in length.
-        /// </returns>
-        /// <remarks>
-        /// This buffer is loaned to the caller and should be returned to the same pool via 
-        /// <see cref="Return"/> so that it may be reused in subsequent usage of <see cref="Rent"/>.  
-        /// It is not a fatal error to not return a rented buffer, but failure to do so may lead to 
-        /// decreased application performance, as the pool may need to create a new buffer to replace
-        /// the one lost.
-        /// </remarks>
-        public abstract T[] Rent(int minimumLength);
-
-        /// <summary>
-        /// Returns to the pool an array that was previously obtained via <see cref="Rent"/> on the same 
-        /// <see cref="ArrayPool{T}"/> instance.
-        /// </summary>
-        /// <param name="array">
-        /// The buffer previously obtained from <see cref="Rent"/> to return to the pool.
-        /// </param>
-        /// <param name="clearArray">
-        /// If <c>true</c> and if the pool will store the buffer to enable subsequent reuse, <see cref="Return"/>
-        /// will clear <paramref name="array"/> of its contents so that a subsequent consumer via <see cref="Rent"/> 
-        /// will not see the previous consumer's content.  If <c>false</c> or if the pool will release the buffer,
-        /// the array's contents are left unchanged.
-        /// </param>
-        /// <remarks>
-        /// Once a buffer has been returned to the pool, the caller gives up all ownership of the buffer 
-        /// and must not use it. The reference returned from a given call to <see cref="Rent"/> must only be
-        /// returned via <see cref="Return"/> once.  The default <see cref="ArrayPool{T}"/>
-        /// may hold onto the returned buffer in order to rent it again, or it may release the returned buffer
-        /// if it's determined that the pool already has enough buffers stored.
-        /// </remarks>
-        public abstract void Return(T[] array, bool clearArray = false);
-    }
-}
-#endif

src/SharpCompress/Buffers/DefaultArrayPool.cs

@@ -1,144 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-#if NETCORE
-using System;
-
-namespace SharpCompress.Buffers
-{
-    internal sealed partial class DefaultArrayPool<T> : ArrayPool<T>
-    {
-        /// <summary>The default maximum length of each array in the pool (2^20).</summary>
-        private const int DefaultMaxArrayLength = 1024 * 1024;
-        /// <summary>The default maximum number of arrays per bucket that are available for rent.</summary>
-        private const int DefaultMaxNumberOfArraysPerBucket = 50;
-        /// <summary>Lazily-allocated empty array used when arrays of length 0 are requested.</summary>
-        private static T[] s_emptyArray; // we support contracts earlier than those with Array.Empty<T>()
-
-        private readonly Bucket[] _buckets;
-
-        internal DefaultArrayPool() : this(DefaultMaxArrayLength, DefaultMaxNumberOfArraysPerBucket)
-        {
-        }
-
-        internal DefaultArrayPool(int maxArrayLength, int maxArraysPerBucket)
-        {
-            if (maxArrayLength <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(maxArrayLength));
-            }
-            if (maxArraysPerBucket <= 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(maxArraysPerBucket));
-            }
-
-            // Our bucketing algorithm has a min length of 2^4 and a max length of 2^30.
-            // Constrain the actual max used to those values.
-            const int MinimumArrayLength = 0x10, MaximumArrayLength = 0x40000000;
-            if (maxArrayLength > MaximumArrayLength)
-            {
-                maxArrayLength = MaximumArrayLength;
-            }
-            else if (maxArrayLength < MinimumArrayLength)
-            {
-                maxArrayLength = MinimumArrayLength;
-            }
-
-            // Create the buckets.
-            int poolId = Id;
-            int maxBuckets = Utilities.SelectBucketIndex(maxArrayLength);
-            var buckets = new Bucket[maxBuckets + 1];
-            for (int i = 0; i < buckets.Length; i++)
-            {
-                buckets[i] = new Bucket(Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, poolId);
-            }
-            _buckets = buckets;
-        }
-
-        /// <summary>Gets an ID for the pool to use with events.</summary>
-        private int Id => GetHashCode();
-
-        public override T[] Rent(int minimumLength)
-        {
-            // Arrays can't be smaller than zero.  We allow requesting zero-length arrays (even though
-            // pooling such an array isn't valuable) as it's a valid length array, and we want the pool
-            // to be usable in general instead of using `new`, even for computed lengths.
-            if (minimumLength < 0)
-            {
-                throw new ArgumentOutOfRangeException(nameof(minimumLength));
-            }
-            else if (minimumLength == 0)
-            {
-                // No need for events with the empty array.  Our pool is effectively infinite
-                // and we'll never allocate for rents and never store for returns.
-                return s_emptyArray ?? (s_emptyArray = new T[0]);
-            }
-
-            T[] buffer = null;
-
-            int index = Utilities.SelectBucketIndex(minimumLength);
-            if (index < _buckets.Length)
-            {
-                // Search for an array starting at the 'index' bucket. If the bucket is empty, bump up to the
-                // next higher bucket and try that one, but only try at most a few buckets.
-                const int MaxBucketsToTry = 2;
-                int i = index;
-                do
-                {
-                    // Attempt to rent from the bucket.  If we get a buffer from it, return it.
-                    buffer = _buckets[i].Rent();
-                    if (buffer != null)
-                    {
-                        return buffer;
-                    }
-                }
-                while (++i < _buckets.Length && i != index + MaxBucketsToTry);
-
-                // The pool was exhausted for this buffer size.  Allocate a new buffer with a size corresponding
-                // to the appropriate bucket.
-                buffer = new T[_buckets[index]._bufferLength];
-            }
-            else
-            {
-                // The request was for a size too large for the pool.  Allocate an array of exactly the requested length.
-                // When it's returned to the pool, we'll simply throw it away.
-                buffer = new T[minimumLength];
-            }
-
-            return buffer;
-        }
-
-        public override void Return(T[] array, bool clearArray = false)
-        {
-            if (array == null)
-            {
-                throw new ArgumentNullException(nameof(array));
-            }
-            else if (array.Length == 0)
-            {
-                // Ignore empty arrays.  When a zero-length array is rented, we return a singleton
-                // rather than actually taking a buffer out of the lowest bucket.
-                return;
-            }
-
-            // Determine with what bucket this array length is associated
-            int bucket = Utilities.SelectBucketIndex(array.Length);
-
-            // If we can tell that the buffer was allocated, drop it. Otherwise, check if we have space in the pool
-            if (bucket < _buckets.Length)
-            {
-                // Clear the array if the user requests
-                if (clearArray)
-                {
-                    Array.Clear(array, 0, array.Length);
-                }
-
-                // Return the buffer to its bucket.  In the future, we might consider having Return return false
-                // instead of dropping a bucket, in which case we could try to return to a lower-sized bucket,
-                // just as how in Rent we allow renting from a higher-sized bucket.
-                _buckets[bucket].Return(array);
-            }
-        }
-    }
-}
-#endif

src/SharpCompress/Buffers/DefaultArrayPoolBucket.cs

@@ -1,111 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-#if NETCORE
-using System;
-using System.Diagnostics;
-using System.Threading;
-
-namespace SharpCompress.Buffers
-{
-    internal sealed partial class DefaultArrayPool<T> : ArrayPool<T>
-    {
-        /// <summary>Provides a thread-safe bucket containing buffers that can be Rent'd and Return'd.</summary>
-        private sealed class Bucket
-        {
-            internal readonly int _bufferLength;
-            private readonly T[][] _buffers;
-            private readonly int _poolId;
-
-            private SpinLock _lock; // do not make this readonly; it's a mutable struct
-            private int _index;
-
-            /// <summary>
-            /// Creates the pool with numberOfBuffers arrays where each buffer is of bufferLength length.
-            /// </summary>
-            internal Bucket(int bufferLength, int numberOfBuffers, int poolId)
-            {
-                _lock = new SpinLock(Debugger.IsAttached); // only enable thread tracking if debugger is attached; it adds non-trivial overheads to Enter/Exit
-                _buffers = new T[numberOfBuffers][];
-                _bufferLength = bufferLength;
-                _poolId = poolId;
-            }
-
-            /// <summary>Gets an ID for the bucket to use with events.</summary>
-            internal int Id => GetHashCode();
-
-            /// <summary>Takes an array from the bucket.  If the bucket is empty, returns null.</summary>
-            internal T[] Rent()
-            {
-                T[][] buffers = _buffers;
-                T[] buffer = null;
-
-                // While holding the lock, grab whatever is at the next available index and
-                // update the index.  We do as little work as possible while holding the spin
-                // lock to minimize contention with other threads.  The try/finally is
-                // necessary to properly handle thread aborts on platforms which have them.
-                bool lockTaken = false, allocateBuffer = false;
-                try
-                {
-                    _lock.Enter(ref lockTaken);
-
-                    if (_index < buffers.Length)
-                    {
-                        buffer = buffers[_index];
-                        buffers[_index++] = null;
-                        allocateBuffer = buffer == null;
-                    }
-                }
-                finally
-                {
-                    if (lockTaken) _lock.Exit(false);
-                }
-
-                // While we were holding the lock, we grabbed whatever was at the next available index, if
-                // there was one.  If we tried and if we got back null, that means we hadn't yet allocated
-                // for that slot, in which case we should do so now.
-                if (allocateBuffer)
-                {
-                    buffer = new T[_bufferLength];
-                }
-
-                return buffer;
-            }
-
-            /// <summary>
-            /// Attempts to return the buffer to the bucket.  If successful, the buffer will be stored
-            /// in the bucket and true will be returned; otherwise, the buffer won't be stored, and false
-            /// will be returned.
-            /// </summary>
-            internal void Return(T[] array)
-            {
-                // Check to see if the buffer is the correct size for this bucket
-                if (array.Length != _bufferLength)
-                {
-                    throw new ArgumentException("Buffer not from pool", nameof(array));
-                }
-
-                // While holding the spin lock, if there's room available in the bucket,
-                // put the buffer into the next available slot.  Otherwise, we just drop it.
-                // The try/finally is necessary to properly handle thread aborts on platforms
-                // which have them.
-                bool lockTaken = false;
-                try
-                {
-                    _lock.Enter(ref lockTaken);
-
-                    if (_index != 0)
-                    {
-                        _buffers[--_index] = array;
-                    }
-                }
-                finally
-                {
-                    if (lockTaken) _lock.Exit(false);
-                }
-            }
-        }
-    }
-}
-#endif

src/SharpCompress/Buffers/Utilities.cs

@@ -1,38 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-#if NETCORE
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-
-namespace SharpCompress.Buffers
-{
-    internal static class Utilities
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static int SelectBucketIndex(int bufferSize)
-        {
-            Debug.Assert(bufferSize > 0);
-
-            uint bitsRemaining = ((uint)bufferSize - 1) >> 4;
-
-            int poolIndex = 0;
-            if (bitsRemaining > 0xFFFF) { bitsRemaining >>= 16; poolIndex = 16; }
-            if (bitsRemaining > 0xFF)   { bitsRemaining >>= 8;  poolIndex += 8; }
-            if (bitsRemaining > 0xF)    { bitsRemaining >>= 4;  poolIndex += 4; }
-            if (bitsRemaining > 0x3)    { bitsRemaining >>= 2;  poolIndex += 2; }
-            if (bitsRemaining > 0x1)    { bitsRemaining >>= 1;  poolIndex += 1; }
-
-            return poolIndex + (int)bitsRemaining;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static int GetMaxSizeForBucket(int binIndex)
-        {
-            int maxSize = 16 << binIndex;
-            Debug.Assert(maxSize >= 0);
-            return maxSize;
-        }
-    }
-}
-#endif

src/SharpCompress/Common/ArchiveEncoding.cs

@@ -18,26 +18,25 @@ namespace SharpCompress.Common
         /// <summary>
         /// Set this encoding when you want to force it for all encoding operations.
         /// </summary>
-        public Encoding Forced { get; set; }
+        public Encoding? Forced { get; set; }
 
         /// <summary>
         /// Set this when you want to use a custom method for all decoding operations.
         /// </summary>
         /// <returns>string Func(bytes, index, length)</returns>
-        public Func<byte[], int, int, string> CustomDecoder { get; set; }
+        public Func<byte[], int, int, string>? CustomDecoder { get; set; }
 
         public ArchiveEncoding()
+        : this(Encoding.Default, Encoding.Default)
         {
-#if NETSTANDARD1_0
-            Default = Encoding.GetEncoding("cp437");
-            Password = Encoding.GetEncoding("cp437");
-#else    
-            Default = Encoding.GetEncoding(437);
-            Password = Encoding.GetEncoding(437);
-#endif            
+        }
+        public ArchiveEncoding(Encoding def, Encoding password)
+        {
+            Default = def;
+            Password = password;
         }
 
-#if NETSTANDARD1_3 || NETSTANDARD2_0
+#if NETSTANDARD1_3 || NETSTANDARD2_0 || NETSTANDARD2_1
         static ArchiveEncoding()
         {
             Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
@@ -74,4 +73,4 @@ namespace SharpCompress.Common
             return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
         }
     }
-}
+}

src/SharpCompress/Common/CompressedBytesReadEventArgs.cs

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

src/SharpCompress/Common/Entry.cs

@@ -15,6 +15,11 @@ namespace SharpCompress.Common
         /// </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 compressed file size
         /// </summary>
@@ -66,12 +71,10 @@ namespace SharpCompress.Common
         public abstract bool IsSplitAfter { get; }
 
         /// <inheritdoc/>
-        public override string ToString()
-        {
-            return Key;
-        }
+        public override string ToString() => Key;
 
         internal abstract IEnumerable<FilePart> Parts { get; }
+
         internal bool IsSolid { get; set; }
 
         internal virtual void Close()

src/SharpCompress/Common/EntryStream.cs

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

src/SharpCompress/Common/ExtractionMethods.cs

@@ -1,28 +1,26 @@
-#if !NO_FILE
-using System;
+using System;
 using System.IO;
-#endif
 
 namespace SharpCompress.Common
 {
     internal static class ExtractionMethods
     {
-        
-#if !NO_FILE
         /// <summary>
         /// Extract to specific directory, retaining filename
         /// </summary>
-        public static void WriteEntryToDirectory(IEntry entry, string destinationDirectory,
-                                                 ExtractionOptions options, Action<string, ExtractionOptions> write)
+        public static void WriteEntryToDirectory(IEntry entry, 
+                                                 string destinationDirectory,
+                                                 ExtractionOptions? options, 
+                                                 Action<string, ExtractionOptions?> write)
         {
             string destinationFileName;
             string file = Path.GetFileName(entry.Key);
             string fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
 
-            options = options ?? new ExtractionOptions()
-                                 {
-                                     Overwrite = true
-                                 };
+            options ??= new ExtractionOptions()
+                        {
+                            Overwrite = true
+                        };
 
             if (options.ExtractFullPath)
             {
@@ -65,23 +63,33 @@ namespace SharpCompress.Common
         }
         
         public static void WriteEntryToFile(IEntry entry, string destinationFileName,
-                                            ExtractionOptions options,
+                                            ExtractionOptions? options,
                                             Action<string, FileMode> openAndWrite)
         {
-            FileMode fm = FileMode.Create;
-            options = options ?? new ExtractionOptions()
-                                 {
-                                     Overwrite = true
-                                 };
-
-            if (!options.Overwrite)
+            if (entry.LinkTarget != null)
             {
-                fm = FileMode.CreateNew;
+                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
+                                };
 
-            openAndWrite(destinationFileName, fm);
-            entry.PreserveExtractionOptions(destinationFileName, options);
+                if (!options.Overwrite)
+                {
+                    fm = FileMode.CreateNew;
+                }
+
+                openAndWrite(destinationFileName, fm);
+                entry.PreserveExtractionOptions(destinationFileName, options);
+            }
         }
-#endif
     }
 }

src/SharpCompress/Common/ExtractionOptions.cs

@@ -1,4 +1,6 @@
-namespace SharpCompress.Common
+using System;
+
+namespace SharpCompress.Common
 {
     public class ExtractionOptions
     {
@@ -21,5 +23,18 @@
         /// 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");
+            };
     }
 }

src/SharpCompress/Common/FilePart.cs

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

src/SharpCompress/Common/FilePartExtractionBeginEventArgs.cs

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

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
 
 namespace SharpCompress.Common.GZip
 {
@@ -20,6 +19,8 @@ namespace SharpCompress.Common.GZip
 
         public override string Key => _filePart.FilePartName;
 
+        public override string? LinkTarget => null;
+
         public override long CompressedSize => 0;
 
         public override long Size => 0;

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -1,21 +1,20 @@
 using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
-using SharpCompress.Converters;
-using System.Text;
 
 namespace SharpCompress.Common.GZip
 {
     internal class GZipFilePart : FilePart
     {
-        private string _name;
+        private string? _name;
         private readonly Stream _stream;
 
         internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
-        : base(archiveEncoding)
+            : base(archiveEncoding)
         {
             ReadAndValidateGzipHeader(stream);
             EntryStartPosition = stream.Position;
@@ -26,7 +25,7 @@ namespace SharpCompress.Common.GZip
 
         internal DateTime? DateModified { get; private set; }
 
-        internal override string FilePartName => _name;
+        internal override string FilePartName => _name!;
 
         internal override Stream GetCompressedStream()
         {
@@ -60,7 +59,7 @@ namespace SharpCompress.Common.GZip
                 throw new ZlibException("Bad GZIP header.");
             }
 
-            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
+            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
             DateModified = TarHeader.EPOCH.AddSeconds(timet);
             if ((header[3] & 0x04) == 0x04)
             {
@@ -69,7 +68,7 @@ namespace SharpCompress.Common.GZip
 
                 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.");
@@ -117,4 +116,4 @@ namespace SharpCompress.Common.GZip
             return ArchiveEncoding.Decode(buffer);
         }
     }
-}
+}

src/SharpCompress/Common/GZip/GZipVolume.cs

@@ -10,13 +10,11 @@ namespace SharpCompress.Common.GZip
         {
         }
 
-#if !NO_FILE
         public GZipVolume(FileInfo fileInfo, ReaderOptions options)
             : base(fileInfo.OpenRead(), options)
         {
             options.LeaveStreamOpen = false;
         }
-#endif
 
         public override bool IsFirstVolume => true;
 

src/SharpCompress/Common/IEntry.Extensions.cs

@@ -1,7 +1,4 @@
-
-#if !NO_FILE
-using System.IO;
-using SharpCompress.Readers;
+using System.IO;
 
 namespace SharpCompress.Common
 {
@@ -48,4 +45,3 @@ namespace SharpCompress.Common
         }
     }
 }
-#endif

src/SharpCompress/Common/IEntry.cs

@@ -10,6 +10,7 @@ namespace SharpCompress.Common
         long Crc { get; }
         DateTime? CreatedTime { get; }
         string Key { get; }
+        string? LinkTarget { get; }
         bool IsDirectory { get; }
         bool IsEncrypted { get; }
         bool IsSplitAfter { get; }

src/SharpCompress/Common/IVolume.cs

@@ -1,9 +1,5 @@
 using System;
 
-#if !NO_FILE
-using System.IO;
-#endif
-
 namespace SharpCompress.Common
 {
     public interface IVolume : IDisposable

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

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

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

@@ -1,4 +1,6 @@
-using SharpCompress.IO;
+#nullable disable
+
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers
 {

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

@@ -2,7 +2,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers
 {
-    internal class ArchiveHeader : RarHeader
+    internal sealed class ArchiveHeader : RarHeader
     {
         public ArchiveHeader(RarHeader header, RarCrcBinaryReader reader) 
             : base(header, reader, HeaderType.Archive) 
@@ -38,7 +38,11 @@ namespace SharpCompress.Common.Rar.Headers
         private void ReadLocator(MarkingBinaryReader reader) {
             var size = reader.ReadRarVIntUInt16();
             var type = reader.ReadRarVIntUInt16();
-            if (type != 1) throw new InvalidFormatException("expected locator record");
+            if (type != 1)
+            {
+                throw new InvalidFormatException("expected locator record");
+            }
+
             var flags = reader.ReadRarVIntUInt16();
             const ushort hasQuickOpenOffset = 0x01;
             const ushort hasRecoveryOffset = 0x02;
@@ -74,7 +78,7 @@ namespace SharpCompress.Common.Rar.Headers
         public bool IsVolume => HasFlag(IsRar5 ? ArchiveFlagsV5.VOLUME : ArchiveFlagsV4.VOLUME);
 
         // RAR5: Volume number field is present. True for all volumes except first.
-        public bool IsFirstVolume => IsRar5 ? VolumeNumber == null : HasFlag(ArchiveFlagsV4.FIRST_VOLUME);
+        public bool IsFirstVolume => IsRar5 ? VolumeNumber is null : HasFlag(ArchiveFlagsV4.FIRST_VOLUME);
 
         public bool IsSolid => HasFlag(IsRar5 ? ArchiveFlagsV5.SOLID : ArchiveFlagsV4.SOLID);
     }

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

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

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

@@ -1,3 +1,5 @@
+#nullable disable
+
 #if !Rar2017_64bit
 using nint = System.Int32;
 using nuint = System.UInt32;
@@ -195,17 +197,12 @@ namespace SharpCompress.Common.Rar.Headers
 
         private static string ConvertPathV5(string path)
         {
-#if NO_FILE
-            // not sure what to do here
-            throw new NotImplementedException("TODO");
-#else
             if (Path.DirectorySeparatorChar == '\\')
             {
                 // replace embedded \\ with valid filename char
                 return path.Replace('\\', '-').Replace('/', '\\');
             } 
             return path;
-#endif
         }
 
 
@@ -361,9 +358,6 @@ namespace SharpCompress.Common.Rar.Headers
 
         private static string ConvertPathV4(string path)
         {
-#if NO_FILE
-            return path.Replace('\\', '/');
-#else
             if (Path.DirectorySeparatorChar == '/')
             {
                 return path.Replace('\\', '/');
@@ -373,7 +367,6 @@ namespace SharpCompress.Common.Rar.Headers
                 return path.Replace('/', '\\');
             }
             return path;
-#endif
         }
 
         public override string ToString()

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

@@ -46,19 +46,38 @@ namespace SharpCompress.Common.Rar.Headers
                         if (b == 0x61) 
                         {
                             b = GetByte(stream); start++;
-                            if (b != 0x72) continue;
+                            if (b != 0x72)
+                            {
+                                continue;
+                            }
+
                             b = GetByte(stream); start++;
-                            if (b != 0x21) continue;
+                            if (b != 0x21)
+                            {
+                                continue;
+                            }
+
                             b = GetByte(stream); start++;
-                            if (b != 0x1a) continue;
+                            if (b != 0x1a)
+                            {
+                                continue;
+                            }
+
                             b = GetByte(stream); start++;
-                            if (b != 0x07) continue;
+                            if (b != 0x07)
+                            {
+                                continue;
+                            }
 
                             b = GetByte(stream); start++;
                             if (b == 1) 
                             {
                                 b = GetByte(stream); start++;
-                                if (b != 0) continue;
+                                if (b != 0)
+                                {
+                                    continue;
+                                }
+
                                 return new MarkHeader(true); // Rar5
                             } 
                             else if (b == 0) 
@@ -69,9 +88,17 @@ namespace SharpCompress.Common.Rar.Headers
                         else if (b == 0x45) 
                         {
                             b = GetByte(stream); start++;
-                            if (b != 0x7e) continue;
+                            if (b != 0x7e)
+                            {
+                                continue;
+                            }
+
                             b = GetByte(stream); start++;
-                            if (b != 0x5e) continue;
+                            if (b != 0x5e)
+                            {
+                                continue;
+                            }
+
                             throw new InvalidFormatException("Rar format version pre-4 is unsupported.");
                         } 
                     } 

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

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

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

@@ -11,7 +11,7 @@ namespace SharpCompress.Common.Rar.Headers
         private readonly HeaderType _headerType;
         private readonly bool _isRar5;
 
-        internal static RarHeader TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
+        internal static RarHeader? TryReadBase(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
         {
             try
             {

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

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.IO;
@@ -26,7 +25,7 @@ namespace SharpCompress.Common.Rar.Headers
             _isRar5 = markHeader.IsRar5;
             yield return markHeader;
 
-            RarHeader header;
+            RarHeader? header;
             while ((header = TryReadNextHeader(stream)) != null)
             {
                 yield return header;
@@ -39,7 +38,7 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        private RarHeader TryReadNextHeader(Stream stream)
+        private RarHeader? TryReadNextHeader(Stream stream)
         {
             RarCrcBinaryReader reader;
             if (!IsEncrypted) 
@@ -48,19 +47,15 @@ namespace SharpCompress.Common.Rar.Headers
             } 
             else 
             {
-#if !NO_CRYPTO
-                if (Options.Password == null)
+                if (Options.Password is null)
                 {
                     throw new CryptographicException("Encrypted Rar archive has no password specified.");
                 }
                 reader = new RarCryptoBinaryReader(stream, Options.Password);
-#else
-                throw new CryptographicException("Rar encryption unsupported on this platform");
-#endif
             }
 
             var header = RarHeader.TryReadBase(reader, _isRar5, Options.ArchiveEncoding);
-            if (header == null)
+            if (header is null)
             {
                 return null;
             }
@@ -132,17 +127,13 @@ namespace SharpCompress.Common.Rar.Headers
                             case StreamingMode.Streaming:
                                 {
                                     var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                                    if (fh.R4Salt == null)
+                                    if (fh.R4Salt is null)
                                     {
                                         fh.PackedStream = ms;
                                     }
                                     else
                                     {
-#if !NO_CRYPTO
-                                        fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.R4Salt);
-#else
-                                        throw new NotSupportedException("RarCrypto not supported");
-#endif
+                                        fh.PackedStream = new RarCryptoWrapper(ms, Options.Password!, fh.R4Salt);
                                     }
                                 }
                                 break;

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

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

src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs

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

src/SharpCompress/Common/Rar/RarCryptoWrapper.cs

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

src/SharpCompress/Common/Rar/RarEntry.cs

@@ -22,6 +22,8 @@ namespace SharpCompress.Common.Rar
         /// </summary>
         public override string Key => FileHeader.FileName;
 
+        public override string? LinkTarget => null;
+
         /// <summary>
         /// The entry last modified time in the archive, if recorded
         /// </summary>

src/SharpCompress/Common/Rar/RarFilePart.cs

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

src/SharpCompress/Common/Rar/RarRijndael.cs

@@ -1,7 +1,6 @@
-#if !NO_CRYPTO
+#nullable disable
+
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.Crypto;
@@ -23,12 +22,6 @@ namespace SharpCompress.Common.Rar
             _salt = salt;
         }
 
-        private byte[] ComputeHash(byte[] input)
-        {
-            var sha = SHA1.Create();
-            return sha.ComputeHash(input);
-        }
-
         private void Initialize()
         {
 
@@ -47,28 +40,27 @@ namespace SharpCompress.Common.Rar
                 rawPassword[i + rawLength] = _salt[i];
             }
 
-
             const int noOfRounds = (1 << 18);
-            IList<byte> bytes = new List<byte>();
+            const int iblock = 3;
             byte[] digest;
+            byte[] data = new byte[(rawPassword.Length + iblock) * noOfRounds];
 
             //TODO slow code below, find ways to optimize
             for (int i = 0; i < noOfRounds; i++)
             {
-                bytes.AddRange(rawPassword);
+                rawPassword.CopyTo(data, i * (rawPassword.Length + iblock));
 
-                bytes.AddRange(new[]
+                data[i * (rawPassword.Length + iblock) + rawPassword.Length + 0] = (byte)i;
+                data[i * (rawPassword.Length + iblock) + rawPassword.Length + 1] = (byte)(i >> 8);
+                data[i * (rawPassword.Length + iblock) + rawPassword.Length + 2] = (byte)(i >> CRYPTO_BLOCK_SIZE);
+
+                if (i % (noOfRounds / CRYPTO_BLOCK_SIZE) == 0)
                 {
-                    (byte) i, (byte) (i >> 8), (byte) (i >> CRYPTO_BLOCK_SIZE)
-                });
-                if (i%(noOfRounds/CRYPTO_BLOCK_SIZE) == 0)
-                {
-                    digest = ComputeHash(bytes.ToArray());
-                    _aesInitializationVector[i/(noOfRounds/CRYPTO_BLOCK_SIZE)] = digest[19];
+                    digest = SHA1.Create().ComputeHash(data, 0, (i + 1) * (rawPassword.Length + iblock));
+                    _aesInitializationVector[i / (noOfRounds / CRYPTO_BLOCK_SIZE)] = digest[19];
                 }
             }
-
-            digest = ComputeHash(bytes.ToArray());
+            digest = SHA1.Create().ComputeHash(data);
             //slow code ends
 
             byte[] aesKey = new byte[CRYPTO_BLOCK_SIZE];
@@ -98,19 +90,20 @@ namespace SharpCompress.Common.Rar
         public byte[] ProcessBlock(byte[] cipherText)
         {
             var plainText = new byte[CRYPTO_BLOCK_SIZE];
-            var decryptedBytes = new List<byte>();
+            byte[] decryptedBytes = new byte[CRYPTO_BLOCK_SIZE];
             _rijndael.ProcessBlock(cipherText, 0, plainText, 0);
 
-            for (int j = 0; j < plainText.Length; j++)
+            for (int j = 0; j < CRYPTO_BLOCK_SIZE; j++)
             {
-                decryptedBytes.Add((byte) (plainText[j] ^ _aesInitializationVector[j%16])); //32:114, 33:101
+                decryptedBytes[j] = (byte)(plainText[j] ^ _aesInitializationVector[j % 16]); //32:114, 33:101
             }
 
             for (int j = 0; j < _aesInitializationVector.Length; j++)
             {
                 _aesInitializationVector[j] = cipherText[j];
             }
-            return decryptedBytes.ToArray();
+
+            return decryptedBytes;
         }
 
         public void Dispose()
@@ -118,4 +111,3 @@ namespace SharpCompress.Common.Rar
         }
     }
 }
-#endif

src/SharpCompress/Common/Rar/RarVolume.cs

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

src/SharpCompress/Common/ReaderExtractionEventArgs.cs

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

src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs

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

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -1,4 +1,6 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -465,7 +467,7 @@ namespace SharpCompress.Common.SevenZip
                     SkipData();
                 }
 
-                if (packCrCs == null)
+                if (packCrCs is null)
                 {
                     packCrCs = new List<uint?>(numPackStreams);
                     for (int i = 0; i < numPackStreams; i++)
@@ -611,7 +613,7 @@ namespace SharpCompress.Common.SevenZip
                     SkipData();
                 }
 
-                if (numUnpackStreamsInFolders == null)
+                if (numUnpackStreamsInFolders is null)
                 {
                     numUnpackStreamsInFolders = new List<int>(folders.Count);
                     for (int i = 0; i < folders.Count; i++)
@@ -703,7 +705,7 @@ namespace SharpCompress.Common.SevenZip
                     }
                     else if (type == BlockType.End)
                     {
-                        if (digests == null)
+                        if (digests is null)
                         {
                             digests = new List<uint?>(numDigestsTotal);
                             for (int i = 0; i < numDigestsTotal; i++)
@@ -1449,13 +1451,14 @@ namespace SharpCompress.Common.SevenZip
                 CFolder folderInfo = db._folders[folderIndex];
                 int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                 long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
-                List<long> packSizes = new List<long>();
-                for (int j = 0; j < folderInfo._packStreams.Count; j++)
+                var count = folderInfo._packStreams.Count;
+                long[] packSizes = new long[count];
+                for (int j = 0; j < count; j++)
                 {
-                    packSizes.Add(db._packSizes[packStreamIndex + j]);
+                    packSizes[j] = db._packSizes[packStreamIndex + j];
                 }
 
-                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
+                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes, folderInfo,
                                                             db.PasswordProvider);
                 _cachedStreams.Add(folderIndex, s);
             }
@@ -1486,17 +1489,12 @@ namespace SharpCompress.Common.SevenZip
 
         public void Extract(ArchiveDatabase db, int[] indices)
         {
-            int numItems;
-            bool allFilesMode = (indices == null);
-            if (allFilesMode)
-            {
-                numItems = db._files.Count;
-            }
-            else
-            {
-                numItems = indices.Length;
-            }
+            bool allFilesMode = (indices is null);
 
+            int numItems = allFilesMode
+                ? db._files.Count
+                : indices.Length;
+            
             if (numItems == 0)
             {
                 return;
@@ -1553,15 +1551,16 @@ namespace SharpCompress.Common.SevenZip
                 int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                 long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
 
-                List<long> packSizes = new List<long>();
-                for (int j = 0; j < folderInfo._packStreams.Count; j++)
+                var count = folderInfo._packStreams.Count;
+                long[] packSizes = new long[count];
+                for (int j = 0; j < count; j++)
                 {
-                    packSizes.Add(db._packSizes[packStreamIndex + j]);
+                    packSizes[j] = db._packSizes[packStreamIndex + j];
                 }
 
                 // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?
 
-                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
+                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes,
                                                                    folderInfo, db.PasswordProvider);
                 byte[] buffer = new byte[4 << 10];
                 for (;;)

src/SharpCompress/Common/SevenZip/CCoderInfo.cs

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

src/SharpCompress/Common/SevenZip/CFileItem.cs

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

src/SharpCompress/Common/SevenZip/SevenZipEntry.cs

@@ -18,6 +18,8 @@ namespace SharpCompress.Common.SevenZip
 
         public override string Key => FilePart.Header.Name;
 
+        public override string? LinkTarget => null;
+
         public override long CompressedSize => 0;
 
         public override long Size => FilePart.Header.Size;
@@ -36,7 +38,7 @@ namespace SharpCompress.Common.SevenZip
 
         public override bool IsSplitAfter => false;
 
-        public override int? Attrib => (int)FilePart.Header.Attrib;
+        public override int? Attrib => FilePart.Header.Attrib.HasValue ? (int?)FilePart.Header.Attrib.Value : null;
 
         internal override IEnumerable<FilePart> Parts => FilePart.AsEnumerable<FilePart>();
     }

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

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

src/SharpCompress/Common/SevenZip/SevenZipVolume.cs

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

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

@@ -1,7 +1,9 @@
-using System;
+#nullable disable
+
+using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Text;
-using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Tar.Headers
 {
@@ -15,6 +17,7 @@ namespace SharpCompress.Common.Tar.Headers
         }
 
         internal string Name { get; set; }
+        internal string LinkName { get; set; }
 
         //internal int Mode { get; set; }
         //internal int UserId { get; set; }
@@ -38,16 +41,17 @@ namespace SharpCompress.Common.Tar.Headers
             WriteOctalBytes(0, buffer, 116, 8); // group ID
 
             //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
-            if (Name.Length > 100)
+            var nameByteCount = ArchiveEncoding.GetEncoding().GetByteCount(Name);
+            if (nameByteCount > 100)
             {
                 // Set mock filename and filetype to indicate the next block is the actual name of the file
                 WriteStringBytes("././@LongLink", buffer, 0, 100);
                 buffer[156] = (byte)EntryType.LongName;
-                WriteOctalBytes(Name.Length + 1, buffer, 124, 12);
+                WriteOctalBytes(nameByteCount + 1, buffer, 124, 12);
             }
             else
             {
-                WriteStringBytes(Name, buffer, 0, 100);
+                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
                 WriteOctalBytes(Size, buffer, 124, 12);
                 var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
                 WriteOctalBytes(time, buffer, 136, 12);
@@ -55,11 +59,10 @@ namespace SharpCompress.Common.Tar.Headers
 
                 if (Size >= 0x1FFFFFFFF)
                 {
-                    byte[] bytes = DataConverter.BigEndian.GetBytes(Size);
-                    var bytes12 = new byte[12];
-                    bytes.CopyTo(bytes12, 12 - bytes.Length);
+                    Span<byte> bytes12 = stackalloc byte[12];
+                    BinaryPrimitives.WriteInt64BigEndian(bytes12.Slice(4), Size);
                     bytes12[0] |= 0x80;
-                    bytes12.CopyTo(buffer, 124);
+                    bytes12.CopyTo(buffer.AsSpan(124));
                 }
             }
 
@@ -68,10 +71,17 @@ namespace SharpCompress.Common.Tar.Headers
 
             output.Write(buffer, 0, buffer.Length);
 
-            if (Name.Length > 100)
+            if (nameByteCount > 100)
             {
                 WriteLongFilenameHeader(output);
-                Name = Name.Substring(0, 100);
+                // update to short name lower than 100 - [max bytes of one character].
+                // subtracting bytes is needed because preventing infinite loop(example code is here).
+                //
+                // var bytes = Encoding.UTF8.GetBytes(new string(0x3042, 100));
+                // var truncated = Encoding.UTF8.GetBytes(Encoding.UTF8.GetString(bytes, 0, 100));
+                //
+                // and then infinite recursion is occured in WriteLongFilenameHeader because truncated.Length is 102.
+                Name = ArchiveEncoding.Decode(ArchiveEncoding.Encode(Name), 0, 100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1));
                 Write(output);
             }
         }
@@ -98,6 +108,12 @@ namespace SharpCompress.Common.Tar.Headers
                 return false;
             }
 
+            // for symlinks, additionally read the linkname
+            if (ReadEntryType(buffer) == EntryType.SymLink)
+            {
+                LinkName = ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
+            }
+
             if (ReadEntryType(buffer) == EntryType.LongName)
             {
                 Name = ReadLongName(reader, buffer);
@@ -161,8 +177,9 @@ namespace SharpCompress.Common.Tar.Headers
         {
             if ((buffer[124] & 0x80) == 0x80) // if size in binary
             {
-                return DataConverter.BigEndian.GetInt64(buffer, 0x80);
+                return BinaryPrimitives.ReadInt64BigEndian(buffer.AsSpan(0x80));
             }
+
             return ReadAsciiInt64Base8(buffer, 124, 11);
         }
 
@@ -177,11 +194,18 @@ namespace SharpCompress.Common.Tar.Headers
             return buffer;
         }
 
+        private static void WriteStringBytes(ReadOnlySpan<byte> name, Span<byte> buffer, int length)
+        {
+            name.CopyTo(buffer);
+            int i = Math.Min(length, name.Length);
+            buffer.Slice(i, length - i).Clear();
+        }
+
         private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)
         {
             int i;
 
-            for (i = 0; i < length - 1 && i < name.Length; ++i)
+            for (i = 0; i < length && i < name.Length; ++i)
             {
                 buffer[offset + i] = (byte)name[i];
             }
@@ -272,4 +296,4 @@ namespace SharpCompress.Common.Tar.Headers
 
         public string Magic { get; set; }
     }
-}
+}

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -1,9 +1,10 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Tar
 {
@@ -23,6 +24,8 @@ namespace SharpCompress.Common.Tar
 
         public override string Key => _filePart.Header.Name;
 
+        public override string LinkTarget => _filePart.Header.LinkName;
+
         public override long CompressedSize => _filePart.Header.Size;
 
         public override long Size => _filePart.Header.Size;

src/SharpCompress/Common/Tar/TarFilePart.cs

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

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

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

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -1,16 +1,16 @@
-using System;
+using SharpCompress.IO;
+using System;
 using System.IO;
 
 namespace SharpCompress.Common.Tar
 {
-    internal class TarReadOnlySubStream : Stream
+    internal class TarReadOnlySubStream : NonDisposingStream
     {
         private bool _isDisposed;
         private long _amountRead;
 
-        public TarReadOnlySubStream(Stream stream, long bytesToRead)
+        public TarReadOnlySubStream(Stream stream, long bytesToRead) : base(stream, throwOnDispose: false)
         {
-            Stream = stream;
             BytesLeftToRead = bytesToRead;
         }
 
@@ -20,28 +20,29 @@ namespace SharpCompress.Common.Tar
             {
                 return;
             }
+
             _isDisposed = true;
+
             if (disposing)
             {
-                long skipBytes = _amountRead % 512;
-                if (skipBytes == 0)
+                // Ensure we read all remaining blocks for this entry.
+                Stream.Skip(BytesLeftToRead);
+                _amountRead += BytesLeftToRead;
+
+                // If the last block wasn't a full 512 bytes, skip the remaining padding bytes.
+                var bytesInLastBlock = _amountRead % 512;
+
+                if (bytesInLastBlock != 0)
                 {
-                    return;
+                    Stream.Skip(512 - bytesInLastBlock);
                 }
-                skipBytes = 512 - skipBytes;
-                if (skipBytes == 0)
-                {
-                    return;
-                }
-                var buffer = new byte[skipBytes];
-                Stream.ReadFully(buffer);
             }
+
+            base.Dispose(disposing);
         }
 
         private long BytesLeftToRead { get; set; }
 
-        public Stream Stream { get; }
-
         public override bool CanRead => true;
 
         public override bool CanSeek => false;

src/SharpCompress/Common/Volume.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -33,15 +34,18 @@ namespace SharpCompress.Common
         /// </summary>
         public virtual bool IsMultiVolume => true;
 
-        private bool _disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                _actualStream.Dispose();
+            }
+        }
 
         public void Dispose()
         {
-            if (!_disposed)
-            {
-                _actualStream.Dispose();
-                _disposed = true;
-            }
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
     }
 }

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

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

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

@@ -1,6 +1,5 @@
 using System.IO;
 using System.Linq;
-using System.Text;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -93,6 +92,6 @@ namespace SharpCompress.Common.Zip.Headers
 
         public ushort DiskNumberStart { get; set; }
 
-        public string Comment { get; private set; }
+        public string? Comment { get; private set; }
     }
 }

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

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

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

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

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

@@ -1,6 +1,8 @@
-using System;
+#nullable disable
+
+using System;
+using System.Buffers.Binary;
 using System.Text;
-using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -76,34 +78,34 @@ namespace SharpCompress.Common.Zip.Headers
             switch (DataBytes.Length)
             {
                 case 4:
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 0);
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes);
                     return;
                 case 8:
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
                     return;
                 case 12:
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 8);
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(8));
                     return;
                 case 16:
-                     UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                     CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
                     return;
                 case 20:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 16);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(16));
                     return;
                 case 24:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
                     return;
                 case 28:
-                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
-                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
-                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
-                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 24);
+                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
+                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
                     return;
                 default:
                 throw new ArchiveException("Unexpected size of of Zip64 extended information extra field");
@@ -132,7 +134,7 @@ namespace SharpCompress.Common.Zip.Headers
                 case ExtraDataType.Zip64ExtendedInformationExtraField:
                     return new Zip64ExtendedInformationExtraField
                             (
-                                type, 
+                                type,
                                 length,
                                 extraData
                            );
@@ -146,4 +148,4 @@ namespace SharpCompress.Common.Zip.Headers
             }
         }
     }
-}
+}

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

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

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

@@ -1,8 +1,9 @@
-using System;
+#nullable disable
+
+using System;
+using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Text;
-using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -30,7 +31,7 @@ namespace SharpCompress.Common.Zip.Headers
                        && Name.EndsWith("\\");
             }
         }
-        
+
         internal Stream PackedStream { get; set; }
 
         internal ArchiveEncoding ArchiveEncoding { get; }
@@ -53,7 +54,7 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal PkwareTraditionalEncryptionData ComposeEncryptionData(Stream archiveStream)
         {
-            if (archiveStream == null)
+            if (archiveStream is null)
             {
                 throw new ArgumentNullException(nameof(archiveStream));
             }
@@ -61,14 +62,12 @@ namespace SharpCompress.Common.Zip.Headers
             var buffer = new byte[12];
             archiveStream.ReadFully(buffer);
 
-            PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password, this, buffer);
+            PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password!, this, buffer);
 
             return encryptionData;
         }
 
-#if !NO_CRYPTO
         internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
-#endif
 
         internal ushort LastModifiedDate { get; set; }
 
@@ -80,13 +79,22 @@ namespace SharpCompress.Common.Zip.Headers
         {
             for (int i = 0; i < extra.Length - 4;)
             {
-                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
+                ExtraDataType type = (ExtraDataType)BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i));
                 if (!Enum.IsDefined(typeof(ExtraDataType), type))
                 {
                     type = ExtraDataType.NotImplementedExtraData;
                 }
 
-                ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
+                ushort length = BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i + 2));
+
+                // 7zip has this same kind of check to ignore extras blocks that don't conform to the standard 2-byte ID, 2-byte length, N-byte value.
+                // CPP/7Zip/Zip/ZipIn.cpp: CInArchive::ReadExtra
+                if (length > extra.Length)
+                {
+                    // bad extras block
+                    return;
+                }
+
                 byte[] data = new byte[length];
                 Buffer.BlockCopy(extra, i + 4, data, 0, length);
                 Extra.Add(LocalEntryHeaderExtraFactory.Create(type, length, data));
@@ -99,4 +107,4 @@ namespace SharpCompress.Common.Zip.Headers
 
         internal bool IsZip64 => CompressedSize == uint.MaxValue;
     }
-}
+}

src/SharpCompress/Common/Zip/PkwareTraditionalCryptoStream.cs

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

src/SharpCompress/Common/Zip/PkwareTraditionalEncryptionData.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Text;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 
@@ -65,9 +64,9 @@ namespace SharpCompress.Common.Zip
 
         public byte[] Encrypt(byte[] plainText, int length)
         {
-            if (plainText == null)
+            if (plainText is null)
             {
-                throw new ArgumentNullException("plaintext");
+                throw new ArgumentNullException(nameof(plainText));
             }
 
             if (length > plainText.Length)

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -1,5 +1,6 @@
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip
 {
@@ -7,11 +8,13 @@ namespace SharpCompress.Common.Zip
     {
         private bool _isLocalHeaderLoaded;
         private readonly SeekableZipHeaderFactory _headerFactory;
+        private readonly DirectoryEntryHeader _directoryEntryHeader;
 
         internal SeekableZipFilePart(SeekableZipHeaderFactory headerFactory, DirectoryEntryHeader header, Stream stream)
             : base(header, stream)
         {
             _headerFactory = headerFactory;
+            _directoryEntryHeader = header;
         }
 
         internal override Stream GetCompressedStream()
@@ -24,18 +27,27 @@ namespace SharpCompress.Common.Zip
             return base.GetCompressedStream();
         }
 
-        internal string Comment => (Header as DirectoryEntryHeader).Comment;
+        internal string? Comment => ((DirectoryEntryHeader)Header).Comment;
 
         private void LoadLocalHeader()
         {
             bool hasData = Header.HasData;
-            Header = _headerFactory.GetLocalHeader(BaseStream, Header as DirectoryEntryHeader);
+            Header = _headerFactory.GetLocalHeader(BaseStream, ((DirectoryEntryHeader)Header));
             Header.HasData = hasData;
         }
 
         protected override Stream CreateBaseStream()
         {
-            BaseStream.Position = Header.DataStartPosition.Value;
+            BaseStream.Position = Header.DataStartPosition!.Value;
+
+            if ((Header.CompressedSize == 0)
+                && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)
+                && (_directoryEntryHeader?.HasData == true)
+                && (_directoryEntryHeader?.CompressedSize != 0))
+            {
+                return new ReadOnlySubStream(BaseStream, _directoryEntryHeader!.CompressedSize);
+            }
+
             return BaseStream;
         }
     }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -3,21 +3,20 @@ using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Zip
 {
-    internal class SeekableZipHeaderFactory : ZipHeaderFactory
+    internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
     {
         private const int MAX_ITERATIONS_FOR_DIRECTORY_HEADER = 4096;
         private bool _zip64;
 
-        internal SeekableZipHeaderFactory(string password, ArchiveEncoding archiveEncoding)
+        internal SeekableZipHeaderFactory(string? password, ArchiveEncoding archiveEncoding)
             : base(StreamingMode.Seekable, password, archiveEncoding)
         {
         }
 
-        internal IEnumerable<DirectoryEntryHeader> ReadSeekableHeader(Stream stream)
+        internal IEnumerable<ZipHeader> ReadSeekableHeader(Stream stream)
         {
             var reader = new BinaryReader(stream);
 
@@ -35,7 +34,9 @@ namespace SharpCompress.Common.Zip
                 stream.Seek(zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord, SeekOrigin.Begin);
                 uint zip64Signature = reader.ReadUInt32();
                 if (zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
+                {
                     throw new ArchiveException("Failed to locate the Zip64 Header");
+                }
 
                 var zip64Entry = new Zip64DirectoryEndHeader();
                 zip64Entry.Read(reader);
@@ -51,16 +52,24 @@ namespace SharpCompress.Common.Zip
             {
                 stream.Position = position;
                 uint signature = reader.ReadUInt32();
-                var directoryEntryHeader = ReadHeader(signature, reader, _zip64) as DirectoryEntryHeader;
+                var nextHeader = ReadHeader(signature, reader, _zip64);
                 position = stream.Position;
-                if (directoryEntryHeader == null)
+
+                if (nextHeader is null)
                 {
                     yield break;
                 }
 
-                //entry could be zero bytes so we need to know that.
-                directoryEntryHeader.HasData = directoryEntryHeader.CompressedSize != 0;
-                yield return directoryEntryHeader;
+                if (nextHeader is DirectoryEntryHeader entryHeader)
+                {
+                    //entry could be zero bytes so we need to know that.
+                    entryHeader.HasData = entryHeader.CompressedSize != 0;
+                    yield return entryHeader;
+                }
+                else if (nextHeader is DirectoryEndHeader endHeader)
+                {
+                    yield return endHeader;
+                }
             }
         }
 
@@ -93,7 +102,7 @@ namespace SharpCompress.Common.Zip
             BinaryReader reader = new BinaryReader(stream);
             uint signature = reader.ReadUInt32();
             var localEntryHeader = ReadHeader(signature, reader, _zip64) as LocalEntryHeader;
-            if (localEntryHeader == null)
+            if (localEntryHeader is null)
             {
                 throw new InvalidOperationException();
             }

src/SharpCompress/Common/Zip/StreamingZipFilePart.cs

@@ -5,9 +5,9 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip
 {
-    internal class StreamingZipFilePart : ZipFilePart
+    internal sealed class StreamingZipFilePart : ZipFilePart
     {
-        private Stream _decompressionStream;
+        private Stream? _decompressionStream;
 
         internal StreamingZipFilePart(ZipFileEntry header, Stream stream)
             : base(header, stream)
@@ -41,14 +41,11 @@ namespace SharpCompress.Common.Zip
             }
             if (Header.HasData && !Skipped)
             {
-                if (_decompressionStream == null)
-                {
-                    _decompressionStream = GetCompressedStream();
-                }
+                _decompressionStream ??= GetCompressedStream();
+                
                 _decompressionStream.Skip();
 
-                DeflateStream deflateStream = _decompressionStream as DeflateStream;
-                if (deflateStream != null)
+                if (_decompressionStream is DeflateStream deflateStream)
                 {
                     rewindableStream.Rewind(deflateStream.InputBuffer);
                 }

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -2,13 +2,12 @@
 using System.IO;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Zip
 {
     internal class StreamingZipHeaderFactory : ZipHeaderFactory
     {
-        internal StreamingZipHeaderFactory(string password, ArchiveEncoding archiveEncoding)
+        internal StreamingZipHeaderFactory(string? password, ArchiveEncoding archiveEncoding)
             : base(StreamingMode.Streaming, password, archiveEncoding)
         {
         }
@@ -16,9 +15,10 @@ namespace SharpCompress.Common.Zip
         internal IEnumerable<ZipHeader> ReadStreamHeader(Stream stream)
         {
             RewindableStream rewindableStream;
-            if (stream is RewindableStream)
+
+            if (stream is RewindableStream rs)
             {
-                rewindableStream = stream as RewindableStream;
+                rewindableStream = rs;
             }
             else
             {
@@ -26,12 +26,12 @@ namespace SharpCompress.Common.Zip
             }
             while (true)
             {
-                ZipHeader header = null;
+                ZipHeader? header;
                 BinaryReader reader = new BinaryReader(rewindableStream);
                 if (_lastEntryHeader != null &&
                     (FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor) || _lastEntryHeader.IsZip64))
                 {
-                    reader = (_lastEntryHeader.Part as StreamingZipFilePart).FixStreamedFileLocation(ref rewindableStream);
+                    reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(ref rewindableStream);
                     long? pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
                     uint crc = reader.ReadUInt32();
                     if (crc == POST_DATA_DESCRIPTOR)
@@ -49,18 +49,35 @@ namespace SharpCompress.Common.Zip
                 _lastEntryHeader = null;
                 uint headerBytes = reader.ReadUInt32();
                 header = ReadHeader(headerBytes, reader);
+                if (header is null) { yield break; }
 
                 //entry could be zero bytes so we need to know that.
                 if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
                 {
-                    bool isRecording = rewindableStream.IsRecording;
-                    if (!isRecording)
+                    var local_header = ((LocalEntryHeader)header);
+
+                    // If we have CompressedSize, there is data to be read
+                    if( local_header.CompressedSize > 0 )
                     {
-                        rewindableStream.StartRecording();
+                        header.HasData = true;
+                    } // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
+                    else if( local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor) )
+                    {
+                        bool isRecording = rewindableStream.IsRecording;
+                        if (!isRecording)
+                        {
+                            rewindableStream.StartRecording();
+                        }
+                        uint nextHeaderBytes = reader.ReadUInt32();
+
+                        // Check if next data is PostDataDescriptor, streamed file with 0 length
+                        header.HasData = !IsHeader(nextHeaderBytes);
+                        rewindableStream.Rewind(!isRecording);
+                    }
+                    else // We are not streaming and compressed size is 0, we have no data
+                    {
+                        header.HasData = false;
                     }
-                    uint nextHeaderBytes = reader.ReadUInt32();
-                    header.HasData = !IsHeader(nextHeaderBytes);
-                    rewindableStream.Rewind(!isRecording);
                 }
                 yield return header;
             }

src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs

@@ -1,9 +1,7 @@
-
-#if !NO_CRYPTO
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Security.Cryptography;
-using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip
 {
@@ -120,7 +118,7 @@ namespace SharpCompress.Common.Zip
                                   : bytesRemaining;
 
             // update the counter
-            DataConverter.LittleEndian.PutBytes(_counter, 0, _nonce++);
+            BinaryPrimitives.WriteInt32LittleEndian(_counter, _nonce++);
 
             // Determine if this is the final block
             if ((bytesToRead == bytesRemaining) && (_totalBytesLeftToRead == 0))
@@ -181,4 +179,3 @@ namespace SharpCompress.Common.Zip
         }
     }
 }
-#endif

src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs

@@ -1,8 +1,8 @@
+#nullable disable
 
-#if !NO_CRYPTO
 using System;
+using System.Buffers.Binary;
 using System.Security.Cryptography;
-using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip
 {
@@ -27,14 +27,9 @@ namespace SharpCompress.Common.Zip
             Initialize();
         }
 
-        internal byte[] IvBytes
-{
-    get; set;
-}
-        internal byte[] KeyBytes
-{
-    get; set;
-}
+        internal byte[] IvBytes { get; set; }
+
+        internal byte[] KeyBytes { get; set; }
 
         private int KeySizeInBytes
         {
@@ -44,16 +39,13 @@ namespace SharpCompress.Common.Zip
 
         internal static int KeyLengthInBytes(WinzipAesKeySize keySize)
         {
-            switch (keySize)
+            return keySize switch
             {
-                case WinzipAesKeySize.KeySize128:
-                    return 16;
-                case WinzipAesKeySize.KeySize192:
-                    return 24;
-                case WinzipAesKeySize.KeySize256:
-                    return 32;
-            }
-            throw new InvalidOperationException();
+                WinzipAesKeySize.KeySize128 => 16,
+                WinzipAesKeySize.KeySize192 => 24,
+                WinzipAesKeySize.KeySize256 => 32,
+                _ => throw new InvalidOperationException(),
+            };
         }
 
         private void Initialize()
@@ -64,10 +56,10 @@ namespace SharpCompress.Common.Zip
             IvBytes = rfc2898.GetBytes(KeySizeInBytes);
             _generatedVerifyValue = rfc2898.GetBytes(2);
 
-            short verify = DataConverter.LittleEndian.GetInt16(_passwordVerifyValue, 0);
+            short verify = BinaryPrimitives.ReadInt16LittleEndian(_passwordVerifyValue);
             if (_password != null)
             {
-                short generated = DataConverter.LittleEndian.GetInt16(_generatedVerifyValue, 0);
+                short generated = BinaryPrimitives.ReadInt16LittleEndian(_generatedVerifyValue);
                 if (verify != generated)
                 {
                     throw new InvalidFormatException("bad password");
@@ -76,4 +68,3 @@ namespace SharpCompress.Common.Zip
         }
     }
 }
-#endif

src/SharpCompress/Common/Zip/ZipEntry.cs

@@ -1,4 +1,6 @@
-using System;
+#nullable disable
+
+using System;
 using System.Collections.Generic;
 using SharpCompress.Common.Zip.Headers;
 
@@ -60,6 +62,8 @@ namespace SharpCompress.Common.Zip
 
         public override string Key => _filePart.Header.Name;
 
+        public override string LinkTarget => null;
+
         public override long CompressedSize => _filePart.Header.CompressedSize;
 
         public override long Size => _filePart.Header.UncompressedSize;

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Zip.Headers;
@@ -8,7 +9,6 @@ using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.Deflate64;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.PPMd;
-using SharpCompress.Converters;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip
@@ -100,7 +100,7 @@ namespace SharpCompress.Common.Zip
                 case ZipCompressionMethod.WinzipAes:
                 {
                     ExtraData data = Header.Extra.Where(x => x.Type == ExtraDataType.WinZipAes).SingleOrDefault();
-                    if (data == null)
+                    if (data is null)
                     {
                         throw new InvalidFormatException("No Winzip AES extra data found.");
                     }
@@ -108,19 +108,19 @@ namespace SharpCompress.Common.Zip
                     {
                         throw new InvalidFormatException("Winzip data length is not 7.");
                     }
-                    ushort compressedMethod = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 0);
+                    ushort compressedMethod = BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes);
 
                     if (compressedMethod != 0x01 && compressedMethod != 0x02)
                     {
                         throw new InvalidFormatException("Unexpected vendor version number for WinZip AES metadata");
                     }
 
-                    ushort vendorId = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 2);
+                    ushort vendorId = BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(2));
                     if (vendorId != 0x4541)
                     {
                         throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
                     }
-                    return CreateDecompressionStream(stream, (ZipCompressionMethod)DataConverter.LittleEndian.GetUInt16(data.DataBytes, 5));
+                    return CreateDecompressionStream(stream, (ZipCompressionMethod)BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(5)));
                 }
                 default:
                 {
@@ -142,7 +142,7 @@ namespace SharpCompress.Common.Zip
                 && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
                 || Header.IsZip64)
             {
-                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close    
+                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close
             }
             else
             {
@@ -165,12 +165,10 @@ namespace SharpCompress.Common.Zip
 
                     case ZipCompressionMethod.WinzipAes:
                     {
-#if !NO_FILE
                         if (Header.WinzipAesEncryptionData != null)
                         {
                             return new WinzipAesCryptoStream(plainStream, Header.WinzipAesEncryptionData, Header.CompressedSize - 10);
                         }
-#endif
                         return plainStream;
                     }
 
@@ -184,4 +182,4 @@ namespace SharpCompress.Common.Zip
             return plainStream;
         }
     }
-}
+}

src/SharpCompress/Common/Zip/ZipHeaderFactory.cs

@@ -1,11 +1,8 @@
 using System;
 using System.IO;
-#if !NO_CRYPTO
 using System.Linq;
-#endif
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Zip
 {
@@ -21,19 +18,19 @@ namespace SharpCompress.Common.Zip
         internal const uint ZIP64_END_OF_CENTRAL_DIRECTORY = 0x06064b50;
         internal const uint ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR = 0x07064b50;
 
-        protected LocalEntryHeader _lastEntryHeader;
-        private readonly string _password;
+        protected LocalEntryHeader? _lastEntryHeader;
+        private readonly string? _password;
         private readonly StreamingMode _mode;
         private readonly ArchiveEncoding _archiveEncoding;
 
-        protected ZipHeaderFactory(StreamingMode mode, string password, ArchiveEncoding archiveEncoding)
+        protected ZipHeaderFactory(StreamingMode mode, string? password, ArchiveEncoding archiveEncoding)
         {
             this._mode = mode;
             this._password = password;
             this._archiveEncoding = archiveEncoding;
         }
 
-        protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
+        protected ZipHeader? ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
         {
             switch (headerBytes)
             {
@@ -54,7 +51,7 @@ namespace SharpCompress.Common.Zip
                 }
                 case POST_DATA_DESCRIPTOR:
                     {
-                        if (FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
+                        if (FlagUtility.HasFlag(_lastEntryHeader!.Flags, HeaderFlags.UsePostDataDescriptor))
                         {
                             _lastEntryHeader.Crc = reader.ReadUInt32();
                             _lastEntryHeader.CompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
@@ -91,7 +88,7 @@ namespace SharpCompress.Common.Zip
                         return entry;
                     }
                 default:
-                    throw new NotSupportedException("Unknown header: " + headerBytes);
+                    return null;
             }
         }
 
@@ -123,7 +120,7 @@ namespace SharpCompress.Common.Zip
                     throw new NotSupportedException("SharpCompress cannot currently read non-seekable Zip Streams with encrypted data that has been written in a non-seekable manner.");
                 }
 
-                if (_password == null)
+                if (_password is null)
                 {
                     throw new CryptographicException("No password supplied for encrypted zip.");
                 }
@@ -132,10 +129,6 @@ namespace SharpCompress.Common.Zip
 
                 if (entryHeader.CompressionMethod == ZipCompressionMethod.WinzipAes)
                 {
-#if NO_CRYPTO
-                    throw new NotSupportedException("Cannot decrypt Winzip AES with Silverlight or WP7.");
-#else
-
                     ExtraData data = entryHeader.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
                     if (data != null)
                     {
@@ -150,7 +143,6 @@ namespace SharpCompress.Common.Zip
 
                         entryHeader.CompressedSize -= (uint)(salt.Length + 2);
                     }
-#endif
                 }
             }