Intermediate commit. Was trying out a progress bar

.circleci/config.yml

@@ -1,11 +0,0 @@
-version: 2
-jobs:
-  build:
-    docker:
-      - image: adamhathcock/cake-build:latest
-    steps:
-      - checkout
-      - run:
-          name: Build
-          command: ./build.sh
-      

.gitattributes

@@ -2,4 +2,4 @@
 * text=auto
 
 # need original files to be windows
-*.txt text eol=crlf
+test/TestArchives/Original/*.txt eol=crlf

.gitignore

@@ -14,4 +14,3 @@ tests/TestArchives/Scratch
 .vs
 tools
 .vscode
-.idea/

.travis.yml

@@ -0,0 +1,13 @@
+dist: trusty
+language: csharp
+cache:
+  directories:
+  - $HOME/.dotnet
+solution: SharpCompress.sln
+matrix:
+  include:
+    - dotnet: 1.0.4
+      mono: none
+      env: DOTNETCORE=1
+script:
+  - ./build.sh

README.md

@@ -7,8 +7,8 @@ The major feature is support for non-seekable streams so large files can be proc
 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)
+Travis CI Build - 
+[![Build Status](https://travis-ci.org/adamhathcock/sharpcompress.svg?branch=master)](https://travis-ci.org/adamhathcock/sharpcompress)
 
 ## Need Help?
 Post Issues on Github!
@@ -44,14 +44,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 
 ## Version Log
 
-### Version 0.18
-
-* [Now on Github releases](https://github.com/adamhathcock/sharpcompress/releases/tag/0.18)
-
-### Version 0.17.1
-
-* Fix - [Bug Fix for .NET Core on Windows](https://github.com/adamhathcock/sharpcompress/pull/257)
-
 ### Version 0.17.0
 
 * New - Full LZip support!  Can read and write LZip files and Tars inside LZip files.  [Make LZip a first class citizen. #241](https://github.com/adamhathcock/sharpcompress/issues/241)

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}") = "dotnet-sharpcompress", "src\dotnet-sharpcompress\dotnet-sharpcompress.csproj", "{CC08976E-8E3B-44EE-BDA7-6A9D2FDDDB02}"
+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
+		{CC08976E-8E3B-44EE-BDA7-6A9D2FDDDB02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CC08976E-8E3B-44EE-BDA7-6A9D2FDDDB02}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CC08976E-8E3B-44EE-BDA7-6A9D2FDDDB02}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CC08976E-8E3B-44EE-BDA7-6A9D2FDDDB02}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -34,5 +40,6 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
 		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
+		{CC08976E-8E3B-44EE-BDA7-6A9D2FDDDB02} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
 	EndGlobalSection
 EndGlobal

SharpCompress.sln.DotSettings

@@ -114,7 +114,6 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
-	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@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>

build.cake

@@ -30,11 +30,8 @@ Task("Build")
 
         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);
+        settings.Framework = "netcoreapp1.1";
+        DotNetCoreBuild("./tests/SharpCompress.Test/SharpCompress.Test.csproj", settings);
     }
 });
 
@@ -42,25 +39,23 @@ Task("Test")
   .IsDependentOn("Build")
   .Does(() =>
 {
-    var files = GetFiles("tests/**/*.csproj");
-    foreach(var file in files)
+    if (!bool.Parse(EnvironmentVariable("APPVEYOR") ?? "false")
+        && !bool.Parse(EnvironmentVariable("TRAVIS") ?? "false"))
     {
-        var settings = new DotNetCoreTestSettings
+        var files = GetFiles("tests/**/*.csproj");
+        foreach(var file in files)
         {
-            Configuration = "Release",
-            Framework = "netcoreapp2.0"
-        };
+            var settings = new DotNetCoreTestSettings
+            {
+                Configuration = "Release"
+            };
 
-        DotNetCoreTest(file.ToString(), settings);
-
-
-        settings = new DotNetCoreTestSettings
-        {
-            Configuration = "Release",
-            Framework = "netcoreapp1.1"
-        };
-
-        DotNetCoreTest(file.ToString(), settings);
+            DotNetCoreTest(file.ToString(), settings);
+        }
+    } 
+    else 
+    {
+        Information("Skipping tests as this is AppVeyor or Travis CI");
     }
 });
 

build.sh

@@ -8,7 +8,7 @@
 # Define directories.
 SCRIPT_DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
 TOOLS_DIR=$SCRIPT_DIR/tools
-CAKE_VERSION=0.23.0
+CAKE_VERSION=0.19.1
 CAKE_DLL=$TOOLS_DIR/Cake.CoreCLR.$CAKE_VERSION/Cake.dll
 
 # Make sure the tools folder exist.

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -14,7 +14,6 @@ namespace SharpCompress.Archives.GZip
     public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
     {
 #if !NO_FILE
-
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
@@ -37,7 +36,6 @@ namespace SharpCompress.Archives.GZip
             return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
 #endif
-
         /// <summary>
         /// Takes a seekable Stream as a source
         /// </summary>
@@ -56,11 +54,11 @@ namespace SharpCompress.Archives.GZip
 
 #if !NO_FILE
 
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
+/// <summary>
+/// Constructor with a FileInfo object to an existing file.
+/// </summary>
+/// <param name="fileInfo"></param>
+/// <param name="options"></param>
         internal GZipArchive(FileInfo fileInfo, ReaderOptions options)
             : base(ArchiveType.GZip, fileInfo, options)
         {
@@ -106,9 +104,15 @@ namespace SharpCompress.Archives.GZip
         {
             // read the header on the first read
             byte[] header = new byte[10];
+            int n = stream.Read(header, 0, header.Length);
 
             // workitem 8501: handle edge case (decompress empty stream)
-            if (!stream.ReadFully(header))
+            if (n == 0)
+            {
+                return false;
+            }
+
+            if (n != 10)
             {
                 return false;
             }
@@ -154,7 +158,7 @@ namespace SharpCompress.Archives.GZip
             {
                 throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
             }
-            using (var writer = new GZipWriter(stream, new GZipWriterOptions(options)))
+            using (var writer = new GZipWriter(stream))
             {
                 foreach (var entry in oldEntries.Concat(newEntries)
                                                 .Where(x => !x.IsDirectory))
@@ -175,7 +179,7 @@ namespace SharpCompress.Archives.GZip
         protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
         {
             Stream stream = volumes.Single().Stream;
-            yield return new GZipArchiveEntry(this, new GZipFilePart(stream, ReaderOptions.ArchiveEncoding));
+            yield return new GZipArchiveEntry(this, new GZipFilePart(stream));
         }
 
         protected override IReader CreateReaderForSolidExtraction()

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -4,7 +4,6 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.SevenZip;
-using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -107,7 +106,7 @@ namespace SharpCompress.Archives.SevenZip
             for (int i = 0; i < database.Files.Count; i++)
             {
                 var file = database.Files[i];
-                yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file, ReaderOptions.ArchiveEncoding));
+                yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file));
             }
         }
 
@@ -118,7 +117,7 @@ namespace SharpCompress.Archives.SevenZip
                 stream.Position = 0;
                 var reader = new ArchiveReader();
                 reader.Open(stream);
-                database = reader.ReadDatabase(new PasswordProvider(ReaderOptions.Password));
+                database = reader.ReadDatabase(null);
             }
         }
 
@@ -145,7 +144,7 @@ namespace SharpCompress.Archives.SevenZip
 
         protected override IReader CreateReaderForSolidExtraction()
         {
-            return new SevenZipReader(ReaderOptions, this);
+            return new SevenZipReader(this);
         }
 
         public override bool IsSolid { get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; } }
@@ -166,8 +165,8 @@ namespace SharpCompress.Archives.SevenZip
             private Stream currentStream;
             private CFileItem currentItem;
 
-            internal SevenZipReader(ReaderOptions readerOptions, SevenZipArchive archive)
-                : base(readerOptions, ArchiveType.SevenZip)
+            internal SevenZipReader(SevenZipArchive archive)
+                : base(new ReaderOptions(), ArchiveType.SevenZip)
             {
                 this.archive = archive;
             }
@@ -191,7 +190,7 @@ namespace SharpCompress.Archives.SevenZip
                     }
                     else
                     {
-                        currentStream = archive.database.GetFolderStream(stream, currentFolder, new PasswordProvider(Options.Password));
+                        currentStream = archive.database.GetFolderStream(stream, currentFolder, null);
                     }
                     foreach (var entry in group)
                     {
@@ -206,21 +205,5 @@ namespace SharpCompress.Archives.SevenZip
                 return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
             }
         }
-        
-        private class PasswordProvider : IPasswordProvider
-        {
-            private readonly string _password;
-
-            public PasswordProvider(string password)
-            {
-                _password = password;
-
-            }
-
-            public string CryptoGetTextPassword()
-            {
-                return _password;
-            }
-        }
     }
 }

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -16,7 +16,7 @@ namespace SharpCompress.Archives.Tar
     public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
     {
 #if !NO_FILE
-
+        
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
@@ -39,7 +39,7 @@ namespace SharpCompress.Archives.Tar
             return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
 #endif
-
+        
         /// <summary>
         /// Takes a seekable Stream as a source
         /// </summary>
@@ -52,7 +52,6 @@ namespace SharpCompress.Archives.Tar
         }
 
 #if !NO_FILE
-
         public static bool IsTarFile(string filePath)
         {
             return IsTarFile(new FileInfo(filePath));
@@ -75,7 +74,7 @@ namespace SharpCompress.Archives.Tar
         {
             try
             {
-                TarHeader tar = new TarHeader(new ArchiveEncoding());
+                TarHeader tar = new TarHeader();
                 tar.Read(new BinaryReader(stream));
                 return tar.Name.Length > 0 && Enum.IsDefined(typeof(EntryType), tar.EntryType);
             }
@@ -99,6 +98,7 @@ namespace SharpCompress.Archives.Tar
 
         protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
         {
+            
             return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
         }
 #endif
@@ -127,7 +127,7 @@ namespace SharpCompress.Archives.Tar
         {
             Stream stream = volumes.Single().Stream;
             TarHeader previousHeader = null;
-            foreach (TarHeader header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream, ReaderOptions.ArchiveEncoding))
+            foreach (TarHeader header in TarHeaderFactory.ReadHeader(StreamingMode.Seekable, stream))
             {
                 if (header != null)
                 {
@@ -152,7 +152,7 @@ namespace SharpCompress.Archives.Tar
                                     memoryStream.Position = 0;
                                     var bytes = memoryStream.ToArray();
 
-                                    header.Name = ReaderOptions.ArchiveEncoding.Decode(bytes).TrimNulls();
+                                    header.Name = ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length).TrimNulls();
                                 }
                             }
 

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -24,7 +24,6 @@ namespace SharpCompress.Archives.Zip
         public CompressionLevel DeflateCompressionLevel { get; set; }
 
 #if !NO_FILE
-
         /// <summary>
         /// Constructor expects a filepath to an existing file.
         /// </summary>
@@ -47,7 +46,6 @@ namespace SharpCompress.Archives.Zip
             return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
         }
 #endif
-
         /// <summary>
         /// Takes a seekable Stream as a source
         /// </summary>
@@ -60,7 +58,6 @@ namespace SharpCompress.Archives.Zip
         }
 
 #if !NO_FILE
-
         public static bool IsZipFile(string filePath, string password = null)
         {
             return IsZipFile(new FileInfo(filePath), password);
@@ -81,7 +78,7 @@ namespace SharpCompress.Archives.Zip
 
         public static bool IsZipFile(Stream stream, string password = null)
         {
-            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding());
+            StreamingZipHeaderFactory headerFactory = new StreamingZipHeaderFactory(password);
             try
             {
                 ZipHeader header =
@@ -112,7 +109,7 @@ namespace SharpCompress.Archives.Zip
         internal ZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
             : base(ArchiveType.Zip, fileInfo, readerOptions)
         {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password);
         }
 
         protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
@@ -134,7 +131,7 @@ namespace SharpCompress.Archives.Zip
         internal ZipArchive(Stream stream, ReaderOptions readerOptions)
             : base(ArchiveType.Zip, stream, readerOptions)
         {
-            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password, readerOptions.ArchiveEncoding);
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password);
         }
 
         protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams)
@@ -153,19 +150,19 @@ namespace SharpCompress.Archives.Zip
                     switch (h.ZipHeaderType)
                     {
                         case ZipHeaderType.DirectoryEntry:
-                            {
-                                yield return new ZipArchiveEntry(this,
-                                                                 new SeekableZipFilePart(headerFactory,
-                                                                                         h as DirectoryEntryHeader,
-                                                                                         stream));
-                            }
+                        {
+                            yield return new ZipArchiveEntry(this,
+                                                             new SeekableZipFilePart(headerFactory,
+                                                                                     h as DirectoryEntryHeader,
+                                                                                     stream));
+                        }
                             break;
                         case ZipHeaderType.DirectoryEnd:
-                            {
-                                byte[] bytes = (h as DirectoryEndHeader).Comment;
-                                volume.Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                                yield break;
-                            }
+                        {
+                            byte[] bytes = (h as DirectoryEndHeader).Comment;
+                            volume.Comment = ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length);
+                            yield break;
+                        }
                     }
                 }
             }
@@ -208,7 +205,7 @@ namespace SharpCompress.Archives.Zip
         {
             var stream = Volumes.Single().Stream;
             stream.Position = 0;
-            return ZipReader.Open(stream, ReaderOptions);
+            return ZipReader.Open(stream);
         }
     }
 }

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

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

src/SharpCompress/Common/FilePart.cs

@@ -4,17 +4,9 @@ namespace SharpCompress.Common
 {
     public abstract class FilePart
     {
-        protected FilePart(ArchiveEncoding archiveEncoding)
-        {
-            ArchiveEncoding = archiveEncoding;
-        }
-
-        internal ArchiveEncoding ArchiveEncoding { get; }
-        
         internal abstract string FilePartName { get; }
 
         internal abstract Stream GetCompressedStream();
         internal abstract Stream GetRawStream();
-        internal bool Skipped { get; set; }
     }
 }

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
 {
@@ -40,9 +39,9 @@ namespace SharpCompress.Common.GZip
 
         internal override IEnumerable<FilePart> Parts => filePart.AsEnumerable<FilePart>();
 
-        internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
+        internal static IEnumerable<GZipEntry> GetEntries(Stream stream)
         {
-            yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
+            yield return new GZipEntry(new GZipFilePart(stream));
         }
     }
 }

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -5,37 +5,35 @@ 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 readonly Stream _stream;
+        private string name;
+        private readonly Stream stream;
 
-        internal GZipFilePart(Stream stream, ArchiveEncoding archiveEncoding)
-        : base(archiveEncoding)
+        internal GZipFilePart(Stream stream)
         {
             ReadAndValidateGzipHeader(stream);
             EntryStartPosition = stream.Position;
-            this._stream = stream;
+            this.stream = stream;
         }
 
         internal long EntryStartPosition { get; }
 
         internal DateTime? DateModified { get; private set; }
 
-        internal override string FilePartName => _name;
+        internal override string FilePartName => name;
 
         internal override Stream GetCompressedStream()
         {
-            return new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default, false);
+            return new DeflateStream(stream, CompressionMode.Decompress, CompressionLevel.Default, false);
         }
 
         internal override Stream GetRawStream()
         {
-            return _stream;
+            return stream;
         }
 
         private void ReadAndValidateGzipHeader(Stream stream)
@@ -69,16 +67,15 @@ namespace SharpCompress.Common.GZip
 
                 Int16 extraLength = (Int16)(header[0] + header[1] * 256);
                 byte[] extra = new byte[extraLength];
-                
-                if (!stream.ReadFully(extra))
+                n = stream.Read(extra, 0, extra.Length);
+                if (n != extraLength)
                 {
                     throw new ZlibException("Unexpected end-of-file reading GZIP header.");
                 }
-                n = extraLength;
             }
             if ((header[3] & 0x08) == 0x08)
             {
-                _name = ReadZeroTerminatedString(stream);
+                name = ReadZeroTerminatedString(stream);
             }
             if ((header[3] & 0x10) == 0x010)
             {
@@ -90,7 +87,7 @@ namespace SharpCompress.Common.GZip
             }
         }
 
-        private string ReadZeroTerminatedString(Stream stream)
+        private static string ReadZeroTerminatedString(Stream stream)
         {
             byte[] buf1 = new byte[1];
             var list = new List<byte>();
@@ -113,8 +110,8 @@ namespace SharpCompress.Common.GZip
                 }
             }
             while (!done);
-            byte[] buffer = list.ToArray();
-            return ArchiveEncoding.Decode(buffer);
+            byte[] a = list.ToArray();
+            return ArchiveEncoding.Default.GetString(a, 0, a.Length);
         }
     }
 }

src/SharpCompress/Common/OptionsBase.cs

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

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

@@ -1,6 +1,6 @@
-using SharpCompress.IO;
 using System;
 using System.IO;
+using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers
 {
@@ -52,50 +52,50 @@ namespace SharpCompress.Common.Rar.Headers
             switch (HeaderType)
             {
                 case HeaderType.FileHeader:
+                {
+                    if (FileFlags.HasFlag(FileFlags.UNICODE))
                     {
-                        if (FileFlags.HasFlag(FileFlags.UNICODE))
+                        int length = 0;
+                        while (length < fileNameBytes.Length
+                               && fileNameBytes[length] != 0)
                         {
-                            int length = 0;
-                            while (length < fileNameBytes.Length
-                                   && fileNameBytes[length] != 0)
-                            {
-                                length++;
-                            }
-                            if (length != nameSize)
-                            {
-                                length++;
-                                FileName = FileNameDecoder.Decode(fileNameBytes, length);
-                            }
-                            else
-                            {
-                                FileName = ArchiveEncoding.Decode(fileNameBytes);
-                            }
+                            length++;
+                        }
+                        if (length != nameSize)
+                        {
+                            length++;
+                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
                         }
                         else
                         {
-                            FileName = ArchiveEncoding.Decode(fileNameBytes);
+                            FileName = DecodeDefault(fileNameBytes);
                         }
-                        FileName = ConvertPath(FileName, HostOS);
                     }
+                    else
+                    {
+                        FileName = DecodeDefault(fileNameBytes);
+                    }
+                    FileName = ConvertPath(FileName, HostOS);
+                }
                     break;
                 case HeaderType.NewSubHeader:
+                {
+                    int datasize = HeaderSize - NEWLHD_SIZE - nameSize;
+                    if (FileFlags.HasFlag(FileFlags.SALT))
                     {
-                        int datasize = HeaderSize - NEWLHD_SIZE - nameSize;
-                        if (FileFlags.HasFlag(FileFlags.SALT))
-                        {
-                            datasize -= SALT_SIZE;
-                        }
-                        if (datasize > 0)
-                        {
-                            SubData = reader.ReadBytes(datasize);
-                        }
-
-                        if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
-                        {
-                            RecoverySectors = SubData[8] + (SubData[9] << 8)
-                                              + (SubData[10] << 16) + (SubData[11] << 24);
-                        }
+                        datasize -= SALT_SIZE;
                     }
+                    if (datasize > 0)
+                    {
+                        SubData = reader.ReadBytes(datasize);
+                    }
+
+                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes))
+                    {
+                        RecoverySectors = SubData[8] + (SubData[9] << 8)
+                                          + (SubData[10] << 16) + (SubData[11] << 24);
+                    }
+                }
                     break;
             }
 
@@ -118,6 +118,12 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
+        //only the full .net framework will do other code pages than unicode/utf8
+        private string DecodeDefault(byte[] bytes)
+        {
+            return ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length);
+        }
+
         private long UInt32To64(uint x, uint y)
         {
             long l = x;
@@ -172,7 +178,6 @@ namespace SharpCompress.Common.Rar.Headers
         }
 
         internal long DataStartPosition { get; set; }
-
         internal HostOS HostOS { get; private set; }
 
         internal uint FileCRC { get; private set; }
@@ -194,7 +199,6 @@ namespace SharpCompress.Common.Rar.Headers
         internal FileFlags FileFlags => (FileFlags)Flags;
 
         internal long CompressedSize { get; private set; }
-
         internal long UncompressedSize { get; private set; }
 
         internal string FileName { get; private set; }

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

@@ -18,9 +18,9 @@ namespace SharpCompress.Common.Rar.Headers
                    Flags == 0x1A21 &&
                    HeaderSize == 0x07;
 
-            // Rar5 signature: 52 61 72 21 1A 07 01 00 (not supported yet)
+            // Rar5 signature: 52 61 72 21 1A 07 10 00 (not supported yet)
         }
 
         internal bool OldFormat { get; private set; }
     }
-}
+}

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

@@ -1,7 +1,6 @@
 using System;
 using System.IO;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Rar.Headers
 {
@@ -18,16 +17,14 @@ namespace SharpCompress.Common.Rar.Headers
             HeaderSize = baseHeader.HeaderSize;
             AdditionalSize = baseHeader.AdditionalSize;
             ReadBytes = baseHeader.ReadBytes;
-            ArchiveEncoding = baseHeader.ArchiveEncoding;
         }
 
-        internal static RarHeader Create(RarCrcBinaryReader reader, ArchiveEncoding archiveEncoding)
+        internal static RarHeader Create(RarCrcBinaryReader reader)
         {
             try
             {
                 RarHeader header = new RarHeader();
 
-                header.ArchiveEncoding = archiveEncoding;
                 reader.Mark();
                 header.ReadStartFromReader(reader);
                 header.ReadBytes += reader.CurrentReadByteCount;
@@ -53,8 +50,7 @@ namespace SharpCompress.Common.Rar.Headers
             }
         }
 
-        protected virtual void ReadFromReader(MarkingBinaryReader reader)
-        {
+        protected virtual void ReadFromReader(MarkingBinaryReader reader) {
             throw new NotImplementedException();
         }
 
@@ -80,11 +76,10 @@ namespace SharpCompress.Common.Rar.Headers
             return header;
         }
 
-        private void VerifyHeaderCrc(ushort crc)
-        {
-            if (HeaderType != HeaderType.MarkHeader)
+        private void VerifyHeaderCrc(ushort crc) {
+            if (HeaderType != HeaderType.MarkHeader) 
             {
-                if (crc != HeadCRC)
+                if (crc != HeadCRC) 
                 {
                     throw new InvalidFormatException("rar header crc mismatch");
                 }
@@ -111,8 +106,6 @@ namespace SharpCompress.Common.Rar.Headers
 
         protected short HeaderSize { get; private set; }
 
-        internal ArchiveEncoding ArchiveEncoding { get; private set; }
-
         /// <summary>
         /// This additional size of the header could be file data
         /// </summary>

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

@@ -117,7 +117,7 @@ namespace SharpCompress.Common.Rar.Headers
         {
 #if !NO_CRYPTO
             var reader = new RarCryptoBinaryReader(stream, Options.Password);
-
+            
             if (IsEncrypted)
             {
                 if (Options.Password == null)
@@ -133,7 +133,7 @@ namespace SharpCompress.Common.Rar.Headers
 
 #endif
 
-            RarHeader header = RarHeader.Create(reader, Options.ArchiveEncoding);
+            RarHeader header = RarHeader.Create(reader);
             if (header == null)
             {
                 return null;
@@ -141,110 +141,110 @@ namespace SharpCompress.Common.Rar.Headers
             switch (header.HeaderType)
             {
                 case HeaderType.ArchiveHeader:
-                    {
-                        var ah = header.PromoteHeader<ArchiveHeader>(reader);
-                        IsEncrypted = ah.HasPassword;
-                        return ah;
-                    }
+                {
+                    var ah = header.PromoteHeader<ArchiveHeader>(reader);
+                    IsEncrypted = ah.HasPassword;
+                    return ah;
+                }
                 case HeaderType.MarkHeader:
-                    {
-                        return header.PromoteHeader<MarkHeader>(reader);
-                    }
+                {
+                    return header.PromoteHeader<MarkHeader>(reader);
+                }
 
                 case HeaderType.ProtectHeader:
+                {
+                    ProtectHeader ph = header.PromoteHeader<ProtectHeader>(reader);
+
+                    // skip the recovery record data, we do not use it.
+                    switch (StreamingMode)
                     {
-                        ProtectHeader ph = header.PromoteHeader<ProtectHeader>(reader);
-
-                        // skip the recovery record data, we do not use it.
-                        switch (StreamingMode)
+                        case StreamingMode.Seekable:
                         {
-                            case StreamingMode.Seekable:
-                                {
-                                    reader.BaseStream.Position += ph.DataSize;
-                                }
-                                break;
-                            case StreamingMode.Streaming:
-                                {
-                                    reader.BaseStream.Skip(ph.DataSize);
-                                }
-                                break;
-                            default:
-                                {
-                                    throw new InvalidFormatException("Invalid StreamingMode");
-                                }
+                            reader.BaseStream.Position += ph.DataSize;
+                        }
+                            break;
+                        case StreamingMode.Streaming:
+                        {
+                            reader.BaseStream.Skip(ph.DataSize);
+                        }
+                            break;
+                        default:
+                        {
+                            throw new InvalidFormatException("Invalid StreamingMode");
                         }
-
-                        return ph;
                     }
 
+                    return ph;
+                }
+
                 case HeaderType.NewSubHeader:
+                {
+                    FileHeader fh = header.PromoteHeader<FileHeader>(reader);
+                    switch (StreamingMode)
                     {
-                        FileHeader fh = header.PromoteHeader<FileHeader>(reader);
-                        switch (StreamingMode)
+                        case StreamingMode.Seekable:
                         {
-                            case StreamingMode.Seekable:
-                                {
-                                    fh.DataStartPosition = reader.BaseStream.Position;
-                                    reader.BaseStream.Position += fh.CompressedSize;
-                                }
-                                break;
-                            case StreamingMode.Streaming:
-                                {
-                                    //skip the data because it's useless?
-                                    reader.BaseStream.Skip(fh.CompressedSize);
-                                }
-                                break;
-                            default:
-                                {
-                                    throw new InvalidFormatException("Invalid StreamingMode");
-                                }
+                            fh.DataStartPosition = reader.BaseStream.Position;
+                            reader.BaseStream.Position += fh.CompressedSize;
                         }
-                        return fh;
-                    }
-                case HeaderType.FileHeader:
-                    {
-                        FileHeader fh = header.PromoteHeader<FileHeader>(reader);
-                        switch (StreamingMode)
+                            break;
+                        case StreamingMode.Streaming:
                         {
-                            case StreamingMode.Seekable:
-                                {
-                                    fh.DataStartPosition = reader.BaseStream.Position;
-                                    reader.BaseStream.Position += fh.CompressedSize;
-                                }
-                                break;
-                            case StreamingMode.Streaming:
-                                {
-                                    var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                                    if (fh.Salt == null)
-                                    {
-                                        fh.PackedStream = ms;
-                                    }
-                                    else
-                                    {
+                            //skip the data because it's useless?
+                            reader.BaseStream.Skip(fh.CompressedSize);
+                        }
+                            break;
+                        default:
+                        {
+                            throw new InvalidFormatException("Invalid StreamingMode");
+                        }
+                    }
+                    return fh;
+                }
+                case HeaderType.FileHeader:
+                {
+                    FileHeader fh = header.PromoteHeader<FileHeader>(reader);
+                    switch (StreamingMode)
+                    {
+                        case StreamingMode.Seekable:
+                        {
+                            fh.DataStartPosition = reader.BaseStream.Position;
+                            reader.BaseStream.Position += fh.CompressedSize;
+                        }
+                            break;
+                        case StreamingMode.Streaming:
+                        {
+                            var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
+                            if (fh.Salt == null)
+                            {
+                                fh.PackedStream = ms;
+                            }
+                            else
+                            {
 #if !NO_CRYPTO
-                                        fh.PackedStream = new RarCryptoWrapper(ms, Options.Password, fh.Salt);
+                                fh.PackedStream = new RarCryptoWrapper(ms, Options.Password,  fh.Salt);
 #else
                                 throw new NotSupportedException("RarCrypto not supported");
 #endif
-                                    }
-                                }
-                                break;
-                            default:
-                                {
-                                    throw new InvalidFormatException("Invalid StreamingMode");
-                                }
+                            }
+                        }
+                            break;
+                        default:
+                        {
+                            throw new InvalidFormatException("Invalid StreamingMode");
                         }
-                        return fh;
                     }
+                    return fh;
+                }
                 case HeaderType.EndArchiveHeader:
-                    {
-                        return header.PromoteHeader<EndArchiveHeader>(reader);
-                    }
+                {
+                    return header.PromoteHeader<EndArchiveHeader>(reader);
+                }
                 default:
-                    {
-                        throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType);
-                    }
+                {
+                    throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType);
+                }
             }
         }
     }
-}
+}

src/SharpCompress/Common/Rar/RarFilePart.cs

@@ -9,7 +9,6 @@ namespace SharpCompress.Common.Rar
     internal abstract class RarFilePart : FilePart
     {
         internal RarFilePart(MarkHeader mh, FileHeader fh)
-            : base(fh.ArchiveEncoding)
         {
             MarkHeader = mh;
             FileHeader = fh;

src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs

@@ -22,13 +22,6 @@ 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)
-        {
-            PasswordProvider = passwordProvider;
-        }
 
         internal void Clear()
         {

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -182,7 +182,7 @@ namespace SharpCompress.Common.SevenZip
 
         private DateTime? TranslateTime(long? time)
         {
-            if (time.HasValue && time.Value >= 0 && time.Value <= 2650467743999999999) //maximum Windows file time 31.12.9999
+            if (time.HasValue)
             {
                 return TranslateTime(time.Value);
             }
@@ -1211,7 +1211,7 @@ namespace SharpCompress.Common.SevenZip
 
         public ArchiveDatabase ReadDatabase(IPasswordProvider pass)
         {
-            var db = new ArchiveDatabase(pass);
+            var db = new ArchiveDatabase();
             db.Clear();
 
             db.MajorVersion = _header[6];
@@ -1279,7 +1279,7 @@ namespace SharpCompress.Common.SevenZip
                         throw new InvalidOperationException();
                     }
 
-                    var dataVector = ReadAndDecodePackedStreams(db.StartPositionAfterHeader, db.PasswordProvider);
+                    var dataVector = ReadAndDecodePackedStreams(db.StartPositionAfterHeader, pass);
 
                     // compressed header without content is odd but ok
                     if (dataVector.Count == 0)
@@ -1301,7 +1301,7 @@ namespace SharpCompress.Common.SevenZip
                     }
                 }
 
-                ReadHeader(db, db.PasswordProvider);
+                ReadHeader(db, pass);
             }
             db.Fill();
             return db;
@@ -1441,7 +1441,7 @@ namespace SharpCompress.Common.SevenZip
             #endregion
         }
 
-        private Stream GetCachedDecoderStream(ArchiveDatabase _db, int folderIndex)
+        private Stream GetCachedDecoderStream(ArchiveDatabase _db, int folderIndex, IPasswordProvider pw)
         {
             Stream s;
             if (!_cachedStreams.TryGetValue(folderIndex, out s))
@@ -1456,13 +1456,13 @@ namespace SharpCompress.Common.SevenZip
                 }
 
                 s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
-                                                            _db.PasswordProvider);
+                                                            pw);
                 _cachedStreams.Add(folderIndex, s);
             }
             return s;
         }
 
-        public Stream OpenStream(ArchiveDatabase _db, int fileIndex)
+        public Stream OpenStream(ArchiveDatabase _db, int fileIndex, IPasswordProvider pw)
         {
             int folderIndex = _db.FileIndexToFolderIndexMap[fileIndex];
             int numFilesInFolder = _db.NumUnpackStreamsVector[folderIndex];
@@ -1479,12 +1479,12 @@ namespace SharpCompress.Common.SevenZip
                 skipSize += _db.Files[firstFileIndex + i].Size;
             }
 
-            Stream s = GetCachedDecoderStream(_db, folderIndex);
+            Stream s = GetCachedDecoderStream(_db, folderIndex, pw);
             s.Position = skipSize;
             return new ReadOnlySubStream(s, _db.Files[fileIndex].Size);
         }
 
-        public void Extract(ArchiveDatabase _db, int[] indices)
+        public void Extract(ArchiveDatabase _db, int[] indices, IPasswordProvider pw)
         {
             int numItems;
             bool allFilesMode = (indices == null);
@@ -1562,7 +1562,7 @@ namespace SharpCompress.Common.SevenZip
                 // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?
 
                 Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
-                                                                   folderInfo, _db.PasswordProvider);
+                                                                   folderInfo, pw);
                 byte[] buffer = new byte[4 << 10];
                 for (;;)
                 {
@@ -1588,4 +1588,4 @@ namespace SharpCompress.Common.SevenZip
 
         #endregion
     }
-}
+}

src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs

@@ -7,15 +7,14 @@ namespace SharpCompress.Common.SevenZip
 {
     internal class SevenZipFilePart : FilePart
     {
-        private CompressionType? _type;
-        private readonly Stream _stream;
-        private readonly ArchiveDatabase _database;
+        private CompressionType? type;
+        private readonly Stream stream;
+        private readonly ArchiveDatabase database;
 
-        internal SevenZipFilePart(Stream stream, ArchiveDatabase database, int index, CFileItem fileEntry, ArchiveEncoding archiveEncoding)
-           : base(archiveEncoding)
+        internal SevenZipFilePart(Stream stream, ArchiveDatabase database, int index, CFileItem fileEntry)
         {
-            this._stream = stream;
-            this._database = database;
+            this.stream = stream;
+            this.database = database;
             Index = index;
             Header = fileEntry;
             if (Header.HasStream)
@@ -42,14 +41,14 @@ namespace SharpCompress.Common.SevenZip
             {
                 return null;
             }
-            var folderStream = _database.GetFolderStream(_stream, Folder, _database.PasswordProvider);
+            var folderStream = database.GetFolderStream(stream, Folder, null);
 
-            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++)
             {
-                skipSize += _database.Files[firstFileIndex + i].Size;
+                skipSize += database.Files[firstFileIndex + i].Size;
             }
             if (skipSize > 0)
             {
@@ -62,11 +61,11 @@ namespace SharpCompress.Common.SevenZip
         {
             get
             {
-                if (_type == null)
+                if (type == null)
                 {
-                    _type = GetCompression();
+                    type = GetCompression();
                 }
-                return _type.Value;
+                return type.Value;
             }
         }
 
@@ -85,7 +84,7 @@ namespace SharpCompress.Common.SevenZip
         {
             var coder = Folder.Coders.First();
             switch (coder.MethodId.Id)
-            {                
+            {
                 case k_LZMA:
                 case k_LZMA2:
                 {

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

@@ -9,11 +9,6 @@ namespace SharpCompress.Common.Tar.Headers
     {
         internal static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
-        public TarHeader(ArchiveEncoding archiveEncoding)
-        {
-            ArchiveEncoding = archiveEncoding;
-        }
-
         internal string Name { get; set; }
 
         //internal int Mode { get; set; }
@@ -25,7 +20,6 @@ namespace SharpCompress.Common.Tar.Headers
         internal DateTime LastModifiedTime { get; set; }
         internal EntryType EntryType { get; set; }
         internal Stream PackedStream { get; set; }
-        internal ArchiveEncoding ArchiveEncoding { get; }
 
         internal const int BlockSize = 512;
 
@@ -37,7 +31,7 @@ namespace SharpCompress.Common.Tar.Headers
             WriteOctalBytes(0, buffer, 108, 8); // owner ID
             WriteOctalBytes(0, buffer, 116, 8); // group ID
 
-            //ArchiveEncoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
+            //Encoding.UTF8.GetBytes("magic").CopyTo(buffer, 257);
             if (Name.Length > 100)
             {
                 // Set mock filename and filetype to indicate the next block is the actual name of the file
@@ -78,7 +72,7 @@ namespace SharpCompress.Common.Tar.Headers
 
         private void WriteLongFilenameHeader(Stream output)
         {
-            byte[] nameBytes = ArchiveEncoding.Encode(Name);
+            byte[] nameBytes = ArchiveEncoding.Default.GetBytes(Name);
             output.Write(nameBytes, 0, nameBytes.Length);
 
             // pad to multiple of BlockSize bytes, and make sure a terminating null is added
@@ -105,7 +99,7 @@ namespace SharpCompress.Common.Tar.Headers
             }
             else
             {
-                Name = ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
+                Name = ArchiveEncoding.Default.GetString(buffer, 0, 100).TrimNulls();
             }
 
             EntryType = ReadEntryType(buffer);
@@ -117,12 +111,12 @@ namespace SharpCompress.Common.Tar.Headers
             long unixTimeStamp = ReadASCIIInt64Base8(buffer, 136, 11);
             LastModifiedTime = Epoch.AddSeconds(unixTimeStamp).ToLocalTime();
 
-            Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();
+            Magic = ArchiveEncoding.Default.GetString(buffer, 257, 6).TrimNulls();
 
             if (!string.IsNullOrEmpty(Magic)
                 && "ustar".Equals(Magic))
             {
-                string namePrefix = ArchiveEncoding.Decode(buffer, 345, 157);
+                string namePrefix = ArchiveEncoding.Default.GetString(buffer, 345, 157);
                 namePrefix = namePrefix.TrimNulls();
                 if (!string.IsNullOrEmpty(namePrefix))
                 {
@@ -149,7 +143,7 @@ namespace SharpCompress.Common.Tar.Headers
             {
                 reader.ReadBytes(remainingBytesToRead);
             }
-            return ArchiveEncoding.Decode(nameBytes, 0, nameBytes.Length).TrimNulls();
+            return ArchiveEncoding.Default.GetString(nameBytes, 0, nameBytes.Length).TrimNulls();
         }
 
         private static EntryType ReadEntryType(byte[] buffer)

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Tar
 {
@@ -44,9 +43,9 @@ namespace SharpCompress.Common.Tar
         internal override IEnumerable<FilePart> Parts => filePart.AsEnumerable<FilePart>();
 
         internal static IEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,
-                                                         CompressionType compressionType, ArchiveEncoding archiveEncoding)
+                                                         CompressionType compressionType)
         {
-            foreach (TarHeader h in TarHeaderFactory.ReadHeader(mode, stream, archiveEncoding))
+            foreach (TarHeader h in TarHeaderFactory.ReadHeader(mode, stream))
             {
                 if (h != null)
                 {

src/SharpCompress/Common/Tar/TarFilePart.cs

@@ -6,12 +6,11 @@ namespace SharpCompress.Common.Tar
 {
     internal class TarFilePart : FilePart
     {
-        private readonly Stream _seekableStream;
+        private readonly Stream seekableStream;
 
         internal TarFilePart(TarHeader header, Stream seekableStream)
-            : base(header.ArchiveEncoding)
         {
-            this._seekableStream = seekableStream;
+            this.seekableStream = seekableStream;
             Header = header;
         }
 
@@ -21,10 +20,10 @@ namespace SharpCompress.Common.Tar
 
         internal override Stream GetCompressedStream()
         {
-            if (_seekableStream != null)
+            if (seekableStream != null)
             {
-                _seekableStream.Position = Header.DataStartPosition.Value;
-                return new ReadOnlySubStream(_seekableStream, Header.Size);
+                seekableStream.Position = Header.DataStartPosition.Value;
+                return new ReadOnlySubStream(seekableStream, Header.Size);
             }
             return Header.PackedStream;
         }

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -2,13 +2,12 @@
 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)
         {
             while (true)
             {
@@ -16,8 +15,7 @@ namespace SharpCompress.Common.Tar
                 try
                 {
                     BinaryReader reader = new BinaryReader(stream);
-                    header = new TarHeader(archiveEncoding);
-
+                    header = new TarHeader();
                     if (!header.Read(reader))
                     {
                         yield break;
@@ -25,22 +23,22 @@ namespace SharpCompress.Common.Tar
                     switch (mode)
                     {
                         case StreamingMode.Seekable:
-                            {
-                                header.DataStartPosition = reader.BaseStream.Position;
+                        {
+                            header.DataStartPosition = reader.BaseStream.Position;
 
-                                //skip to nearest 512
-                                reader.BaseStream.Position += PadTo512(header.Size);
-                            }
+                            //skip to nearest 512
+                            reader.BaseStream.Position += PadTo512(header.Size);
+                        }
                             break;
                         case StreamingMode.Streaming:
-                            {
-                                header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
-                            }
+                        {
+                            header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
+                        }
                             break;
                         default:
-                            {
-                                throw new InvalidFormatException("Invalid StreamingMode");
-                            }
+                        {
+                            throw new InvalidFormatException("Invalid StreamingMode");
+                        }
                     }
                 }
                 catch

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

@@ -6,8 +6,8 @@ namespace SharpCompress.Common.Zip.Headers
 {
     internal class DirectoryEntryHeader : ZipFileEntry
     {
-        public DirectoryEntryHeader(ArchiveEncoding archiveEncoding)
-            : base(ZipHeaderType.DirectoryEntry, archiveEncoding)
+        public DirectoryEntryHeader()
+            : base(ZipHeaderType.DirectoryEntry)
         {
         }
 
@@ -31,10 +31,10 @@ namespace SharpCompress.Common.Zip.Headers
             RelativeOffsetOfEntryHeader = reader.ReadUInt32();
 
             byte[] name = reader.ReadBytes(nameLength);
-            Name = ArchiveEncoding.Decode(name);
+            Name = DecodeString(name);
             byte[] extra = reader.ReadBytes(extraLength);
             byte[] comment = reader.ReadBytes(commentLength);
-            Comment = ArchiveEncoding.Decode(comment);
+            Comment = DecodeString(comment);
             LoadExtra(extra);
 
             var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);

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

@@ -5,7 +5,6 @@ namespace SharpCompress.Common.Zip.Headers
     [Flags]
     internal enum HeaderFlags : ushort
     {
-        None = 0,
         Encrypted = 1, // http://www.pkware.com/documents/casestudies/APPNOTE.TXT
         Bit1 = 2,
         Bit2 = 4,

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

@@ -1,13 +1,12 @@
 using System.IO;
 using System.Linq;
-using System.Text;
 
 namespace SharpCompress.Common.Zip.Headers
 {
     internal class LocalEntryHeader : ZipFileEntry
     {
-        public LocalEntryHeader(ArchiveEncoding archiveEncoding)
-            : base(ZipHeaderType.LocalEntry, archiveEncoding)
+        public LocalEntryHeader()
+            : base(ZipHeaderType.LocalEntry)
         {
         }
 
@@ -25,7 +24,7 @@ namespace SharpCompress.Common.Zip.Headers
             ushort extraLength = reader.ReadUInt16();
             byte[] name = reader.ReadBytes(nameLength);
             byte[] extra = reader.ReadBytes(extraLength);
-            Name = ArchiveEncoding.Decode(name);
+            Name = DecodeString(name);
             LoadExtra(extra);
 
             var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);

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

@@ -8,11 +8,10 @@ namespace SharpCompress.Common.Zip.Headers
 {
     internal abstract class ZipFileEntry : ZipHeader
     {
-        protected ZipFileEntry(ZipHeaderType type, ArchiveEncoding archiveEncoding)
+        protected ZipFileEntry(ZipHeaderType type)
             : base(type)
         {
             Extra = new List<ExtraData>();
-            ArchiveEncoding = archiveEncoding;
         }
 
         internal bool IsDirectory
@@ -30,10 +29,27 @@ namespace SharpCompress.Common.Zip.Headers
                        && Name.EndsWith("\\");
             }
         }
-        
-        internal Stream PackedStream { get; set; }
 
-        internal ArchiveEncoding ArchiveEncoding { get; }
+        protected string DecodeString(byte[] str)
+        {
+            if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
+            {
+                return Encoding.UTF8.GetString(str, 0, str.Length);
+            }
+
+            return ArchiveEncoding.Default.GetString(str, 0, str.Length);
+        }
+
+        protected byte[] EncodeString(string str)
+        {
+            if (FlagUtility.HasFlag(Flags, HeaderFlags.UTF8))
+            {
+                return Encoding.UTF8.GetBytes(str);
+            }
+            return ArchiveEncoding.Default.GetBytes(str);
+        }
+
+        internal Stream PackedStream { get; set; }
 
         internal string Name { get; set; }
 
@@ -48,7 +64,7 @@ namespace SharpCompress.Common.Zip.Headers
         internal long UncompressedSize { get; set; }
 
         internal List<ExtraData> Extra { get; set; }
-
+        
         public string Password { get; set; }
 
         internal PkwareTraditionalEncryptionData ComposeEncryptionData(Stream archiveStream)
@@ -59,10 +75,10 @@ namespace SharpCompress.Common.Zip.Headers
             }
 
             var buffer = new byte[12];
-            archiveStream.ReadFully(buffer);
+            archiveStream.Read(buffer, 0, 12);
 
             PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password, this, buffer);
-
+            
             return encryptionData;
         }
 

src/SharpCompress/Common/Zip/PkwareTraditionalCryptoStream.cs

@@ -42,7 +42,7 @@ namespace SharpCompress.Common.Zip
 
             if (buffer == null)
             {
-                throw new ArgumentNullException(nameof(buffer));
+                throw new ArgumentNullException("buffer");
             }
 
             byte[] temp = new byte[count];

src/SharpCompress/Common/Zip/PkwareTraditionalEncryptionData.cs

@@ -9,11 +9,9 @@ namespace SharpCompress.Common.Zip
     {
         private static readonly CRC32 crc32 = new CRC32();
         private readonly UInt32[] _Keys = {0x12345678, 0x23456789, 0x34567890};
-        private readonly ArchiveEncoding _archiveEncoding;
 
-        private PkwareTraditionalEncryptionData(string password, ArchiveEncoding archiveEncoding)
+        private PkwareTraditionalEncryptionData(string password)
         {
-            _archiveEncoding = archiveEncoding;
             Initialize(password);
         }
 
@@ -29,7 +27,7 @@ namespace SharpCompress.Common.Zip
         public static PkwareTraditionalEncryptionData ForRead(string password, ZipFileEntry header,
                                                               byte[] encryptionHeader)
         {
-            var encryptor = new PkwareTraditionalEncryptionData(password, header.ArchiveEncoding);
+            var encryptor = new PkwareTraditionalEncryptionData(password);
             byte[] plainTextHeader = encryptor.Decrypt(encryptionHeader, encryptionHeader.Length);
             if (plainTextHeader[11] != (byte)((header.Crc >> 24) & 0xff))
             {
@@ -49,7 +47,7 @@ namespace SharpCompress.Common.Zip
         {
             if (length > cipherText.Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(length),
+                throw new ArgumentOutOfRangeException("length",
                                                       "Bad length during Decryption: the length parameter must be smaller than or equal to the size of the destination array.");
             }
 
@@ -72,7 +70,7 @@ namespace SharpCompress.Common.Zip
 
             if (length > plainText.Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(length),
+                throw new ArgumentOutOfRangeException("length",
                                                       "Bad length during Encryption: The length parameter must be smaller than or equal to the size of the destination array.");
             }
 
@@ -95,12 +93,17 @@ namespace SharpCompress.Common.Zip
             }
         }
 
-        internal byte[] StringToByteArray(string value)
+        internal static byte[] StringToByteArray(string value, Encoding encoding)
         {
-            byte[] a = _archiveEncoding.Password.GetBytes(value);
+            byte[] a = encoding.GetBytes(value);
             return a;
         }
 
+        internal static byte[] StringToByteArray(string value)
+        {
+            return StringToByteArray(value, ArchiveEncoding.Password);
+        }
+
         private void UpdateKeys(byte byteValue)
         {
             _Keys[0] = (UInt32)crc32.ComputeCrc32((int)_Keys[0], byteValue);

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -5,21 +5,21 @@ namespace SharpCompress.Common.Zip
 {
     internal class SeekableZipFilePart : ZipFilePart
     {
-        private bool _isLocalHeaderLoaded;
-        private readonly SeekableZipHeaderFactory _headerFactory;
+        private bool isLocalHeaderLoaded;
+        private readonly SeekableZipHeaderFactory headerFactory;
 
         internal SeekableZipFilePart(SeekableZipHeaderFactory headerFactory, DirectoryEntryHeader header, Stream stream)
             : base(header, stream)
         {
-            this._headerFactory = headerFactory;
+            this.headerFactory = headerFactory;
         }
 
         internal override Stream GetCompressedStream()
         {
-            if (!_isLocalHeaderLoaded)
+            if (!isLocalHeaderLoaded)
             {
                 LoadLocalHeader();
-                _isLocalHeaderLoaded = true;
+                isLocalHeaderLoaded = true;
             }
             return base.GetCompressedStream();
         }
@@ -29,7 +29,7 @@ namespace SharpCompress.Common.Zip
         private void LoadLocalHeader()
         {
             bool hasData = Header.HasData;
-            Header = _headerFactory.GetLocalHeader(BaseStream, Header as DirectoryEntryHeader);
+            Header = headerFactory.GetLocalHeader(BaseStream, Header as DirectoryEntryHeader);
             Header.HasData = hasData;
         }
 

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -3,17 +3,16 @@ 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
     {
         private const int MAX_ITERATIONS_FOR_DIRECTORY_HEADER = 4096;
-        private bool _zip64;
+        private bool zip64;
 
-        internal SeekableZipHeaderFactory(string password, ArchiveEncoding archiveEncoding)
-            : base(StreamingMode.Seekable, password, archiveEncoding)
+        internal SeekableZipHeaderFactory(string password)
+            : base(StreamingMode.Seekable, password)
         {
         }
 
@@ -27,14 +26,14 @@ namespace SharpCompress.Common.Zip
 
             if (entry.IsZip64)
             {
-                _zip64 = true;
+                zip64 = true;
                 SeekBackToHeader(stream, reader, ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR);
                 var zip64Locator = new Zip64DirectoryEndLocatorHeader();
                 zip64Locator.Read(reader);
 
                 stream.Seek(zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord, SeekOrigin.Begin);
                 uint zip64Signature = reader.ReadUInt32();
-                if (zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
+                if(zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
                     throw new ArchiveException("Failed to locate the Zip64 Header");
 
                 var zip64Entry = new Zip64DirectoryEndHeader();
@@ -51,7 +50,7 @@ namespace SharpCompress.Common.Zip
             {
                 stream.Position = position;
                 uint signature = reader.ReadUInt32();
-                var directoryEntryHeader = ReadHeader(signature, reader, _zip64) as DirectoryEntryHeader;
+                var directoryEntryHeader = ReadHeader(signature, reader, zip64) as DirectoryEntryHeader;
                 position = stream.Position;
                 if (directoryEntryHeader == null)
                 {
@@ -92,7 +91,7 @@ namespace SharpCompress.Common.Zip
             stream.Seek(directoryEntryHeader.RelativeOffsetOfEntryHeader, SeekOrigin.Begin);
             BinaryReader reader = new BinaryReader(stream);
             uint signature = reader.ReadUInt32();
-            var localEntryHeader = ReadHeader(signature, reader, _zip64) as LocalEntryHeader;
+            var localEntryHeader = ReadHeader(signature, reader, zip64) as LocalEntryHeader;
             if (localEntryHeader == null)
             {
                 throw new InvalidOperationException();

src/SharpCompress/Common/Zip/StreamingZipFilePart.cs

@@ -39,20 +39,19 @@ namespace SharpCompress.Common.Zip
             {
                 return new BinaryReader(rewindableStream);
             }
-            if (Header.HasData && !Skipped)
+            if (Header.HasData)
             {
                 if (decompressionStream == null)
                 {
                     decompressionStream = GetCompressedStream();
                 }
-                decompressionStream.Skip();
+                decompressionStream.SkipAll();
 
                 DeflateStream deflateStream = decompressionStream as DeflateStream;
                 if (deflateStream != null)
                 {
                     rewindableStream.Rewind(deflateStream.InputBuffer);
                 }
-                Skipped = true;
             }
             var reader = new BinaryReader(rewindableStream);
             decompressionStream = null;

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -2,14 +2,13 @@
 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)
-            : base(StreamingMode.Streaming, password, archiveEncoding)
+        internal StreamingZipHeaderFactory(string password)
+            : base(StreamingMode.Streaming, password)
         {
         }
 

src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs

@@ -78,7 +78,7 @@ namespace SharpCompress.Common.Zip
             {
                 //read out last 10 auth bytes
                 var ten = new byte[10];
-                stream.ReadFully(ten);
+                stream.Read(ten, 0, 10);
                 stream.Dispose();
             }
         }

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -15,7 +15,6 @@ namespace SharpCompress.Common.Zip
     internal abstract class ZipFilePart : FilePart
     {
         internal ZipFilePart(ZipFileEntry header, Stream stream)
-        : base(header.ArchiveEncoding)
         {
             Header = header;
             header.Part = this;
@@ -89,7 +88,7 @@ namespace SharpCompress.Common.Zip
                 case ZipCompressionMethod.PPMd:
                 {
                     var props = new byte[2];
-                    stream.ReadFully(props);
+                    stream.Read(props, 0, props.Length);
                     return new PpmdStream(new PpmdProperties(props), stream, false);
                 }
                 case ZipCompressionMethod.WinzipAes:
@@ -176,6 +175,7 @@ namespace SharpCompress.Common.Zip
 
                 }
             }
+
             return plainStream;
         }
     }

src/SharpCompress/Common/Zip/ZipHeaderFactory.cs

@@ -5,7 +5,6 @@ using System.Linq;
 #endif
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
-using System.Text;
 
 namespace SharpCompress.Common.Zip
 {
@@ -24,13 +23,11 @@ namespace SharpCompress.Common.Zip
         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)
         {
             this.mode = mode;
             this.password = password;
-            this.archiveEncoding = archiveEncoding;
         }
 
         protected ZipHeader ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
@@ -39,7 +36,7 @@ namespace SharpCompress.Common.Zip
             {
                 case ENTRY_HEADER_BYTES:
                 {
-                    var entryHeader = new LocalEntryHeader(archiveEncoding);
+                    var entryHeader = new LocalEntryHeader();
                     entryHeader.Read(reader);
                     LoadHeader(entryHeader, reader.BaseStream);
 
@@ -48,48 +45,48 @@ namespace SharpCompress.Common.Zip
                 }
                 case DIRECTORY_START_HEADER_BYTES:
                 {
-                    var entry = new DirectoryEntryHeader(archiveEncoding);
+                    var entry = new DirectoryEntryHeader();
                     entry.Read(reader);
                     return entry;
                 }
                 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();
-                            lastEntryHeader.UncompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
-                        }
-                        else
-                        {
-                            reader.ReadBytes(zip64 ? 20 : 12);
-                        }
-                        return null;
+                        lastEntryHeader.Crc = reader.ReadUInt32();
+                        lastEntryHeader.CompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
+                        lastEntryHeader.UncompressedSize = zip64 ? (long)reader.ReadUInt64() : reader.ReadUInt32();
                     }
+                    else
+                    {
+                        reader.ReadBytes(zip64 ? 20 : 12);
+                    }
+                    return null;
+                }
                 case DIGITAL_SIGNATURE:
                     return null;
                 case DIRECTORY_END_HEADER_BYTES:
-                    {
-                        var entry = new DirectoryEndHeader();
-                        entry.Read(reader);
-                        return entry;
-                    }
+                {
+                    var entry = new DirectoryEndHeader();
+                    entry.Read(reader);
+                    return entry;
+                }
                 case SPLIT_ARCHIVE_HEADER_BYTES:
-                    {
-                        return new SplitHeader();
-                    }
+                {
+                    return new SplitHeader();
+                }
                 case ZIP64_END_OF_CENTRAL_DIRECTORY:
-                    {
-                        var entry = new Zip64DirectoryEndHeader();
-                        entry.Read(reader);
-                        return entry;
-                    }
+                {
+                    var entry = new Zip64DirectoryEndHeader();
+                    entry.Read(reader);
+                    return entry;
+                }
                 case ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR:
-                    {
-                        var entry = new Zip64DirectoryEndLocatorHeader();
-                        entry.Read(reader);
-                        return entry;
-                    }
+                {
+                    var entry = new Zip64DirectoryEndLocatorHeader();
+                    entry.Read(reader);
+                    return entry;
+                }
                 default:
                     throw new NotSupportedException("Unknown header: " + headerBytes);
             }
@@ -168,22 +165,22 @@ namespace SharpCompress.Common.Zip
             switch (mode)
             {
                 case StreamingMode.Seekable:
-                    {
-                        entryHeader.DataStartPosition = stream.Position;
-                        stream.Position += entryHeader.CompressedSize;
-                        break;
-                    }
+                {
+                    entryHeader.DataStartPosition = stream.Position;
+                    stream.Position += entryHeader.CompressedSize;
+                    break;
+                }
 
                 case StreamingMode.Streaming:
-                    {
-                        entryHeader.PackedStream = stream;
-                        break;
-                    }
+                {
+                    entryHeader.PackedStream = stream;
+                    break;
+                }
 
                 default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
+                {
+                    throw new InvalidFormatException("Invalid StreamingMode");
+                }
             }
 
             //}

src/SharpCompress/Compressors/ADC/ADCStream.cs

@@ -105,19 +105,19 @@ namespace SharpCompress.Compressors.ADC
             }
             if (buffer == null)
             {
-                throw new ArgumentNullException(nameof(buffer));
+                throw new ArgumentNullException("buffer");
             }
             if (count < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(count));
+                throw new ArgumentOutOfRangeException("count");
             }
             if (offset < buffer.GetLowerBound(0))
             {
-                throw new ArgumentOutOfRangeException(nameof(offset));
+                throw new ArgumentOutOfRangeException("offset");
             }
             if ((offset + count) > buffer.GetLength(0))
             {
-                throw new ArgumentOutOfRangeException(nameof(count));
+                throw new ArgumentOutOfRangeException("count");
             }
 
             int size = -1;

src/SharpCompress/Compressors/Deflate/DeflateStream.cs

@@ -26,7 +26,6 @@
 
 using System;
 using System.IO;
-using System.Text;
 
 namespace SharpCompress.Compressors.Deflate
 {
@@ -37,10 +36,9 @@ namespace SharpCompress.Compressors.Deflate
 
         public DeflateStream(Stream stream, CompressionMode mode,
                              CompressionLevel level = CompressionLevel.Default,
-                             bool leaveOpen = false,
-                             Encoding forceEncoding = null)
+                             bool leaveOpen = false)
         {
-            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen, forceEncoding);
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.DEFLATE, leaveOpen);
         }
 
         #region Zlib properties

src/SharpCompress/Compressors/Deflate/GZipStream.cs

@@ -30,45 +30,41 @@ using System;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.Converters;
-using System.Text;
 
 namespace SharpCompress.Compressors.Deflate
 {
     public class GZipStream : Stream
     {
-        internal static readonly DateTime UNIX_EPOCH = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        internal static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
         public DateTime? LastModified { get; set; }
 
-        private string _comment;
-        private string _fileName;
+        private string comment;
+        private string fileName;
 
         internal ZlibBaseStream BaseStream;
-        private bool _disposed;
-        private bool _firstReadDone;
-        private int _headerByteCount;
-
-        private readonly Encoding _encoding;
+        private bool disposed;
+        private bool firstReadDone;
+        private int headerByteCount;
 
         public GZipStream(Stream stream, CompressionMode mode)
-            : this(stream, mode, CompressionLevel.Default, false, Encoding.UTF8)
+            : this(stream, mode, CompressionLevel.Default, false)
         {
         }
 
         public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level)
-            : this(stream, mode, level, false, Encoding.UTF8)
+            : this(stream, mode, level, false)
         {
         }
 
         public GZipStream(Stream stream, CompressionMode mode, bool leaveOpen)
-            : this(stream, mode, CompressionLevel.Default, leaveOpen, Encoding.UTF8)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
         {
         }
 
-        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen, Encoding encoding)
+        public GZipStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
         {
-            BaseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen, encoding);
-            _encoding = encoding;
+            BaseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.GZIP, leaveOpen);
         }
 
         #region Zlib properties
@@ -78,7 +74,7 @@ namespace SharpCompress.Compressors.Deflate
             get => (BaseStream._flushMode);
             set
             {
-                if (_disposed)
+                if (disposed)
                 {
                     throw new ObjectDisposedException("GZipStream");
                 }
@@ -91,7 +87,7 @@ namespace SharpCompress.Compressors.Deflate
             get => BaseStream._bufferSize;
             set
             {
-                if (_disposed)
+                if (disposed)
                 {
                     throw new ObjectDisposedException("GZipStream");
                 }
@@ -127,7 +123,7 @@ namespace SharpCompress.Compressors.Deflate
         {
             get
             {
-                if (_disposed)
+                if (disposed)
                 {
                     throw new ObjectDisposedException("GZipStream");
                 }
@@ -153,7 +149,7 @@ namespace SharpCompress.Compressors.Deflate
         {
             get
             {
-                if (_disposed)
+                if (disposed)
                 {
                     throw new ObjectDisposedException("GZipStream");
                 }
@@ -183,7 +179,7 @@ namespace SharpCompress.Compressors.Deflate
             {
                 if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Writer)
                 {
-                    return BaseStream._z.TotalBytesOut + _headerByteCount;
+                    return BaseStream._z.TotalBytesOut + headerByteCount;
                 }
                 if (BaseStream._streamMode == ZlibBaseStream.StreamMode.Reader)
                 {
@@ -206,14 +202,14 @@ namespace SharpCompress.Compressors.Deflate
         {
             try
             {
-                if (!_disposed)
+                if (!disposed)
                 {
                     if (disposing && (BaseStream != null))
                     {
                         BaseStream.Dispose();
                         Crc32 = BaseStream.Crc32;
                     }
-                    _disposed = true;
+                    disposed = true;
                 }
             }
             finally
@@ -227,7 +223,7 @@ namespace SharpCompress.Compressors.Deflate
         /// </summary>
         public override void Flush()
         {
-            if (_disposed)
+            if (disposed)
             {
                 throw new ObjectDisposedException("GZipStream");
             }
@@ -267,7 +263,7 @@ namespace SharpCompress.Compressors.Deflate
         /// <returns>the number of bytes actually read</returns>
         public override int Read(byte[] buffer, int offset, int count)
         {
-            if (_disposed)
+            if (disposed)
             {
                 throw new ObjectDisposedException("GZipStream");
             }
@@ -276,9 +272,9 @@ namespace SharpCompress.Compressors.Deflate
             // Console.WriteLine("GZipStream::Read(buffer, off({0}), c({1}) = {2}", offset, count, n);
             // Console.WriteLine( Util.FormatByteArray(buffer, offset, n) );
 
-            if (!_firstReadDone)
+            if (!firstReadDone)
             {
-                _firstReadDone = true;
+                firstReadDone = true;
                 FileName = BaseStream._GzipFileName;
                 Comment = BaseStream._GzipComment;
             }
@@ -329,7 +325,7 @@ namespace SharpCompress.Compressors.Deflate
         /// <param name="count">the number of bytes to write.</param>
         public override void Write(byte[] buffer, int offset, int count)
         {
-            if (_disposed)
+            if (disposed)
             {
                 throw new ObjectDisposedException("GZipStream");
             }
@@ -339,7 +335,7 @@ namespace SharpCompress.Compressors.Deflate
                 if (BaseStream._wantCompress)
                 {
                     // first write in compression, therefore, emit the GZIP header
-                    _headerByteCount = EmitHeader();
+                    headerByteCount = EmitHeader();
                 }
                 else
                 {
@@ -350,56 +346,56 @@ namespace SharpCompress.Compressors.Deflate
             BaseStream.Write(buffer, offset, count);
         }
 
-        #endregion Stream methods
+        #endregion
 
         public String Comment
         {
-            get => _comment;
+            get => comment;
             set
             {
-                if (_disposed)
+                if (disposed)
                 {
                     throw new ObjectDisposedException("GZipStream");
                 }
-                _comment = value;
+                comment = value;
             }
         }
 
         public string FileName
         {
-            get => _fileName;
+            get => fileName;
             set
             {
-                if (_disposed)
+                if (disposed)
                 {
                     throw new ObjectDisposedException("GZipStream");
                 }
-                _fileName = value;
-                if (_fileName == null)
+                fileName = value;
+                if (fileName == null)
                 {
                     return;
                 }
-                if (_fileName.IndexOf("/") != -1)
+                if (fileName.IndexOf("/") != -1)
                 {
-                    _fileName = _fileName.Replace("/", "\\");
+                    fileName = fileName.Replace("/", "\\");
                 }
-                if (_fileName.EndsWith("\\"))
+                if (fileName.EndsWith("\\"))
                 {
                     throw new InvalidOperationException("Illegal filename");
                 }
 
-                var index = _fileName.IndexOf("\\");
+                var index = fileName.IndexOf("\\");
                 if (index != -1)
                 {
                     // trim any leading path
-                    int length = _fileName.Length;
+                    int length = fileName.Length;
                     int num = length;
                     while (--num >= 0)
                     {
-                        char c = _fileName[num];
+                        char c = fileName[num];
                         if (c == '\\')
                         {
-                            _fileName = _fileName.Substring(num + 1, length - num - 1);
+                            fileName = fileName.Substring(num + 1, length - num - 1);
                         }
                     }
                 }
@@ -410,10 +406,8 @@ namespace SharpCompress.Compressors.Deflate
 
         private int EmitHeader()
         {
-            byte[] commentBytes = (Comment == null) ? null
-                : _encoding.GetBytes(Comment);
-            byte[] filenameBytes = (FileName == null) ? null
-                : _encoding.GetBytes(FileName);
+            byte[] commentBytes = (Comment == null) ? null : ArchiveEncoding.Default.GetBytes(Comment);
+            byte[] filenameBytes = (FileName == null) ? null : ArchiveEncoding.Default.GetBytes(FileName);
 
             int cbLength = (Comment == null) ? 0 : commentBytes.Length + 1;
             int fnLength = (FileName == null) ? 0 : filenameBytes.Length + 1;
@@ -446,7 +440,7 @@ namespace SharpCompress.Compressors.Deflate
             {
                 LastModified = DateTime.Now;
             }
-            TimeSpan delta = LastModified.Value - UNIX_EPOCH;
+            TimeSpan delta = LastModified.Value - UnixEpoch;
             var timet = (Int32)delta.TotalSeconds;
             DataConverter.LittleEndian.PutBytes(header, i, timet);
             i += 4;

src/SharpCompress/Compressors/Deflate/Zlib.cs

@@ -418,7 +418,7 @@ namespace SharpCompress.Compressors.Deflate
     internal sealed class Adler
     {
         // largest prime smaller than 65536
-        private static readonly uint BASE = 65521U;
+        private static readonly int BASE = 65521;
 
         // NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1
         private static readonly int NMAX = 5552;
@@ -430,8 +430,8 @@ namespace SharpCompress.Compressors.Deflate
                 return 1;
             }
 
-            uint s1 = adler & 0xffffU;
-            uint s2 = (adler >> 16) & 0xffffU;
+            int s1 = (int)(adler & 0xffff);
+            int s2 = (int)((adler >> 16) & 0xffff);
 
             while (len > 0)
             {
@@ -486,7 +486,7 @@ namespace SharpCompress.Compressors.Deflate
                 s1 %= BASE;
                 s2 %= BASE;
             }
-            return (s2 << 16) | s1;
+            return (uint)((s2 << 16) | s1);
         }
     }
 }

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -1,20 +1,20 @@
 // ZlibBaseStream.cs
 // ------------------------------------------------------------------
 //
-// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.
+// Copyright (c) 2009 Dino Chiesa and Microsoft Corporation.  
 // All rights reserved.
 //
 // This code module is part of DotNetZip, a zipfile class library.
 //
 // ------------------------------------------------------------------
 //
-// This code is licensed under the Microsoft Public License.
+// This code is licensed under the Microsoft Public License. 
 // See the file License.txt for the license details.
 // More info on: http://dotnetzip.codeplex.com
 //
 // ------------------------------------------------------------------
 //
-// last saved (in emacs):
+// last saved (in emacs): 
 // Time-stamp: <2009-October-28 15:45:15>
 //
 // ------------------------------------------------------------------
@@ -30,7 +30,6 @@ using System.IO;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Converters;
-using System.Text;
 
 namespace SharpCompress.Compressors.Deflate
 {
@@ -65,8 +64,6 @@ namespace SharpCompress.Compressors.Deflate
         protected internal DateTime _GzipMtime;
         protected internal int _gzipHeaderByteCount;
 
-        private readonly Encoding _encoding;
-
         internal int Crc32
         {
             get
@@ -83,8 +80,7 @@ namespace SharpCompress.Compressors.Deflate
                               CompressionMode compressionMode,
                               CompressionLevel level,
                               ZlibStreamFlavor flavor,
-                              bool leaveOpen,
-                              Encoding encoding)
+                              bool leaveOpen)
         {
             _flushMode = FlushType.None;
 
@@ -95,8 +91,6 @@ namespace SharpCompress.Compressors.Deflate
             _flavor = flavor;
             _level = level;
 
-            _encoding = encoding;
-
             // workitem 7159
             if (flavor == ZlibStreamFlavor.GZIP)
             {
@@ -424,8 +418,8 @@ namespace SharpCompress.Compressors.Deflate
                 }
             }
             while (!done);
-            byte[] buffer = list.ToArray();
-            return _encoding.GetString(buffer, 0, buffer.Length);
+            byte[] a = list.ToArray();
+            return ArchiveEncoding.Default.GetString(a, 0, a.Length);
         }
 
         private int _ReadAndValidateGzipHeader()
@@ -534,19 +528,19 @@ namespace SharpCompress.Compressors.Deflate
             }
             if (buffer == null)
             {
-                throw new ArgumentNullException(nameof(buffer));
+                throw new ArgumentNullException("buffer");
             }
             if (count < 0)
             {
-                throw new ArgumentOutOfRangeException(nameof(count));
+                throw new ArgumentOutOfRangeException("count");
             }
             if (offset < buffer.GetLowerBound(0))
             {
-                throw new ArgumentOutOfRangeException(nameof(offset));
+                throw new ArgumentOutOfRangeException("offset");
             }
             if ((offset + count) > buffer.GetLength(0))
             {
-                throw new ArgumentOutOfRangeException(nameof(count));
+                throw new ArgumentOutOfRangeException("count");
             }
 
             int rc = 0;
@@ -599,7 +593,7 @@ namespace SharpCompress.Compressors.Deflate
             while (_z.AvailableBytesOut > 0 && !nomoreinput && rc == ZlibConstants.Z_OK);
 
             // workitem 8557
-            // is there more room in output?
+            // is there more room in output? 
             if (_z.AvailableBytesOut > 0)
             {
                 if (rc == ZlibConstants.Z_OK && _z.AvailableBytesIn == 0)

src/SharpCompress/Compressors/Deflate/ZlibStream.cs

@@ -27,7 +27,6 @@
 
 using System;
 using System.IO;
-using System.Text;
 
 namespace SharpCompress.Compressors.Deflate
 {
@@ -37,23 +36,23 @@ namespace SharpCompress.Compressors.Deflate
         private bool _disposed;
 
         public ZlibStream(Stream stream, CompressionMode mode)
-            : this(stream, mode, CompressionLevel.Default, false, Encoding.UTF8)
+            : this(stream, mode, CompressionLevel.Default, false)
         {
         }
 
         public ZlibStream(Stream stream, CompressionMode mode, CompressionLevel level)
-            : this(stream, mode, level, false, Encoding.UTF8)
+            : this(stream, mode, level, false)
         {
         }
 
         public ZlibStream(Stream stream, CompressionMode mode, bool leaveOpen)
-            : this(stream, mode, CompressionLevel.Default, leaveOpen, Encoding.UTF8)
+            : this(stream, mode, CompressionLevel.Default, leaveOpen)
         {
         }
 
-        public ZlibStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen, Encoding encoding)
+        public ZlibStream(Stream stream, CompressionMode mode, CompressionLevel level, bool leaveOpen)
         {
-            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen, encoding);
+            _baseStream = new ZlibBaseStream(stream, mode, level, ZlibStreamFlavor.ZLIB, leaveOpen);
         }
 
         #region Zlib properties
@@ -327,6 +326,6 @@ namespace SharpCompress.Compressors.Deflate
             _baseStream.Write(buffer, offset, count);
         }
 
-        #endregion System.IO.Stream methods
+        #endregion
     }
 }

src/SharpCompress/Compressors/LZMA/BitVector.cs

@@ -58,7 +58,7 @@ namespace SharpCompress.Compressors.LZMA
             {
                 if (index < 0 || index >= Length)
                 {
-                    throw new ArgumentOutOfRangeException(nameof(index));
+                    throw new ArgumentOutOfRangeException("index");
                 }
 
                 return (mBits[index >> 5] & (1u << (index & 31))) != 0;
@@ -69,7 +69,7 @@ namespace SharpCompress.Compressors.LZMA
         {
             if (index < 0 || index >= Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(index));
+                throw new ArgumentOutOfRangeException("index");
             }
 
             mBits[index >> 5] |= 1u << (index & 31);
@@ -79,7 +79,7 @@ namespace SharpCompress.Compressors.LZMA
         {
             if (index < 0 || index >= Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(index));
+                throw new ArgumentOutOfRangeException("index");
             }
 
             uint bits = mBits[index >> 5];

src/SharpCompress/Compressors/LZMA/Utilites/Utils.cs

@@ -58,22 +58,22 @@ namespace SharpCompress.Compressors.LZMA.Utilites
         {
             if (stream == null)
             {
-                throw new ArgumentNullException(nameof(stream));
+                throw new ArgumentNullException("stream");
             }
 
             if (buffer == null)
             {
-                throw new ArgumentNullException(nameof(buffer));
+                throw new ArgumentNullException("buffer");
             }
 
             if (offset < 0 || offset > buffer.Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(offset));
+                throw new ArgumentOutOfRangeException("offset");
             }
 
             if (length < 0 || length > buffer.Length - offset)
             {
-                throw new ArgumentOutOfRangeException(nameof(length));
+                throw new ArgumentOutOfRangeException("length");
             }
 
             while (length > 0)

src/SharpCompress/Compressors/PPMd/I1/Model.cs

@@ -146,12 +146,12 @@ namespace SharpCompress.Compressors.PPMd.I1
         {
             if (target == null)
             {
-                throw new ArgumentNullException(nameof(target));
+                throw new ArgumentNullException("target");
             }
 
             if (source == null)
             {
-                throw new ArgumentNullException(nameof(source));
+                throw new ArgumentNullException("source");
             }
 
             EncodeStart(properties);
@@ -235,12 +235,12 @@ namespace SharpCompress.Compressors.PPMd.I1
         {
             if (target == null)
             {
-                throw new ArgumentNullException(nameof(target));
+                throw new ArgumentNullException("target");
             }
 
             if (source == null)
             {
-                throw new ArgumentNullException(nameof(source));
+                throw new ArgumentNullException("source");
             }
 
             DecodeStart(source, properties);

src/SharpCompress/Compressors/Rar/RarCrcStream.cs

@@ -31,7 +31,7 @@ namespace SharpCompress.Compressors.Rar {
             {
                 currentCrc = RarCRC.CheckCrc(currentCrc, buffer, offset, result);
             } 
-            else if (GetCrc() != readStream.CurrentCrc && count != 0)
+            else if (GetCrc() != readStream.CurrentCrc)
             {
                 // NOTE: we use the last FileHeader in a multipart volume to check CRC
                 throw new InvalidFormatException("file crc mismatch");

src/SharpCompress/Compressors/Xz/BinaryUtils.cs

@@ -18,11 +18,9 @@ namespace SharpCompress.Compressors.Xz
         public static int ReadLittleEndianInt32(this Stream stream)
         {
             byte[] bytes = new byte[4];
-            var read = stream.ReadFully(bytes);
-            if (!read)
-            {
+            var read = stream.Read(bytes, 0, 4);
+            if (read != 4)
                 throw new EndOfStreamException();
-            }
             return (bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24));
         }
 

src/SharpCompress/Compressors/Xz/MultiByteIntegers.cs

@@ -18,7 +18,7 @@ namespace SharpCompress.Compressors.Xz
             int i = 0;
             while ((LastByte & 0x80) != 0)
             {
-                if (++i >= MaxBytes)
+                if (i >= MaxBytes)
                     throw new InvalidDataException();
                 LastByte = reader.ReadByte();
                 if (LastByte == 0)

src/SharpCompress/Compressors/Xz/XZBlock.cs

@@ -50,11 +50,11 @@ namespace SharpCompress.Compressors.Xz
 
         private void SkipPadding()
         {
-            int bytes = (int)(BaseStream.Position % 4);
-            if (bytes > 0)
+            int padding = (int)(_bytesRead % 4);
+            if (padding > 0)
             {
-                byte[] paddingBytes = new byte[4 - bytes];
-                BaseStream.Read(paddingBytes, 0, paddingBytes.Length);
+                byte[] paddingBytes = new byte[padding];
+                BaseStream.Read(paddingBytes, 0, padding);
                 if (paddingBytes.Any(b => b != 0))
                     throw new InvalidDataException("Padding bytes were non-null");
             }

src/SharpCompress/Compressors/Xz/XZIndex.cs

@@ -55,10 +55,10 @@ namespace SharpCompress.Compressors.Xz
 
         private void SkipPadding()
         {
-            int bytes = (int)(_reader.BaseStream.Position - StreamStartPosition) % 4;
-            if (bytes > 0)
+            int padding = (int)(_reader.BaseStream.Position - StreamStartPosition) % 4;
+            if (padding > 0)
             {
-                byte[] paddingBytes = _reader.ReadBytes(4 - bytes);
+                byte[] paddingBytes = _reader.ReadBytes(padding);
                 if (paddingBytes.Any(b => b != 0))
                     throw new InvalidDataException("Padding bytes were non-null");
             }

src/SharpCompress/Converters/DataConverter.cs

@@ -156,7 +156,7 @@ namespace SharpCompress.Converters
         {
             if (dest == null)
             {
-                throw new ArgumentNullException(nameof(dest));
+                throw new ArgumentNullException("dest");
             }
             if (destIdx < 0 || destIdx > dest.Length - size)
             {
@@ -170,7 +170,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 8)
                 {
@@ -195,7 +195,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 8)
                 {
@@ -221,7 +221,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 8)
                 {
@@ -247,7 +247,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 4)
                 {
@@ -273,7 +273,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 4)
                 {
@@ -299,7 +299,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 4)
                 {
@@ -325,7 +325,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 2)
                 {
@@ -351,7 +351,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 2)
                 {
@@ -468,7 +468,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 8)
                 {
@@ -494,7 +494,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 8)
                 {
@@ -520,7 +520,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 8)
                 {
@@ -546,7 +546,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 4)
                 {
@@ -572,7 +572,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 4)
                 {
@@ -598,7 +598,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 4)
                 {
@@ -624,7 +624,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 2)
                 {
@@ -650,7 +650,7 @@ namespace SharpCompress.Converters
             {
                 if (data == null)
                 {
-                    throw new ArgumentNullException(nameof(data));
+                    throw new ArgumentNullException("data");
                 }
                 if (data.Length - index < 2)
                 {

src/SharpCompress/Crypto/KeyParameter.cs

@@ -12,7 +12,7 @@ namespace Org.BouncyCastle.Crypto.Parameters
         {
             if (key == null)
             {
-                throw new ArgumentNullException(nameof(key));
+                throw new ArgumentNullException("key");
             }
 
             this.key = (byte[])key.Clone();
@@ -25,15 +25,15 @@ namespace Org.BouncyCastle.Crypto.Parameters
         {
             if (key == null)
             {
-                throw new ArgumentNullException(nameof(key));
+                throw new ArgumentNullException("key");
             }
             if (keyOff < 0 || keyOff > key.Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(keyOff));
+                throw new ArgumentOutOfRangeException("keyOff");
             }
             if (keyLen < 0 || (keyOff + keyLen) > key.Length)
             {
-                throw new ArgumentOutOfRangeException(nameof(keyLen));
+                throw new ArgumentOutOfRangeException("keyLen");
             }
 
             this.key = new byte[keyLen];

src/SharpCompress/IO/BufferedSubStream.cs

@@ -41,7 +41,7 @@ namespace SharpCompress.IO
             throw new NotSupportedException();
         }
 
-        public override long Length => BytesLeftToRead;
+        public override long Length => throw new NotSupportedException();
 
         public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
 

src/SharpCompress/IO/RewindableStream.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using SharpCompress.Compressors.Filters;
 
 namespace SharpCompress.IO
 {
@@ -47,13 +46,8 @@ namespace SharpCompress.IO
             }
             else
             {
-                
                 bufferStream.TransferTo(buffer);
-                //create new memorystream to allow proper resizing as memorystream could be a user provided buffer
-                //https://github.com/adamhathcock/sharpcompress/issues/306
-                bufferStream = new MemoryStream();
-                buffer.Position = 0;
-                buffer.TransferTo(bufferStream);
+                bufferStream = buffer;
                 bufferStream.Position = 0;
             }
             isRewound = true;

src/SharpCompress/Readers/AbstractReader.cs

@@ -139,6 +139,8 @@ namespace SharpCompress.Readers
             }
         }
 
+        private readonly byte[] skipBuffer = new byte[4096];
+
         private void Skip()
         {
             if (ArchiveType != ArchiveType.Rar 
@@ -146,21 +148,25 @@ namespace SharpCompress.Readers
                 && Entry.CompressedSize > 0)
             {
                 //not solid and has a known compressed size then we can skip raw bytes.
-                var part = Entry.Parts.First();
-                var rawStream = part.GetRawStream();
+                var rawStream = Entry.Parts.First().GetRawStream();
 
                 if (rawStream != null)
                 {
                     var bytesToAdvance = Entry.CompressedSize;
-                    rawStream.Skip(bytesToAdvance);
-                    part.Skipped = true;
+                    for (var i = 0; i < bytesToAdvance / skipBuffer.Length; i++)
+                    {
+                        rawStream.Read(skipBuffer, 0, skipBuffer.Length);
+                    }
+                    rawStream.Read(skipBuffer, 0, (int)(bytesToAdvance % skipBuffer.Length));
                     return;
                 }
             }
             //don't know the size so we have to try to decompress to skip
             using (var s = OpenEntryStream())
             {
-                s.Skip();
+                while (s.Read(skipBuffer, 0, skipBuffer.Length) > 0)
+                {
+                }
             }
         }
 

src/SharpCompress/Readers/GZip/GZipReader.cs

@@ -29,11 +29,11 @@ namespace SharpCompress.Readers.GZip
             return new GZipReader(stream, options ?? new ReaderOptions());
         }
 
-        #endregion Open
+        #endregion
 
         internal override IEnumerable<GZipEntry> GetEntries(Stream stream)
         {
-            return GZipEntry.GetEntries(stream, Options);
+            return GZipEntry.GetEntries(stream);
         }
     }
 }

src/SharpCompress/Readers/ReaderOptions.cs

@@ -8,7 +8,6 @@ namespace SharpCompress.Readers
         /// Look for RarArchive (Check for self-extracting archives or cases where RarArchive isn't at the start of the file)
         /// </summary>
         public bool LookForHeader { get; set; }
-
         public string Password { get; set; }
     }
 }

src/SharpCompress/Readers/Tar/TarReader.cs

@@ -114,11 +114,11 @@ namespace SharpCompress.Readers.Tar
             return new TarReader(rewindableStream, options, CompressionType.None);
         }
 
-        #endregion Open
+        #endregion
 
         internal override IEnumerable<TarEntry> GetEntries(Stream stream)
         {
-            return TarEntry.GetEntries(StreamingMode.Streaming, stream, compressionType, Options.ArchiveEncoding);
+            return TarEntry.GetEntries(StreamingMode.Streaming, stream, compressionType);
         }
     }
 }

src/SharpCompress/Readers/Zip/ZipReader.cs

@@ -8,13 +8,13 @@ namespace SharpCompress.Readers.Zip
 {
     public class ZipReader : AbstractReader<ZipEntry, ZipVolume>
     {
-        private readonly StreamingZipHeaderFactory _headerFactory;
+        private readonly StreamingZipHeaderFactory headerFactory;
 
         internal ZipReader(Stream stream, ReaderOptions options)
             : base(options, ArchiveType.Zip)
         {
             Volume = new ZipVolume(stream, options);
-            _headerFactory = new StreamingZipHeaderFactory(options.Password, options.ArchiveEncoding);
+            headerFactory = new StreamingZipHeaderFactory(options.Password);
         }
 
         public override ZipVolume Volume { get; }
@@ -33,26 +33,26 @@ namespace SharpCompress.Readers.Zip
             return new ZipReader(stream, options ?? new ReaderOptions());
         }
 
-        #endregion Open
+        #endregion
 
         internal override IEnumerable<ZipEntry> GetEntries(Stream stream)
         {
-            foreach (ZipHeader h in _headerFactory.ReadStreamHeader(stream))
+            foreach (ZipHeader h in headerFactory.ReadStreamHeader(stream))
             {
                 if (h != null)
                 {
                     switch (h.ZipHeaderType)
                     {
                         case ZipHeaderType.LocalEntry:
-                            {
-                                yield return new ZipEntry(new StreamingZipFilePart(h as LocalEntryHeader,
-                                                                                   stream));
-                            }
+                        {
+                            yield return new ZipEntry(new StreamingZipFilePart(h as LocalEntryHeader,
+                                                                               stream));
+                        }
                             break;
                         case ZipHeaderType.DirectoryEnd:
-                            {
-                                yield break;
-                            }
+                        {
+                            yield break;
+                        }
                     }
                 }
             }

src/SharpCompress/SharpCompress.csproj

@@ -2,11 +2,12 @@
   <PropertyGroup>
     <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.19.2</VersionPrefix>
-    <AssemblyVersion>0.19.2.0</AssemblyVersion>
-    <FileVersion>0.19.2.0</FileVersion>
+    <VersionPrefix>0.17.0</VersionPrefix>
+    <AssemblyVersion>0.17.0.0</AssemblyVersion>
+    <FileVersion>0.17.0.0</FileVersion>
     <Authors>Adam Hathcock</Authors>
-    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">net45;net35;netstandard1.0;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">net45;net35;netstandard1.0;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'!=''">$(LibraryFrameworks)</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AssemblyName>SharpCompress</AssemblyName>
@@ -24,10 +25,4 @@
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.0' ">
     <DefineConstants>$(DefineConstants);NO_FILE;NO_CRYPTO;SILVERLIGHT</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
-    <DefineConstants>$(DefineConstants);NETCORE</DefineConstants>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-    <DefineConstants>$(DefineConstants);NETCORE</DefineConstants>
-  </PropertyGroup>
-</Project>
+</Project>

src/SharpCompress/Utility.cs

@@ -2,9 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-#if NETCORE
-using SharpCompress.Buffers;
-#endif
 using SharpCompress.Readers;
 
 namespace SharpCompress
@@ -141,55 +138,37 @@ namespace SharpCompress
 
         public static void Skip(this Stream source, long advanceAmount)
         {
-            byte[] buffer = GetTransferByteArray();
-            try
+            byte[] buffer = new byte[32 * 1024];
+            int read = 0;
+            int readCount = 0;
+            do
             {
-                int read = 0;
-                int readCount = 0;
-                do
+                readCount = buffer.Length;
+                if (readCount > advanceAmount)
                 {
-                    readCount = buffer.Length;
-                    if (readCount > advanceAmount)
-                    {
-                        readCount = (int)advanceAmount;
-                    }
-                    read = source.Read(buffer, 0, readCount);
-                    if (read <= 0)
-                    {
-                        break;
-                    }
-                    advanceAmount -= read;
-                    if (advanceAmount == 0)
-                    {
-                        break;
-                    }
+                    readCount = (int)advanceAmount;
+                }
+                read = source.Read(buffer, 0, readCount);
+                if (read <= 0)
+                {
+                    break;
+                }
+                advanceAmount -= read;
+                if (advanceAmount == 0)
+                {
+                    break;
                 }
-                while (true);
-            }
-            finally
-            {
-#if NETCORE
-                ArrayPool<byte>.Shared.Return(buffer);
-#endif
             }
+            while (true);
         }
 
-        public static void Skip(this Stream source)
+        public static void SkipAll(this Stream source)
         {
-            byte[] buffer = GetTransferByteArray();
-            try
+            byte[] buffer = new byte[32 * 1024];
+            do
             {
-                do
-                {
-                }
-                while (source.Read(buffer, 0, buffer.Length) == buffer.Length);
-            }
-            finally
-            {
-#if NETCORE
-                ArrayPool<byte>.Shared.Return(buffer);
-#endif
             }
+            while (source.Read(buffer, 0, buffer.Length) == buffer.Length);
         }
 
         public static DateTime DosDateToDateTime(UInt16 iDate, UInt16 iTime)
@@ -254,48 +233,30 @@ namespace SharpCompress
         public static long TransferTo(this Stream source, Stream destination)
         {
             byte[] array = GetTransferByteArray();
-            try
+            int count;
+            long total = 0;
+            while (ReadTransferBlock(source, array, out count))
             {
-                int count;
-                long total = 0;
-                while (ReadTransferBlock(source, array, out count))
-                {
-                    total += count;
-                    destination.Write(array, 0, count);
-                }
-                return total;
-            }
-            finally
-            {
-#if NETCORE
-                ArrayPool<byte>.Shared.Return(array);
-#endif
+                total += count;
+                destination.Write(array, 0, count);
             }
+            return total;
         }
 
         public static long TransferTo(this Stream source, Stream destination, Common.Entry entry, IReaderExtractionListener readerExtractionListener)
         {
             byte[] array = GetTransferByteArray();
-            try
+            int count;
+            var iterations = 0;
+            long total = 0;
+            while (ReadTransferBlock(source, array, out count))
             {
-                int count;
-                var iterations = 0;
-                long total = 0;
-                while (ReadTransferBlock(source, array, out count))
-                {
-                    total += count;
-                    destination.Write(array, 0, count);
-                    iterations++;
-                    readerExtractionListener.FireEntryExtractionProgress(entry, total, iterations);
-                }
-                return total;
-            }
-            finally
-            {
-#if NETCORE
-                ArrayPool<byte>.Shared.Return(array);
-#endif
+                total += count;
+                destination.Write(array, 0, count);
+                iterations++;
+                readerExtractionListener.FireEntryExtractionProgress(entry, total, iterations);
             }
+            return total;
         }
 
         private static bool ReadTransferBlock(Stream source, byte[] array, out int count)
@@ -305,11 +266,7 @@ namespace SharpCompress
 
         private static byte[] GetTransferByteArray()
         {
-#if NETCORE
-            return ArrayPool<byte>.Shared.Rent(81920);
-#else
             return new byte[81920];
-#endif
         }
 
         public static bool ReadFully(this Stream stream, byte[] buffer)

src/SharpCompress/Writers/AbstractWriter.cs

@@ -6,30 +6,29 @@ namespace SharpCompress.Writers
 {
     public abstract class AbstractWriter : IWriter
     {
+        private bool closeStream;
         private bool isDisposed;
 
-        protected AbstractWriter(ArchiveType type, WriterOptions writerOptions)
+        protected AbstractWriter(ArchiveType type)
         {
             WriterType = type;
-            WriterOptions = writerOptions;
         }
 
-        protected void InitalizeStream(Stream stream)
+        protected void InitalizeStream(Stream stream, bool closeStream)
         {
             OutputStream = stream;
+            this.closeStream = closeStream;
         }
 
         protected Stream OutputStream { get; private set; }
 
         public ArchiveType WriterType { get; }
 
-        protected WriterOptions WriterOptions { get; }
-
         public abstract void Write(string filename, Stream source, DateTime? modificationTime);
 
         protected virtual void Dispose(bool isDisposing)
         {
-            if (isDisposing && !WriterOptions.LeaveStreamOpen)
+            if (isDisposing && closeStream)
             {
                 OutputStream.Dispose();
             }

src/SharpCompress/Writers/GZip/GZipWriter.cs

@@ -8,15 +8,12 @@ namespace SharpCompress.Writers.GZip
 {
     public class GZipWriter : AbstractWriter
     {
-        private bool _wroteToStream;
+        private bool wroteToStream;
 
-        public GZipWriter(Stream destination, GZipWriterOptions options = null)
-            : base(ArchiveType.GZip, options ?? new GZipWriterOptions())
+        public GZipWriter(Stream destination, bool leaveOpen = false)
+            : base(ArchiveType.GZip)
         {
-            InitalizeStream(new GZipStream(destination, CompressionMode.Compress, 
-                                           options?.CompressionLevel ?? CompressionLevel.Default, 
-                                           WriterOptions.LeaveStreamOpen, 
-                                           WriterOptions.ArchiveEncoding.GetEncoding()));
+            InitalizeStream(new GZipStream(destination, CompressionMode.Compress, leaveOpen), !leaveOpen);
         }
 
         protected override void Dispose(bool isDisposing)
@@ -31,7 +28,7 @@ namespace SharpCompress.Writers.GZip
 
         public override void Write(string filename, Stream source, DateTime? modificationTime)
         {
-            if (_wroteToStream)
+            if (wroteToStream)
             {
                 throw new ArgumentException("Can only write a single stream to a GZip file.");
             }
@@ -39,7 +36,7 @@ namespace SharpCompress.Writers.GZip
             stream.FileName = filename;
             stream.LastModified = modificationTime;
             source.TransferTo(stream);
-            _wroteToStream = true;
+            wroteToStream = true;
         }
     }
 }

src/SharpCompress/Writers/GZip/GZipWriterOptions.cs

@@ -1,28 +0,0 @@
-using SharpCompress.Common;
-using SharpCompress.Compressors.Deflate;
-
-namespace SharpCompress.Writers.GZip
-{
-    public class GZipWriterOptions : WriterOptions
-    {
-        public GZipWriterOptions()
-            : base(CompressionType.GZip)
-        {
-        }
-        
-        internal GZipWriterOptions(WriterOptions options)
-            : base(options.CompressionType)
-        {
-            LeaveStreamOpen = options.LeaveStreamOpen;
-            ArchiveEncoding = options.ArchiveEncoding;
-
-            var writerOptions = options as GZipWriterOptions;
-            if (writerOptions != null)
-            {
-                CompressionLevel = writerOptions.CompressionLevel;
-            }
-        }
-        
-        public CompressionLevel CompressionLevel { get; set; } = CompressionLevel.Default;
-    }
-}

src/SharpCompress/Writers/Tar/TarWriter.cs

@@ -12,7 +12,7 @@ namespace SharpCompress.Writers.Tar
     public class TarWriter : AbstractWriter
     {
         public TarWriter(Stream destination, WriterOptions options)
-            : base(ArchiveType.Tar, options)
+            : base(ArchiveType.Tar)
         {
             if (!destination.CanWrite)
             {
@@ -42,7 +42,7 @@ namespace SharpCompress.Writers.Tar
                     throw new InvalidFormatException("Tar does not support compression: " + options.CompressionType);
                 }
             }
-            InitalizeStream(destination);
+            InitalizeStream(destination, true);
         }
 
         public override void Write(string filename, Stream source, DateTime? modificationTime)
@@ -72,8 +72,7 @@ namespace SharpCompress.Writers.Tar
 
             long realSize = size ?? source.Length;
 
-            TarHeader header = new TarHeader(WriterOptions.ArchiveEncoding);
-
+            TarHeader header = new TarHeader();
             header.LastModifiedTime = modificationTime ?? TarHeader.Epoch;
             header.Name = NormalizeFilename(filename);
             header.Size = realSize;

src/SharpCompress/Writers/WriterFactory.cs

@@ -19,7 +19,7 @@ namespace SharpCompress.Writers
                     {
                         throw new InvalidFormatException("GZip archives only support GZip compression type.");
                     }
-                    return new GZipWriter(stream, new GZipWriterOptions(writerOptions));
+                    return new GZipWriter(stream, writerOptions.LeaveStreamOpen);
                 }
                 case ArchiveType.Zip:
                 {

src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs

@@ -1,7 +1,6 @@
 using System;
 using System.IO;
 using System.Text;
-using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Converters;
@@ -12,16 +11,14 @@ namespace SharpCompress.Writers.Zip
     {
         private readonly ZipCompressionMethod compression;
         private readonly string fileName;
-        private readonly ArchiveEncoding archiveEncoding;
 
-        public ZipCentralDirectoryEntry(ZipCompressionMethod compression, string fileName, ulong headerOffset, ArchiveEncoding archiveEncoding)
+        public ZipCentralDirectoryEntry(ZipCompressionMethod compression, string fileName, ulong headerOffset)
         {
             this.compression = compression;
             this.fileName = fileName;
             HeaderOffset = headerOffset;
-            this.archiveEncoding = archiveEncoding;
         }
-
+        
         internal DateTime? ModificationTime { get; set; }
         internal string Comment { get; set; }
         internal uint Crc { get; set; }
@@ -32,11 +29,11 @@ namespace SharpCompress.Writers.Zip
 
         internal uint Write(Stream outputStream)
         {
-            byte[] encodedFilename = archiveEncoding.Encode(fileName);
-            byte[] encodedComment = archiveEncoding.Encode(Comment);
+            byte[] encodedFilename = Encoding.UTF8.GetBytes(fileName);
+            byte[] encodedComment = Encoding.UTF8.GetBytes(Comment);
 
-            var zip64_stream = Compressed >= uint.MaxValue || Decompressed >= uint.MaxValue;
-            var zip64 = zip64_stream || HeaderOffset >= uint.MaxValue || Zip64HeaderOffset != 0;
+			var zip64_stream = Compressed >= uint.MaxValue || Decompressed >= uint.MaxValue;
+			var zip64 = zip64_stream || HeaderOffset >= uint.MaxValue || Zip64HeaderOffset != 0;
 
             var compressedvalue = zip64 ? uint.MaxValue : (uint)Compressed;
             var decompressedvalue = zip64 ? uint.MaxValue : (uint)Decompressed;
@@ -44,18 +41,18 @@ namespace SharpCompress.Writers.Zip
             var extralength = zip64 ? (2 + 2 + 8 + 8 + 8 + 4) : 0;
             var version = (byte)(zip64 ? 45 : 20); // Version 20 required for deflate/encryption
 
-            HeaderFlags flags = Equals(archiveEncoding.GetEncoding(), Encoding.UTF8) ? HeaderFlags.UTF8 : HeaderFlags.None;
+            HeaderFlags flags = HeaderFlags.UTF8;
             if (!outputStream.CanSeek)
             {
                 // Cannot use data descriptors with zip64:
                 // https://blogs.oracle.com/xuemingshen/entry/is_zipinput_outputstream_handling_of
 
-                // We check that streams are not written too large in the ZipWritingStream,
-                // so this extra guard is not required, but kept to simplify changing the code
-                // once the zip64 post-data issue is resolved
+				// We check that streams are not written too large in the ZipWritingStream,
+				// so this extra guard is not required, but kept to simplify changing the code
+				// once the zip64 post-data issue is resolved
                 if (!zip64_stream)
                     flags |= HeaderFlags.UsePostDataDescriptor;
-
+                
                 if (compression == ZipCompressionMethod.LZMA)
                 {
                     flags |= HeaderFlags.Bit1; // eos marker

src/SharpCompress/Writers/Zip/ZipWriter.cs

@@ -26,7 +26,7 @@ namespace SharpCompress.Writers.Zip
         private readonly bool isZip64;
 
         public ZipWriter(Stream destination, ZipWriterOptions zipWriterOptions)
-            : base(ArchiveType.Zip, zipWriterOptions)
+            : base(ArchiveType.Zip)
         {
             zipComment = zipWriterOptions.ArchiveComment ?? string.Empty;
             isZip64 = zipWriterOptions.UseZip64;
@@ -37,7 +37,7 @@ namespace SharpCompress.Writers.Zip
 
             compressionType = zipWriterOptions.CompressionType;
             compressionLevel = zipWriterOptions.DeflateCompressionLevel;
-            InitalizeStream(destination);
+            InitalizeStream(destination, !zipWriterOptions.LeaveStreamOpen);
         }
 
         private PpmdProperties PpmdProperties
@@ -65,7 +65,6 @@ namespace SharpCompress.Writers.Zip
             }
             base.Dispose(isDisposing);
         }
-
         private static ZipCompressionMethod ToZipCompressionMethod(CompressionType compressionType)
         {
             switch (compressionType)
@@ -98,9 +97,9 @@ namespace SharpCompress.Writers.Zip
         public override void Write(string entryPath, Stream source, DateTime? modificationTime)
         {
             Write(entryPath, source, new ZipWriterEntryOptions()
-            {
-                ModificationDateTime = modificationTime
-            });
+                                     {
+                                         ModificationDateTime =  modificationTime
+                                     });
         }
 
         public void Write(string entryPath, Stream source, ZipWriterEntryOptions zipWriterEntryOptions)
@@ -118,11 +117,11 @@ namespace SharpCompress.Writers.Zip
             entryPath = NormalizeFilename(entryPath);
             options.ModificationDateTime = options.ModificationDateTime ?? DateTime.Now;
             options.EntryComment = options.EntryComment ?? string.Empty;
-            var entry = new ZipCentralDirectoryEntry(compression, entryPath, (ulong)streamPosition, WriterOptions.ArchiveEncoding)
-            {
-                Comment = options.EntryComment,
-                ModificationTime = options.ModificationDateTime
-            };
+            var entry = new ZipCentralDirectoryEntry(compression, entryPath, (ulong)streamPosition)
+                        {
+                            Comment = options.EntryComment,
+                            ModificationTime = options.ModificationDateTime
+                        };
 
             // Use the archive default setting for zip64 and allow overrides
             var useZip64 = isZip64;
@@ -131,7 +130,7 @@ namespace SharpCompress.Writers.Zip
 
             var headersize = (uint)WriteHeader(entryPath, options, entry, useZip64);
             streamPosition += headersize;
-            return new ZipWritingStream(this, OutputStream, entry, compression,
+            return new ZipWritingStream(this, OutputStream, entry, compression, 
                 options.DeflateCompressionLevel ?? compressionLevel);
         }
 
@@ -150,12 +149,12 @@ namespace SharpCompress.Writers.Zip
 
         private int WriteHeader(string filename, ZipWriterEntryOptions zipWriterEntryOptions, ZipCentralDirectoryEntry entry, bool useZip64)
         {
-            // We err on the side of caution until the zip specification clarifies how to support this
-            if (!OutputStream.CanSeek && useZip64)
-                throw new NotSupportedException("Zip64 extensions are not supported on non-seekable streams");
+			// We err on the side of caution until the zip specification clarifies how to support this
+			if (!OutputStream.CanSeek && useZip64)
+				throw new NotSupportedException("Zip64 extensions are not supported on non-seekable streams");
 
             var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? compressionType);
-            byte[] encodedFilename = WriterOptions.ArchiveEncoding.Encode(filename);
+            byte[] encodedFilename = ArchiveEncoding.Default.GetBytes(filename);
 
             OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
             if (explicitZipCompressionInfo == ZipCompressionMethod.Deflate)
@@ -163,17 +162,17 @@ namespace SharpCompress.Writers.Zip
                 if (OutputStream.CanSeek && useZip64)
                     OutputStream.Write(new byte[] { 45, 0 }, 0, 2); //smallest allowed version for zip64
                 else
-                    OutputStream.Write(new byte[] { 20, 0 }, 0, 2); //older version which is more compatible
+                    OutputStream.Write(new byte[] { 20, 0 }, 0, 2); //older version which is more compatible 
             }
             else
             {
                 OutputStream.Write(new byte[] { 63, 0 }, 0, 2); //version says we used PPMd or LZMA
             }
-            HeaderFlags flags = Equals(WriterOptions.ArchiveEncoding.GetEncoding(), Encoding.UTF8) ? HeaderFlags.UTF8 : 0;
+            HeaderFlags flags = ArchiveEncoding.Default == Encoding.UTF8 ? HeaderFlags.UTF8 : 0;
             if (!OutputStream.CanSeek)
             {
                 flags |= HeaderFlags.UsePostDataDescriptor;
-
+                
                 if (explicitZipCompressionInfo == ZipCompressionMethod.LZMA)
                 {
                     flags |= HeaderFlags.Bit1; // eos marker
@@ -214,11 +213,11 @@ namespace SharpCompress.Writers.Zip
 
         private void WriteEndRecord(ulong size)
         {
-            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
+            byte[] encodedComment = ArchiveEncoding.Default.GetBytes(zipComment);
             var zip64 = isZip64 || entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
 
             var sizevalue = size >= uint.MaxValue ? uint.MaxValue : (uint)size;
-            var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition;
+            var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition; 
 
             if (zip64)
             {
@@ -251,7 +250,7 @@ namespace SharpCompress.Writers.Zip
             }
 
             // Write normal end of central directory record
-            OutputStream.Write(new byte[] { 80, 75, 5, 6, 0, 0, 0, 0 }, 0, 8);
+            OutputStream.Write(new byte[] {80, 75, 5, 6, 0, 0, 0, 0}, 0, 8);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
             OutputStream.Write(DataConverter.LittleEndian.GetBytes(sizevalue), 0, 4);
@@ -274,11 +273,10 @@ namespace SharpCompress.Writers.Zip
             private CountingWritableSubStream counting;
             private ulong decompressed;
 
-            // Flag to prevent throwing exceptions on Dispose
-            private bool limitsExceeded;
-            private bool isDisposed;
+			// Flag to prevent throwing exceptions on Dispose
+			private bool limitsExceeded;
 
-            internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry,
+            internal ZipWritingStream(ZipWriter writer, Stream originalStream, ZipCentralDirectoryEntry entry, 
                 ZipCompressionMethod zipCompressionMethod, CompressionLevel compressionLevel)
             {
                 this.writer = writer;
@@ -307,115 +305,108 @@ namespace SharpCompress.Writers.Zip
                 switch (zipCompressionMethod)
                 {
                     case ZipCompressionMethod.None:
-                        {
-                            return output;
-                        }
+                    {
+                        return output;
+                    }
                     case ZipCompressionMethod.Deflate:
-                        {
-                            return new DeflateStream(counting, CompressionMode.Compress, compressionLevel,
-                                                     true);
-                        }
+                    {
+                        return new DeflateStream(counting, CompressionMode.Compress, compressionLevel,
+                                                 true);
+                    }
                     case ZipCompressionMethod.BZip2:
-                        {
-                            return new BZip2Stream(counting, CompressionMode.Compress, true);
-                        }
+                    {
+                        return new BZip2Stream(counting, CompressionMode.Compress, true);
+                    }
                     case ZipCompressionMethod.LZMA:
-                        {
-                            counting.WriteByte(9);
-                            counting.WriteByte(20);
-                            counting.WriteByte(5);
-                            counting.WriteByte(0);
+                    {
+                        counting.WriteByte(9);
+                        counting.WriteByte(20);
+                        counting.WriteByte(5);
+                        counting.WriteByte(0);
 
-                            LzmaStream lzmaStream = new LzmaStream(new LzmaEncoderProperties(!originalStream.CanSeek),
-                                                                   false, counting);
-                            counting.Write(lzmaStream.Properties, 0, lzmaStream.Properties.Length);
-                            return lzmaStream;
-                        }
+                        LzmaStream lzmaStream = new LzmaStream(new LzmaEncoderProperties(!originalStream.CanSeek),
+                                                               false, counting);
+                        counting.Write(lzmaStream.Properties, 0, lzmaStream.Properties.Length);
+                        return lzmaStream;
+                    }
                     case ZipCompressionMethod.PPMd:
-                        {
-                            counting.Write(writer.PpmdProperties.Properties, 0, 2);
-                            return new PpmdStream(writer.PpmdProperties, counting, true);
-                        }
+                    {
+                        counting.Write(writer.PpmdProperties.Properties, 0, 2);
+                        return new PpmdStream(writer.PpmdProperties, counting, true);
+                    }
                     default:
-                        {
-                            throw new NotSupportedException("CompressionMethod: " + zipCompressionMethod);
-                        }
+                    {
+                        throw new NotSupportedException("CompressionMethod: " + zipCompressionMethod);
+                    }
                 }
             }
 
             protected override void Dispose(bool disposing)
             {
-                if (isDisposed)
-                {
-                    return;
-                }
-
-                isDisposed = true;
-
                 base.Dispose(disposing);
                 if (disposing)
                 {
                     writeStream.Dispose();
 
-                    if (limitsExceeded)
-                    {
-                        // We have written invalid data into the archive,
-                        // so we destroy it now, instead of allowing the user to continue
-                        // with a defunct archive
-                        originalStream.Dispose();
-                        return;
-                    }
+					if (limitsExceeded)
+					{
+						// We have written invalid data into the archive,
+						// so we destroy it now, instead of allowing the user to continue
+						// with a defunct archive
+						originalStream.Dispose();
+						return;
+					}
 
                     entry.Crc = (uint)crc.Crc32Result;
                     entry.Compressed = counting.Count;
                     entry.Decompressed = decompressed;
 
                     var zip64 = entry.Compressed >= uint.MaxValue || entry.Decompressed >= uint.MaxValue;
-                    var compressedvalue = zip64 ? uint.MaxValue : (uint)counting.Count;
-                    var decompressedvalue = zip64 ? uint.MaxValue : (uint)entry.Decompressed;
+					var compressedvalue = zip64 ? uint.MaxValue : (uint)counting.Count;
+					var decompressedvalue = zip64 ? uint.MaxValue : (uint)entry.Decompressed;
 
                     if (originalStream.CanSeek)
                     {
                         originalStream.Position = (long)(entry.HeaderOffset + 6);
                         originalStream.WriteByte(0);
-
+                        
                         originalStream.Position = (long)(entry.HeaderOffset + 14);
 
                         writer.WriteFooter(entry.Crc, compressedvalue, decompressedvalue);
 
-                        // Ideally, we should not throw from Dispose()
-                        // We should not get here as the Write call checks the limits
-                        if (zip64 && entry.Zip64HeaderOffset == 0)
-                            throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
+						// Ideally, we should not throw from Dispose()
+						// We should not get here as the Write call checks the limits
+						if (zip64 && entry.Zip64HeaderOffset == 0)
+							throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
 
-                        // If we have pre-allocated space for zip64 data,
-                        // fill it out, even if it is not required
-                        if (entry.Zip64HeaderOffset != 0)
-                        {
-                            originalStream.Position = (long)(entry.HeaderOffset + entry.Zip64HeaderOffset);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(8 + 8)), 0, 2);
+						// If we have pre-allocated space for zip64 data, 
+						// fill it out, even if it is not required
+						if (entry.Zip64HeaderOffset != 0)
+						{
+							originalStream.Position = (long)(entry.HeaderOffset + entry.Zip64HeaderOffset);
+							originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
+							originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(8 + 8)), 0, 2);
 
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Decompressed), 0, 8);
-                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Compressed), 0, 8);
-                        }
+							originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Decompressed), 0, 8);
+							originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Compressed), 0, 8);
+						}
 
                         originalStream.Position = writer.streamPosition + (long)entry.Compressed;
                         writer.streamPosition += (long)entry.Compressed;
                     }
                     else
                     {
-                        // We have a streaming archive, so we should add a post-data-descriptor,
-                        // but we cannot as it does not hold the zip64 values
-                        // Throwing an exception until the zip specification is clarified
+						// We have a streaming archive, so we should add a post-data-descriptor,
+						// but we cannot as it does not hold the zip64 values
+						// Throwing an exception until the zip specification is clarified
 
-                        // Ideally, we should not throw from Dispose()
-                        // We should not get here as the Write call checks the limits
-                        if (zip64)
-                            throw new NotSupportedException("Streams larger than 4GiB are not supported for non-seekable streams");
+						// Ideally, we should not throw from Dispose()
+						// We should not get here as the Write call checks the limits
+						if (zip64)
+							throw new NotSupportedException("Streams larger than 4GiB are not supported for non-seekable streams");
 
-                        originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
-                        writer.WriteFooter(entry.Crc,
+						originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
+                        writer.WriteFooter(entry.Crc, 
                                            (uint)compressedvalue,
                                            (uint)decompressedvalue);
                         writer.streamPosition += (long)entry.Compressed + 16;
@@ -446,35 +437,36 @@ namespace SharpCompress.Writers.Zip
 
             public override void Write(byte[] buffer, int offset, int count)
             {
-                // We check the limits first, because we can keep the archive consistent
-                // if we can prevent the writes from happening
-                if (entry.Zip64HeaderOffset == 0)
-                {
-                    // Pre-check, the counting.Count is not exact, as we do not know the size before having actually compressed it
-                    if (limitsExceeded || ((decompressed + (uint)count) > uint.MaxValue) || (counting.Count + (uint)count) > uint.MaxValue)
-                        throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
-                }
+				// We check the limits first, because we can keep the archive consistent
+				// if we can prevent the writes from happening
+				if (entry.Zip64HeaderOffset == 0)
+				{
+					// Pre-check, the counting.Count is not exact, as we do not know the size before having actually compressed it
+					if (limitsExceeded || ((decompressed + (uint)count) > uint.MaxValue) || (counting.Count + (uint)count) > uint.MaxValue)
+						throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
+				}
 
                 decompressed += (uint)count;
                 crc.SlurpBlock(buffer, offset, count);
                 writeStream.Write(buffer, offset, count);
 
-                if (entry.Zip64HeaderOffset == 0)
-                {
-                    // Post-check, this is accurate
-                    if ((decompressed > uint.MaxValue) || counting.Count > uint.MaxValue)
-                    {
-                        // We have written the data, so the archive is now broken
-                        // Throwing the exception here, allows us to avoid
-                        // throwing an exception in Dispose() which is discouraged
-                        // as it can mask other errors
-                        limitsExceeded = true;
-                        throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
-                    }
-                }
+				if (entry.Zip64HeaderOffset == 0)
+				{
+					// Post-check, this is accurate
+					if ((decompressed > uint.MaxValue) || counting.Count > uint.MaxValue)
+					{
+						// We have written the data, so the archive is now broken
+						// Throwing the exception here, allows us to avoid
+						// throwing an exception in Dispose() which is discouraged
+						// as it can mask other errors
+						limitsExceeded = true;
+						throw new NotSupportedException("Attempted to write a stream that is larger than 4GiB without setting the zip64 option");
+					}
+				}
+
             }
         }
 
-        #endregion Nested type: ZipWritingStream
+        #endregion
     }
 }

src/SharpCompress/Writers/Zip/ZipWriterOptions.cs

@@ -15,15 +15,8 @@ namespace SharpCompress.Writers.Zip
             : base(options.CompressionType)
         {
             LeaveStreamOpen = options.LeaveStreamOpen;
-            ArchiveEncoding = options.ArchiveEncoding;
-
-            var writerOptions = options as ZipWriterOptions;
-            if (writerOptions != null)
-            {
-                UseZip64 = writerOptions.UseZip64;
-                DeflateCompressionLevel = writerOptions.DeflateCompressionLevel;
-                ArchiveComment = writerOptions.ArchiveComment;
-            }
+            if (options is ZipWriterOptions)
+                UseZip64 = ((ZipWriterOptions)options).UseZip64;
         }
         /// <summary>
         /// When CompressionType.Deflate is used, this property is referenced.  Defaults to CompressionLevel.Default.

src/dotnet-sharpcompress/BaseOptions.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using CommandLine;
+
+namespace SharpCompress
+{
+    public class BaseOptions
+    {
+        [Value(0, Min = 1)]
+        public IEnumerable<string> Path { get; set; }
+
+        protected IEnumerable<FileInfo> GetFilesFromPath()
+        {
+            foreach (var s in Path)
+            {
+                var fileInfo = new FileInfo(s);
+                if (fileInfo.Exists)
+                {
+                    yield return fileInfo;
+                }
+                else
+                {
+                    using (ConsoleHelper.PushError())
+                    {
+                        Console.WriteLine($"{s} does not exist");
+                    }
+                }
+            }
+        }
+    }
+}

src/dotnet-sharpcompress/ConsoleHelper.cs

@@ -0,0 +1,32 @@
+using System;
+
+namespace SharpCompress
+{
+    public static class ConsoleHelper
+    {
+        private class ConsoleTextPush : IDisposable
+        {
+            private readonly ConsoleColor _restoreColor;
+
+            public ConsoleTextPush(ConsoleColor displayColor)
+            {
+                _restoreColor = Console.ForegroundColor;
+                Console.ForegroundColor = displayColor;
+            }
+
+            public void Dispose()
+            {
+                Console.ForegroundColor = _restoreColor;
+            }
+        }
+
+        public static IDisposable PushForeground(ConsoleColor color)
+        {
+            return new ConsoleTextPush(color);
+        }
+        public static IDisposable PushError()
+        {
+            return PushForeground(ConsoleColor.Red);
+        }
+    }
+}

src/dotnet-sharpcompress/ExtractOptions.cs

@@ -0,0 +1,37 @@
+using System;
+using CommandLine;
+using SharpCompress.Readers;
+
+namespace SharpCompress
+{
+    [Verb("x", HelpText = "Extract an archive")]
+    public class ExtractOptions : BaseOptions
+    {
+
+        [Option('p', HelpText = "Path to extract to")]
+        public string ExtractionPath { get; set; } = AppContext.BaseDirectory;
+        
+        public int Process()
+        {
+            foreach (var fileInfo in GetFilesFromPath())
+            {
+                Console.WriteLine($"Extracting archive {fileInfo.FullName} to path: {ExtractionPath}");
+                using (var reader = ReaderFactory.Open(fileInfo.OpenRead()))
+                {
+                    while (reader.MoveToNextEntry())
+                    {
+                        var progress = new ProgressBar();
+                            reader.EntryExtractionProgress += (sender, args) =>
+                                                              {
+                                                                  progress.Report(args.ReaderProgress.PercentageReadExact);
+                                                              };
+                            Console.Write($"Extracting entry {reader.Entry.Key}: ");
+                            reader.WriteEntryToDirectory(ExtractionPath);
+                            Console.WriteLine();
+                    }
+                }
+            }
+            return 1;
+        }
+    }
+}

src/dotnet-sharpcompress/InfoOptions.cs

@@ -0,0 +1,56 @@
+using System;
+using CommandLine;
+using SharpCompress.Archives;
+using SharpCompress.Common;
+
+namespace SharpCompress
+{
+    [Verb("i", HelpText = "Information about an archive")]
+    public class InfoOptions : BaseOptions
+    {
+        [Option('e',  HelpText = "Show Archive Entry Information")]
+        public bool ShowEntries { get; set; }
+        
+        public int Process()
+        {
+            foreach (var fileInfo in GetFilesFromPath())
+            {
+                Console.WriteLine($"=== Archive: {fileInfo}");
+                try
+                {
+                    using (var archive = ArchiveFactory.Open(fileInfo.OpenRead()))
+                    {
+                        Console.WriteLine($"Archive Type: {archive.Type}");
+
+                        Console.WriteLine($"Size: {archive.TotalSize}");
+                        Console.WriteLine($"Uncompressed Size: {archive.TotalUncompressSize}");
+
+                        if (ShowEntries)
+                        {
+                            foreach (var archiveEntry in archive.Entries)
+                            {
+                                Console.WriteLine($"\tEntry: {archiveEntry.Key}");
+                            }
+                        }
+                    }
+                }
+                catch (InvalidFormatException)
+                {
+                    using (ConsoleHelper.PushError())
+                    {
+                        Console.WriteLine("Archive Type is unknown.");
+                    }
+                }
+                catch (Exception e)
+                {
+                    using (ConsoleHelper.PushError())
+                    {
+                        Console.WriteLine($"Unhandled Error: {e}");
+                        return 1;
+                    }
+                }
+            }
+            return 0;
+        }
+    }
+}

src/dotnet-sharpcompress/Program.cs

@@ -0,0 +1,16 @@
+using CommandLine;
+
+namespace SharpCompress
+{
+    public class Program
+    {
+        public static int Main(string[] args)
+        {
+            return Parser.Default.ParseArguments<InfoOptions, ExtractOptions>(args)
+                              .MapResult(
+                                         (InfoOptions opts) => opts.Process(),
+                                         (ExtractOptions opts) => opts.Process(),
+                                         errs => 1);
+        }
+    }
+}

src/dotnet-sharpcompress/dotnet-sharpcompress.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+    <RootNamespace>SharpCompress</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\SharpCompress\SharpCompress.csproj">
+      <Project>{fd19ddd8-72b2-4024-8665-0d1f7a2aa998}</Project>
+      <Name>SharpCompress</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="CommandLineParser">
+      <Version>2.1.1-beta</Version>
+    </PackageReference>
+    <PackageReference Include="goblinfactory.konsole" Version="2.0.2" />
+  </ItemGroup>
+</Project>

tests/SharpCompress.Test/ArchiveTests.cs

@@ -40,7 +40,7 @@ namespace SharpCompress.Test
                     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                     {
                         entry.WriteToDirectory(SCRATCH_FILES_PATH,
-                                               new ExtractionOptions
+                                               new ExtractionOptions()
                                                {
                                                    ExtractFullPath = true,
                                                    Overwrite = true
@@ -51,24 +51,24 @@ namespace SharpCompress.Test
             }
         }
 
-        protected void ArchiveStreamRead(string testArchive, ReaderOptions readerOptions = null)
+        protected void ArchiveStreamRead(string testArchive)
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
-            ArchiveStreamRead(readerOptions, testArchive.AsEnumerable());
+            ArchiveStreamRead(testArchive.AsEnumerable());
         }
 
-        protected void ArchiveStreamRead(ReaderOptions readerOptions = null, params string[] testArchives)
+        protected void ArchiveStreamRead(params string[] testArchives)
         {
-            ArchiveStreamRead(readerOptions, testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)));
+            ArchiveStreamRead(testArchives.Select(x => Path.Combine(TEST_ARCHIVES_PATH, x)));
         }
 
-        protected void ArchiveStreamRead(ReaderOptions readerOptions, IEnumerable<string> testArchives)
+        protected void ArchiveStreamRead(IEnumerable<string> testArchives)
         {
             foreach (var path in testArchives)
             {
                 ResetScratch();
                 using (Stream stream = File.OpenRead(path))
-                using (var archive = ArchiveFactory.Open(stream, readerOptions))
+                using (var archive = ArchiveFactory.Open(stream))
                 {
                     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                     {
@@ -83,17 +83,17 @@ namespace SharpCompress.Test
             }
         }
 
-        protected void ArchiveFileRead(string testArchive, ReaderOptions readerOptions = null)
+        protected void ArchiveFileRead(string testArchive)
         {
             testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
-            ArchiveFileRead(testArchive.AsEnumerable(), readerOptions);
+            ArchiveFileRead(testArchive.AsEnumerable());
         }
-        protected void ArchiveFileRead(IEnumerable<string> testArchives, ReaderOptions readerOptions = null)
+        protected void ArchiveFileRead(IEnumerable<string> testArchives)
         {
             foreach (var path in testArchives)
             {
                 ResetScratch();
-                using (var archive = ArchiveFactory.Open(path, readerOptions))
+                using (var archive = ArchiveFactory.Open(path))
                 {
                     //archive.EntryExtractionBegin += archive_EntryExtractionBegin;
                     //archive.FilePartExtractionBegin += archive_FilePartExtractionBegin;

tests/SharpCompress.Test/Rar/RarArchiveTests.cs

@@ -35,10 +35,10 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
             using (var archive = RarArchive.Open(stream, new ReaderOptions()
-            {
-                Password = password,
-                LeaveStreamOpen = true
-            }))
+                                                         {
+                                                             Password = password,
+                                                             LeaveStreamOpen = true
+                                                         }))
             {
                 foreach (var entry in archive.Entries)
                 {
@@ -66,10 +66,10 @@ namespace SharpCompress.Test.Rar
         {
             ResetScratch();
             using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, archiveName), new ReaderOptions()
-            {
-                Password = password,
-                LeaveStreamOpen = true
-            }))
+                                                            {
+                                                                Password = password,
+                                                                LeaveStreamOpen = true
+                                                            }))
             {
                 foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                 {
@@ -120,12 +120,12 @@ namespace SharpCompress.Test.Rar
         public void Rar_Jpg_ArchiveStreamRead()
         {
             ResetScratch();
-            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rarjpeg.jpg")))
+            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg")))
             {
                 using (var archive = RarArchive.Open(stream, new ReaderOptions()
-                {
-                    LookForHeader = true
-                }))
+                                                             {
+                                                                 LookForHeader = true
+                                                             }))
                 {
                     foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                     {
@@ -224,7 +224,7 @@ namespace SharpCompress.Test.Rar
                 using (var archive = RarArchive.Open(stream))
                 {
                     Assert.False(archive.IsSolid);
-                    Assert.Contains(true, archive.Entries.Select(entry => entry.IsDirectory));
+                    Assert.True(archive.Entries.Any(entry => entry.IsDirectory));
                 }
             }
         }
@@ -233,10 +233,10 @@ namespace SharpCompress.Test.Rar
         public void Rar_Jpg_ArchiveFileRead()
         {
             ResetScratch();
-            using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "Rarjpeg.jpg"), new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+            using (var archive = RarArchive.Open(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg"), new ReaderOptions()
+                                                                                                  {
+                                                                                                      LookForHeader = true
+                                                                                                  }))
             {
                 foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
                 {

tests/SharpCompress.Test/Rar/RarHeaderFactoryTest.cs

@@ -12,14 +12,14 @@ namespace SharpCompress.Test.Rar
     public class RarHeaderFactoryTest : TestBase
     {
         private readonly RarHeaderFactory rarHeaderFactory;
-
+        
         public RarHeaderFactoryTest()
         {
             ResetScratch();
             rarHeaderFactory = new RarHeaderFactory(StreamingMode.Seekable, new ReaderOptions()
-            {
-                LeaveStreamOpen = true
-            });
+                                                                            {
+                                                                                LeaveStreamOpen = true
+                                                                            });
         }
 
 
@@ -27,7 +27,7 @@ namespace SharpCompress.Test.Rar
         public void ReadHeaders_RecognizeEncryptedFlag()
         {
 
-            ReadEncryptedFlag("Rar.encrypted_filesAndHeader.rar", true);
+            ReadEncryptedFlag("Rar.Encrypted_filesAndHeader.rar", true);
 
 
 

tests/SharpCompress.Test/Rar/RarReaderTests.cs

@@ -149,9 +149,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, testArchive)))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                Password = password
-            }))
+                                                       {
+                                                           Password = password
+                                                       }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -209,9 +209,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Audio_program.rar")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                       {
+                                                           LookForHeader = true
+                                                       }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -231,11 +231,11 @@ namespace SharpCompress.Test.Rar
         public void Rar_Jpg_Reader()
         {
             ResetScratch();
-            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rarjpeg.jpg")))
+            using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "RarJpeg.jpg")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                        {
+                                                            LookForHeader = true
+                                                        }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -262,9 +262,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.solid.rar")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                        {
+                                                            LookForHeader = true
+                                                        }))
             {
                 while (reader.MoveToNextEntry())
                 {
@@ -287,9 +287,9 @@ namespace SharpCompress.Test.Rar
             ResetScratch();
             using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.rar")))
             using (var reader = RarReader.Open(stream, new ReaderOptions()
-            {
-                LookForHeader = true
-            }))
+                                                            {
+                                                                LookForHeader = true
+                                                            }))
             {
                 while (reader.MoveToNextEntry())
                 {

tests/SharpCompress.Test/SevenZip/SevenZipArchiveTests.cs

@@ -1,6 +1,5 @@
 using System;
 using SharpCompress.Common;
-using SharpCompress.Readers;
 using Xunit;
 
 namespace SharpCompress.Test.SevenZip
@@ -19,17 +18,6 @@ namespace SharpCompress.Test.SevenZip
             ArchiveFileRead("7Zip.LZMA.7z");
         }
 
-        [Fact]
-        public void SevenZipArchive_LZMAAES_StreamRead()
-        {
-            ArchiveStreamRead("7Zip.LZMA.Aes.7z", new ReaderOptions() {Password = "testpassword"});
-        }
-
-        [Fact]
-        public void SevenZipArchive_LZMAAES_PathRead()
-        {
-            ArchiveFileRead("7Zip.LZMA.Aes.7z", new ReaderOptions() {Password = "testpassword"});
-        }
         [Fact]
         public void SevenZipArchive_PPMd_StreamRead()
         {
@@ -47,7 +35,6 @@ namespace SharpCompress.Test.SevenZip
         {
             ArchiveFileRead("7Zip.PPMd.7z");
         }
-
         [Fact]
         public void SevenZipArchive_LZMA2_StreamRead()
         {
@@ -59,19 +46,6 @@ namespace SharpCompress.Test.SevenZip
         {
             ArchiveFileRead("7Zip.LZMA2.7z");
         }
-
-        [Fact]
-        public void SevenZipArchive_LZMA2AES_StreamRead()
-        {
-            ArchiveStreamRead("7Zip.LZMA2.Aes.7z", new ReaderOptions {Password = "testpassword"});
-        }
-
-        [Fact]
-        public void SevenZipArchive_LZMA2AES_PathRead()
-        {
-            ArchiveFileRead("7Zip.LZMA2.Aes.7z", new ReaderOptions {Password = "testpassword"});
-        }
-
         [Fact]
         public void SevenZipArchive_BZip2_StreamRead()
         {
@@ -93,13 +67,9 @@ namespace SharpCompress.Test.SevenZip
         [Fact]
         public void SevenZipArchive_BZip2_Split()
         {
-            Assert.Throws<IndexOutOfRangeException>(() => ArchiveStreamRead(null, "Original.7z.001",
-                                                                            "Original.7z.002",
-                                                                            "Original.7z.003",
-                                                                            "Original.7z.004",
-                                                                            "Original.7z.005",
-                                                                            "Original.7z.006",
-                                                                            "Original.7z.007"));
+            Assert.Throws<IndexOutOfRangeException>(() => ArchiveStreamRead("Original.7z.001", "Original.7z.002",
+                "Original.7z.003", "Original.7z.004", "Original.7z.005",
+                "Original.7z.006", "Original.7z.007"));
         }
     }
-}
+}

tests/SharpCompress.Test/SharpCompress.Test.csproj

@@ -1,25 +1,25 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp1.1;netcoreapp2.0</TargetFrameworks>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
     <AssemblyName>SharpCompress.Test</AssemblyName>
     <AssemblyOriginatorKeyFile>../../SharpCompress.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageId>SharpCompress.Test</PackageId>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <RuntimeFrameworkVersion>1.1.2</RuntimeFrameworkVersion>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\SharpCompress\SharpCompress.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
-    <PackageReference Include="xunit" Version="2.3.1" />
-  </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' != 'netstandard2.0' ">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.0-beta2-build1317" />
     <PackageReference Include="Microsoft.Extensions.PlatformAbstractions" Version="1.1.0" />
+    <PackageReference Include="xunit" Version="2.3.0-beta2-build3683" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.0-beta2-build3683" />
   </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-    <PackageReference Include="NETStandard.Library" Version="2.0.0" />
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
   </ItemGroup>
 </Project>

tests/SharpCompress.Test/Tar/TarArchiveTests.cs

@@ -35,11 +35,11 @@ namespace SharpCompress.Test.Tar
             using (var archive = TarArchive.Open(unmodified))
             {
                 Assert.Equal(5, archive.Entries.Count);
-                Assert.Contains("very long filename/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("very long filename/very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename.jpg", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("z_file 1.txt", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("z_file 2.txt", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("z_file 3.txt", archive.Entries.Select(entry => entry.Key));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "very long filename/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "very long filename/very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename very long filename.jpg"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "z_file 1.txt"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "z_file 2.txt"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "z_file 3.txt"));
             }
         }
 
@@ -74,7 +74,7 @@ namespace SharpCompress.Test.Tar
             using (var archive2 = TarArchive.Open(unmodified))
             {
                 Assert.Equal(1, archive2.Entries.Count);
-                Assert.Contains(longFilename, archive2.Entries.Select(entry => entry.Key));
+                Assert.True(archive2.Entries.Any(entry => entry.Key == longFilename));
 
                 foreach (var entry in archive2.Entries)
                     Assert.Equal("dummy filecontent", new StreamReader(entry.OpenEntryStream()).ReadLine());
@@ -85,15 +85,15 @@ namespace SharpCompress.Test.Tar
         public void Tar_UstarArchivePathReadLongName()
         {
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "ustar with long names.tar");
-            using (var archive = TarArchive.Open(unmodified))
+            using(var archive = TarArchive.Open(unmodified))
             {
                 Assert.Equal(6, archive.Entries.Count);
-                Assert.Contains("Directory/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/", archive.Entries.Select(entry => entry.Key));
-                Assert.Contains("Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name", archive.Entries.Select(entry => entry.Key));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Some file with veeeeeeeeeery loooooooooong name"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/"));
+                Assert.True(archive.Entries.Any(entry => entry.Key == "Directory/Directory with veeeeeeeeeery loooooooooong name/Directory with veeeeeeeeeery loooooooooong name/Some file with veeeeeeeeeery loooooooooong name"));
             }
         }
 
@@ -114,7 +114,7 @@ namespace SharpCompress.Test.Tar
         [Fact]
         public void Tar_Random_Write_Add()
         {
-            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg", "test.jpg");
+            string jpg = Path.Combine(ORIGINAL_FILES_PATH, "jpg","test.jpg");
             string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.mod.tar");
             string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.mod.tar");
             string modified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar");

tests/SharpCompress.Test/TestBase.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
+using Microsoft.Extensions.PlatformAbstractions;
+using SharpCompress.Common;
 using SharpCompress.Readers;
 using Xunit;
 
@@ -10,7 +12,7 @@ namespace SharpCompress.Test
 {
     public class TestBase : IDisposable
     {
-        protected string SOLUTION_BASE_PATH = null;
+        protected string SOLUTION_BASE_PATH=null;
         protected string TEST_ARCHIVES_PATH;
         protected string ORIGINAL_FILES_PATH;
         protected string MISC_TEST_FILES_PATH;
@@ -179,11 +181,6 @@ namespace SharpCompress.Test
 
         protected void CompareFilesByPath(string file1, string file2)
         {
-            //TODO: fix line ending issues with the text file
-            if (file1.EndsWith("txt"))
-            {
-                return;
-            }
             using (var file1Stream = File.OpenRead(file1))
             using (var file2Stream = File.OpenRead(file2))
             {
@@ -240,14 +237,8 @@ namespace SharpCompress.Test
         public TestBase()
         {
             Monitor.Enter(lockObject);
-
-#if NETSTANDARD20
-            var index = AppDomain.CurrentDomain.BaseDirectory.IndexOf("SharpCompress.Test", StringComparison.OrdinalIgnoreCase);
-            SOLUTION_BASE_PATH = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory.Substring(0, index));
-#else
-            var index = Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default.Application.ApplicationBasePath.IndexOf("SharpCompress.Test", StringComparison.OrdinalIgnoreCase);
-            SOLUTION_BASE_PATH = Path.GetDirectoryName(Microsoft.Extensions.PlatformAbstractions.PlatformServices.Default.Application.ApplicationBasePath.Substring(0, index));
-#endif
+            var index = PlatformServices.Default.Application.ApplicationBasePath.IndexOf("SharpCompress.Test", StringComparison.OrdinalIgnoreCase);
+            SOLUTION_BASE_PATH = Path.GetDirectoryName(PlatformServices.Default.Application.ApplicationBasePath.Substring(0, index));
             TEST_ARCHIVES_PATH = Path.Combine(SOLUTION_BASE_PATH, "TestArchives", "Archives");
             ORIGINAL_FILES_PATH = Path.Combine(SOLUTION_BASE_PATH, "TestArchives", "Original");
             MISC_TEST_FILES_PATH = Path.Combine(SOLUTION_BASE_PATH, "TestArchives", "MiscTest");

tests/SharpCompress.Test/Xz/Crc32Tests.cs

@@ -1,32 +0,0 @@
-using SharpCompress.Compressors.Xz;
-using System;
-using System.Text;
-using Xunit;
-
-namespace SharpCompress.Test.Xz
-{
-    public class Crc32Tests
-    {
-        private const string SimpleString = @"The quick brown fox jumps over the lazy dog.";
-        private readonly byte[] SimpleBytes = Encoding.ASCII.GetBytes(SimpleString);
-        private const string SimpleString2 = @"Life moves pretty fast. If you don't stop and look around once in a while, you could miss it.";
-        private readonly byte[] SimpleBytes2 = Encoding.ASCII.GetBytes(SimpleString2);
-
-        [Fact]
-        public void ShortAsciiString()
-        {
-            var actual = Crc32.Compute(SimpleBytes);
-
-            Assert.Equal((UInt32)0x519025e9, actual);
-        }
-
-        [Fact]
-        public void ShortAsciiString2()
-        {
-            var actual = Crc32.Compute(SimpleBytes2);
-
-            Assert.Equal((UInt32)0x6ee3ad88, actual);
-        }
-
-    }
-}

tests/SharpCompress.Test/Xz/Crc64Tests.cs

@@ -1,32 +0,0 @@
-using SharpCompress.Compressors.Xz;
-using System;
-using System.Text;
-using Xunit;
-
-namespace SharpCompress.Test.Xz
-{
-    public class Crc64Tests
-    {
-        private const string SimpleString = @"The quick brown fox jumps over the lazy dog.";
-        private readonly byte[] SimpleBytes = Encoding.ASCII.GetBytes(SimpleString);
-        private const string SimpleString2 = @"Life moves pretty fast. If you don't stop and look around once in a while, you could miss it.";
-        private readonly byte[] SimpleBytes2 = Encoding.ASCII.GetBytes(SimpleString2);
-
-        [Fact]
-        public void ShortAsciiString()
-        {
-            var actual = Crc64.Compute(SimpleBytes);
-
-            Assert.Equal((UInt64)0x7E210EB1B03E5A1D, actual);
-        }
-
-        [Fact]
-        public void ShortAsciiString2()
-        {
-            var actual = Crc64.Compute(SimpleBytes2);
-
-            Assert.Equal((UInt64)0x416B4150508661EE, actual);
-        }
-
-    }
-}

tests/SharpCompress.Test/Xz/Filters/Lzma2Tests.cs

@@ -1,72 +0,0 @@
-using System;
-using Xunit;
-using System.IO;
-using SharpCompress.Compressors.Xz.Filters;
-
-namespace SharpCompress.Test.Xz.Filters
-{
-    public class Lzma2Tests : XZTestsBase
-    {
-        Lzma2Filter filter;
-    
-        public Lzma2Tests()
-        {
-            filter = new Lzma2Filter();
-        }
-
-        [Fact]
-        public void IsOnlyAllowedLast()
-        {
-            Assert.True(filter.AllowAsLast);
-            Assert.False(filter.AllowAsNonLast);
-        }
-
-        [Fact]
-        public void ChangesStreamSize()
-        {
-            Assert.True(filter.ChangesDataSize);
-        }
-
-        [Theory]
-        [InlineData(0, (uint)4 * 1024)]
-        [InlineData(1, (uint)6 * 1024)]
-        [InlineData(2, (uint)8 * 1024)]
-        [InlineData(3, (uint)12 * 1024)]
-        [InlineData(38, (uint)2 * 1024 * 1024 * 1024)]
-        [InlineData(39, (uint)3 * 1024 * 1024 * 1024)]
-        [InlineData(40, (uint)(1024 * 1024 * 1024 - 1) * 4 + 3)]
-        public void CalculatesDictionarySize(byte inByte, uint dicSize)
-        {
-            filter.Init(new[] { inByte });
-            Assert.Equal(filter.DictionarySize, dicSize);
-        }
-
-        [Fact]
-        public void CalculatesDictionarySizeError()
-        {
-            uint temp;
-            filter.Init(new byte[] { 41 });
-            var ex = Assert.Throws<OverflowException>(() =>
-            {
-                temp = filter.DictionarySize;
-            });
-            Assert.Equal("Dictionary size greater than UInt32.Max", ex.Message);
-        }
-
-        [Theory]
-        [InlineData(new byte[] { })]
-        [InlineData(new byte[] { 0, 0 })]
-        public void OnlyAcceptsOneByte(byte[] bytes)
-        {
-            var ex = Assert.Throws<InvalidDataException>(() => filter.Init(bytes));
-            Assert.Equal("LZMA properties unexpected length", ex.Message);
-        }
-
-        [Fact]
-        public void ReservedBytesThrow()
-        {
-            var ex = Assert.Throws<InvalidDataException>(() => filter.Init(new byte[] { 0xC0 }));
-            Assert.Equal("Reserved bits used in LZMA properties", ex.Message);
-        }
-    }
-}

tests/SharpCompress.Test/Xz/XZBlockTests.cs

@@ -1,98 +0,0 @@
-using System.Text;
-using System.IO;
-using SharpCompress.Compressors.Xz;
-using Xunit;
-
-namespace SharpCompress.Test.Xz
-{
-    public class XZBlockTests : XZTestsBase
-    {
-        protected override void Rewind(Stream stream)
-        {
-            stream.Position = 12;
-        }
-
-        protected override void RewindIndexed(Stream stream)
-        {
-            stream.Position = 12;
-        }
-
-        private byte[] ReadBytes(XZBlock block, int bytesToRead)
-        {
-            byte[] buffer = new byte[bytesToRead];
-            var read = block.Read(buffer, 0, bytesToRead);
-            if (read != bytesToRead)
-                throw new EndOfStreamException();
-            return buffer;
-        }
-
-        [Fact]
-        public void OnFindIndexBlockThrow()
-        {
-            var bytes = new byte[] { 0 };
-            using (Stream indexBlockStream = new MemoryStream(bytes))
-            {
-                var XZBlock = new XZBlock(indexBlockStream, CheckType.CRC64, 8);
-                Assert.Throws<XZIndexMarkerReachedException>(() => { ReadBytes(XZBlock, 1); });
-            }
-        }
-
-        [Fact]
-        public void CrcIncorrectThrows()
-        {
-            var bytes = Compressed.Clone() as byte[];
-            bytes[20]++;
-            using (Stream badCrcStream = new MemoryStream(bytes))
-            {
-                Rewind(badCrcStream);
-                var XZBlock = new XZBlock(badCrcStream, CheckType.CRC64, 8);
-                var ex = Assert.Throws<InvalidDataException>(() => { ReadBytes(XZBlock, 1); });
-                Assert.Equal("Block header corrupt", ex.Message);
-            }
-        }
-
-        [Fact]
-        public void CanReadM()
-        {
-            var XZBlock = new XZBlock(CompressedStream, CheckType.CRC64, 8);
-            Assert.Equal(Encoding.ASCII.GetBytes("M"), ReadBytes(XZBlock, 1));
-        }
-
-        [Fact]
-        public void CanReadMary()
-        {
-            var XZBlock = new XZBlock(CompressedStream, CheckType.CRC64, 8);
-            Assert.Equal(Encoding.ASCII.GetBytes("M"), ReadBytes(XZBlock, 1));
-            Assert.Equal(Encoding.ASCII.GetBytes("a"), ReadBytes(XZBlock, 1));
-            Assert.Equal(Encoding.ASCII.GetBytes("ry"), ReadBytes(XZBlock, 2));
-        }
-
-        [Fact]
-        public void CanReadPoemWithStreamReader()
-        {
-            var XZBlock = new XZBlock(CompressedStream, CheckType.CRC64, 8);
-            var sr = new StreamReader(XZBlock);
-            Assert.Equal(sr.ReadToEnd(), Original);
-        }
-
-        [Fact]
-        public void NoopWhenNoPadding()
-        {
-            // CompressedStream's only block has no padding.
-            var XZBlock = new XZBlock(CompressedStream, CheckType.CRC64, 8);
-            var sr = new StreamReader(XZBlock);
-            sr.ReadToEnd();
-            Assert.Equal(0L, CompressedStream.Position % 4L);
-        }
-
-        [Fact]
-        public void SkipsPaddingWhenPresent()
-        {
-            // CompressedIndexedStream's first block has 1-byte padding.
-            var XZBlock = new XZBlock(CompressedIndexedStream, CheckType.CRC64, 8);
-            var sr = new StreamReader(XZBlock);
-            sr.ReadToEnd();
-            Assert.Equal(0L, CompressedIndexedStream.Position % 4L);
-        }
-    }
-}

tests/SharpCompress.Test/Xz/XZHeaderTests.cs

@@ -1,78 +0,0 @@
-using SharpCompress.Compressors.Xz;
-using System.IO;
-using Xunit;
-
-namespace SharpCompress.Test.Xz
-{
-    public class XZHeaderTests : XZTestsBase
-    {
-        [Fact]
-        public void ChecksMagicNumber()
-        {
-            var bytes = Compressed.Clone() as byte[];
-            bytes[3]++;
-            using (Stream badMagicNumberStream = new MemoryStream(bytes))
-            {
-                BinaryReader br = new BinaryReader(badMagicNumberStream);
-                var header = new XZHeader(br);
-                var ex = Assert.Throws<InvalidDataException>(() => { header.Process(); });
-                Assert.Equal("Invalid XZ Stream", ex.Message);
-            }
-        }
-
-        [Fact]
-        public void CorruptHeaderThrows()
-        {
-            var bytes = Compressed.Clone() as byte[];
-            bytes[8]++;
-            using (Stream badCrcStream = new MemoryStream(bytes))
-            {
-                BinaryReader br = new BinaryReader(badCrcStream);
-                var header = new XZHeader(br);
-                var ex = Assert.Throws<InvalidDataException>(() => { header.Process(); });
-                Assert.Equal("Stream header corrupt", ex.Message);
-            }
-        }
-
-        [Fact]
-        public void BadVersionIfCrcOkButStreamFlagUnknown() { 
-            var bytes = Compressed.Clone() as byte[];
-            byte[] streamFlags = { 0x00, 0xF4 };
-            byte[] crc = Crc32.Compute(streamFlags).ToLittleEndianBytes();
-            streamFlags.CopyTo(bytes, 6);
-            crc.CopyTo(bytes, 8);
-            using (Stream badFlagStream = new MemoryStream(bytes))
-            {
-                BinaryReader br = new BinaryReader(badFlagStream);
-                var header = new XZHeader(br);
-                var ex = Assert.Throws<InvalidDataException>(() => { header.Process(); });
-                Assert.Equal("Unknown XZ Stream Version", ex.Message);
-            }
-}
-
-        [Fact]
-        public void ProcessesBlockCheckType()
-        {
-            BinaryReader br = new BinaryReader(CompressedStream);
-            var header = new XZHeader(br);
-            header.Process();
-            Assert.Equal(CheckType.CRC64, header.BlockCheckType);
-        }
-
-        [Fact]
-        public void CanCalculateBlockCheckSize()
-        {
-            BinaryReader br = new BinaryReader(CompressedStream);
-            var header = new XZHeader(br);
-            header.Process();
-            Assert.Equal(8, header.BlockCheckSize);
-        }
-
-        [Fact]
-        public void ProcessesStreamHeaderFromFactory()
-        {
-            var header = XZHeader.FromStream(CompressedStream);
-            Assert.Equal(CheckType.CRC64, header.BlockCheckType);
-        }
-    }
-}

tests/SharpCompress.Test/Xz/XZIndexTests.cs

@@ -1,95 +0,0 @@
-using SharpCompress.Compressors.Xz;
-using System.IO;
-using Xunit;
-
-namespace SharpCompress.Test.Xz
-{
-    public class XZIndexTests : XZTestsBase
-    {
-        protected override void RewindEmpty(Stream stream)
-        {
-            stream.Position = 12;
-        }
-
-        protected override void Rewind(Stream stream)
-        {
-            stream.Position = 356;
-        }
-
-        protected override void RewindIndexed(Stream stream)
-        {
-            stream.Position = 612;
-        }
-
-        [Fact]
-        public void RecordsStreamStartOnInit()
-        {
-            using (Stream badStream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }))
-            {
-                BinaryReader br = new BinaryReader(badStream);
-                var index = new XZIndex(br, false);
-                Assert.Equal(0, index.StreamStartPosition);
-            }
-        }
-
-        [Fact]
-        public void ThrowsIfHasNoIndexMarker()
-        {
-            using (Stream badStream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }))
-            {
-                BinaryReader br = new BinaryReader(badStream);
-                var index = new XZIndex(br, false);
-                Assert.Throws<InvalidDataException>( () => index.Process());
-            }
-        }
-
-        [Fact]
-        public void ReadsNoRecord()
-        {
-            BinaryReader br = new BinaryReader(CompressedEmptyStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)0, index.NumberOfRecords);
-        }
-
-        [Fact]
-        public void ReadsOneRecord()
-        {
-            BinaryReader br = new BinaryReader(CompressedStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)1, index.NumberOfRecords);
-        }
-
-        [Fact]
-        public void ReadsMultipleRecords()
-        {
-            BinaryReader br = new BinaryReader(CompressedIndexedStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)2, index.NumberOfRecords);
-        }
-
-        [Fact]
-        public void ReadsFirstRecord()
-        {
-            BinaryReader br = new BinaryReader(CompressedStream);
-            var index = new XZIndex(br, false);
-            index.Process();
-            Assert.Equal((ulong)OriginalBytes.Length, index.Records[0].UncompressedSize);
-        }
-
-        [Fact]
-        public void SkipsPadding()
-        {
-            // Index with 3-byte padding.
-            using (Stream badStream = new MemoryStream(new byte[] { 0x00, 0x01, 0x10, 0x80, 0x01, 0x00, 0x00, 0x00, 0xB1, 0x01, 0xD9, 0xC9, 0xFF }))
-            {
-                BinaryReader br = new BinaryReader(badStream);
-                var index = new XZIndex(br, false);
-                index.Process();
-                Assert.Equal(0L, badStream.Position % 4L);
-            }
-        }
-    }
-}