Attempt to use native zlib for gzip. Need lower level access

Enable test
Doing some resharper clean up
2026-02-04 05:25:00 +00:00 · 2017-05-19 11:47:25 +01:00 · 2017-05-19 11:03:31 +01:00 · 2017-05-19 10:52:49 +01:00 · 2017-05-19 10:15:19 +01:00 · 2017-05-19 10:10:23 +01:00
379 changed files with 12065 additions and 8790 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,14 +1,16 @@
-**/bin/*
-**/obj/*
-_ReSharper.SharpCompress/
-bin/
-*.suo
-*.user
-TestArchives/Scratch/
-TestArchives/Scratch2/
-TestResults/
-*.nupkg
-packages/*/
-project.lock.json
-test/TestArchives/Scratch
-.vs
+**/bin/*
+**/obj/*
+_ReSharper.SharpCompress/
+bin/
+*.suo
+*.user
+TestArchives/Scratch/
+TestArchives/Scratch2/
+TestResults/
+*.nupkg
+packages/*/
+project.lock.json
+tests/TestArchives/Scratch
+.vs
+tools
+.vscode
--- a/FORMATS.md
+++ b/FORMATS.md
@@ -0,0 +1,36 @@
+# Archive Formats
+
+## Accessing Archives
+
+Archive classes allow random access to a seekable stream.
+Reader classes allow forward-only reading
+Writer classes allow forward-only Writing
+
+## Supported Format Table
+
+| Archive Format | Compression Format(s) | Compress/Decompress | Archive API | Reader API | Writer API |
+| --- | --- | --- | --- | --- | --- |
+| Rar | Rar | Decompress (1) | RarArchive | RarReader | N/A |
+| Zip (2) | None, DEFLATE, BZip2, LZMA/LZMA2, PPMd | Both | ZipArchive | ZipReader | ZipWriter |
+| Tar | None, BZip2, GZip, LZip | Both | TarArchive | TarReader | TarWriter (3)  |
+| GZip (single file) | GZip | Both | GZipArchive | GZipReader | GZipWriter |
+| 7Zip (4) | LZMA, LZMA2, BZip2, PPMd, BCJ, BCJ2, Deflate | Decompress | SevenZipArchive | N/A | N/A |
+
+ 1. SOLID Rars are only supported in the RarReader API.
+ 2. Zip format supports pkware and WinzipAES encryption.  However, encrypted LZMA is not supported.  Zip64 reading is supported.
+ 3. The Tar format requires a file size in the header.  If no size is specified to the TarWriter and the stream is not seekable, then an exception will be thrown.
+ 4. The 7Zip format doesn't allow for reading as a forward-only stream so 7Zip is only supported through the Archive API
+
+## Compressors
+
+For those who want to directly compress/decompress bits
+
+| Compressor | Compress/Decompress |
+| --- | --- |
+| BZip2Stream | Both |
+| GZipStream | Both |
+| DeflateStream | Both |
+| LZMAStream | Both |
+| PPMdStream | Both |
+| ADCStream | Decompress |
+| LZipStream | Decompress |
--- a/README.md
+++ b/README.md
@@ -4,10 +4,12 @@ SharpCompress is a compression library for .NET/Mono/Silverlight/WP7 that can un

 The major feature is support for non-seekable streams so large files can be processed on the fly (i.e. download stream). 

+[![Build status](https://ci.appveyor.com/api/projects/status/voxg971oemmvxh1e/branch/master?svg=true)](https://ci.appveyor.com/project/adamhathcock/sharpcompress/branch/master)
+
 ## Need Help?
 Post Issues on Github!

-Check the [Supported Formats](https://github.com/adamhathcock/sharpcompress/wiki/Supported-Formats) and [basic samples.](https://github.com/adamhathcock/sharpcompress/wiki/API-Examples)
+Check the [Supported Formats](FORMATS.md) and [Basic Usage.](USAGE.md)

 ## A Simple Request

@@ -23,24 +25,64 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un

 * RAR 5 support
 * 7Zip writing
-* Zip64
+* Zip64 (Need writing and extend Reading)
 * Multi-volume Zip support.
-
-## In-Progress
-
 * RAR5 support
-* DNX/NET Core support
-* xproj targeting

 ## Version Log

+### Version 0.15.2
+
+* [Fix invalid headers](https://github.com/adamhathcock/sharpcompress/pull/210) - fixes an issue creating large-ish zip archives that was introduced with zip64 reading.
+
+### Version 0.15.1
+
+* [Zip64 extending information and ZipReader](https://github.com/adamhathcock/sharpcompress/pull/206)
+
+### Version 0.15.0
+
+* [Add zip64 support for ZipArchive extraction](https://github.com/adamhathcock/sharpcompress/pull/205)
+
+### Version 0.14.1
+
+* [.NET Assemblies aren't strong named](https://github.com/adamhathcock/sharpcompress/issues/158)
+* [Pkware encryption for Zip files didn't allow for multiple reads of an entry](https://github.com/adamhathcock/sharpcompress/issues/197)
+* [GZip Entry couldn't be read multiple times](https://github.com/adamhathcock/sharpcompress/issues/198)
+
+### Version 0.14.0
+
+* [Support for LZip reading in for Tars](https://github.com/adamhathcock/sharpcompress/pull/191)
+
+### Version 0.13.1
+
+* [Fix null password on ReaderFactory. Fix null options on SevenZipArchive](https://github.com/adamhathcock/sharpcompress/pull/188)
+* [Make PpmdProperties lazy to avoid unnecessary allocations.](https://github.com/adamhathcock/sharpcompress/pull/185)
+
+### Version 0.13.0
+
+* Breaking change: Big refactor of Options on API.
+* 7Zip supports Deflate
+
+### Version 0.12.4
+
+* Forward only zip issue fix https://github.com/adamhathcock/sharpcompress/issues/160
+* Try to fix frameworks again by copying targets from JSON.NET
+
+### Version 0.12.3
+
+* 7Zip fixes https://github.com/adamhathcock/sharpcompress/issues/73
+* Maybe all profiles will work with project.json now
+
 ### Version 0.12.2
+
 * Support Profile 259 again

 ### Version 0.12.1
+
 * Support Silverlight 5

 ### Version 0.12.0
+
 * .NET Core RTM!
 * Bug fix for Tar long paths

@@ -93,8 +135,6 @@ I'm always looking for help or ideas. Please submit code or email with ideas. Un
 * Embedded some BouncyCastle crypto classes to allow RAR Decryption and Winzip AES Decryption in Portable and Windows Store DLLs
 * Built in Release (I think)

-Some Help/Discussion: https://sharpcompress.codeplex.com/discussions
-
 7Zip implementation based on: https://code.google.com/p/managed-lzma/

 LICENSE
--- a/SharpCompress.sln
+++ b/SharpCompress.sln
@@ -1,44 +1,38 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.24720.0
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F18F1765-4A02-42FD-9BEF-F0E2FCBD9D17}"
-	ProjectSection(SolutionItems) = preProject
-		global.json = global.json
-	EndProjectSection
-EndProject
-Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SharpCompress", "src\SharpCompress\SharpCompress.xproj", "{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3C5BE746-03E5-4895-9988-0B57F162F86C}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{0F0901FF-E8D9-426A-B5A2-17C7F47C1529}"
-EndProject
-Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "SharpCompress.Test", "test\SharpCompress.Test\SharpCompress.Test.xproj", "{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}"
-	ProjectSection(ProjectDependencies) = postProject
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {FD19DDD8-72B2-4024-8665-0D1F7A2AA998}
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.Build.0 = Release|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
-		{3B80E585-A2F3-4666-8F69-C7FFDA0DD7E5} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26430.6
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F18F1765-4A02-42FD-9BEF-F0E2FCBD9D17}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{3C5BE746-03E5-4895-9988-0B57F162F86C}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{0F0901FF-E8D9-426A-B5A2-17C7F47C1529}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress", "src\SharpCompress\SharpCompress.csproj", "{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SharpCompress.Test", "tests\SharpCompress.Test\SharpCompress.Test.csproj", "{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{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
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{FD19DDD8-72B2-4024-8665-0D1F7A2AA998} = {3C5BE746-03E5-4895-9988-0B57F162F86C}
+		{F2B1A1EB-0FA6-40D0-8908-E13247C7226F} = {0F0901FF-E8D9-426A-B5A2-17C7F47C1529}
+	EndGlobalSection
+EndGlobal
--- a/SharpCompress.sln.DotSettings
+++ b/SharpCompress.sln.DotSettings
@@ -1,6 +1,119 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/Environment/InjectedLayers/FileInjectedLayer/=181069325DAB1C4287CD564D6CDDEDB3/AbsolutePath/@EntryValue">D:\Git\sharpcompress\SharpCompress\sharpcompress.DotSettings</s:String>
-	<s:String x:Key="/Default/Environment/InjectedLayers/FileInjectedLayer/=181069325DAB1C4287CD564D6CDDEDB3/RelativePath/@EntryValue">..\SharpCompress\sharpcompress.DotSettings</s:String>
-	<s:Boolean x:Key="/Default/Environment/InjectedLayers/FileInjectedLayer/=181069325DAB1C4287CD564D6CDDEDB3/@KeyIndexDefined">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/InjectedLayers/InjectedLayerCustomization/=File181069325DAB1C4287CD564D6CDDEDB3/@KeyIndexDefined">True</s:Boolean>
-	<s:Double x:Key="/Default/Environment/InjectedLayers/InjectedLayerCustomization/=File181069325DAB1C4287CD564D6CDDEDB3/RelativePriority/@EntryValue">1</s:Double></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArgumentsStyleNamedExpression/@EntryIndexedValue">DO_NOT_SHOW</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Fdowhile/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Ffixed/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Ffor/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Fforeach/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Fifelse/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Flock/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Fusing/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ArrangeBraces_005Fwhile/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=MethodSupportsCancellation/@EntryIndexedValue">ERROR</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=RedundantExplicitParamsArrayCreation/@EntryIndexedValue">DO_NOT_SHOW</s:String>
+	
+	<s:String x:Key="/Default/CodeStyle/CodeCleanup/Profiles/=Basic_0020Clean/@EntryIndexedValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;&lt;Profile name="Basic Clean"&gt;&lt;CSOptimizeUsings&gt;&lt;OptimizeUsings&gt;True&lt;/OptimizeUsings&gt;&lt;EmbraceInRegion&gt;False&lt;/EmbraceInRegion&gt;&lt;RegionName&gt;&lt;/RegionName&gt;&lt;/CSOptimizeUsings&gt;&lt;CSShortenReferences&gt;True&lt;/CSShortenReferences&gt;&lt;CSRemoveCodeRedundancies&gt;True&lt;/CSRemoveCodeRedundancies&gt;&lt;CSMakeFieldReadonly&gt;True&lt;/CSMakeFieldReadonly&gt;&lt;CSCodeStyleAttributes ArrangeTypeAccessModifier="False" ArrangeTypeMemberAccessModifier="False" SortModifiers="False" RemoveRedundantParentheses="False" AddMissingParentheses="False" ArrangeBraces="True" ArrangeAttributes="False" ArrangeArgumentsStyle="False" /&gt;&lt;RemoveCodeRedundancies&gt;True&lt;/RemoveCodeRedundancies&gt;&lt;CSUseAutoProperty&gt;True&lt;/CSUseAutoProperty&gt;&lt;CSMakeAutoPropertyGetOnly&gt;True&lt;/CSMakeAutoPropertyGetOnly&gt;&lt;CSReformatCode&gt;True&lt;/CSReformatCode&gt;&lt;/Profile&gt;</s:String>
+	
+	<s:String x:Key="/Default/CodeStyle/CodeCleanup/SilentCleanupProfile/@EntryValue">Basic Clean</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/APPLY_ON_COMPLETION/@EntryValue">True</s:Boolean>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/ARGUMENTS_NAMED/@EntryValue">Named</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOR/@EntryValue">Required</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_FOREACH/@EntryValue">Required</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_IFELSE/@EntryValue">Required</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpCodeStyle/BRACES_FOR_WHILE/@EntryValue">Required</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_FIRST_ARG_BY_PAREN/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_LINQ_QUERY/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARGUMENT/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_CALLS_CHAIN/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXPRESSION/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_EXTENDS_LIST/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_FOR_STMT/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_PARAMETER/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTIPLE_DECLARATION/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_CONSTRAINS/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_LIST/@EntryValue">True</s:Boolean>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_AFTER_START_COMMENT/@EntryValue">0</s:Int64>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_BEFORE_SINGLE_LINE_COMMENT/@EntryValue">1</s:Int64>
+	
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_ATTRIBUTE_STYLE/@EntryValue">SEPARATE</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_FIXED_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_FOR_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_FOREACH_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_IFELSE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_USING_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/FORCE_WHILE_BRACES_STYLE/@EntryValue">ALWAYS_ADD</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_ANONYMOUS_METHOD_BLOCK/@EntryValue">True</s:Boolean>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_CONSTRUCTOR_INITIALIZER_ON_SAME_LINE/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_FIELD_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSORHOLDER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_ACCESSOR_ATTRIBUTE_ON_SAME_LINE/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_SIMPLE_INITIALIZER_ON_SINGLE_LINE/@EntryValue">True</s:Boolean>
+	
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_WHILE_ON_NEW_LINE/@EntryValue">True</s:Boolean>
+	
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SIMPLE_EMBEDDED_STATEMENT_STYLE/@EntryValue">LINE_BREAK</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_AFTER_TYPECAST_PARENTHESES/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_AROUND_ARROW_OP/@EntryValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_AROUND_MULTIPLICATIVE_OP/@EntryValue">True</s:Boolean>
+	
+	
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_BEFORE_SIZEOF_PARENTHESES/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/SPACE_BEFORE_TYPEOF_PARENTHESES/@EntryValue">False</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/STICK_COMMENT/@EntryValue">False</s:Boolean>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARGUMENTS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_ARRAY_INITIALIZER_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_EXTENDS_LIST_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_LINES/@EntryValue">False</s:Boolean>
+	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/WRAP_PARAMETERS_STYLE/@EntryValue">CHOP_IF_LONG</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForBuiltInTypes/@EntryValue">UseVarWhenEvident</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForOtherTypes/@EntryValue">UseVarWhenEvident</s:String>
+	<s:String x:Key="/Default/CodeStyle/CSharpVarKeywordUsage/ForSimpleTypes/@EntryValue">UseVarWhenEvident</s:String>
+	
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateInstanceFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="_" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticFields/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=PrivateStaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/PredefinedNamingRules/=StaticReadonly/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AA_BB" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FCONSTANT/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FCLASS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FCONSTRUCTOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FGLOBAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLABEL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLOCAL_005FCONSTRUCTOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLOCAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FOBJECT_005FPROPERTY_005FOF_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FPARAMETER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FCLASS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FENUM/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FENUM_005FMEMBER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FINTERFACE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="I" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE_005FEXPORTED/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE_005FLOCAL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FTYPE_005FPARAMETER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="T" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FHTML_005FCONTROL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FTAG_005FNAME/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FTAG_005FPREFIX/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
+	<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_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>
--- a/SharpCompress.snk
+++ b/SharpCompress.snk
--- a/USAGE.md
+++ b/USAGE.md
@@ -0,0 +1,131 @@
+# SharpCompress Usage
+
+## Stream Rules
+When dealing with Streams, the rule should be that you don't close a stream you didn't create.  This, in effect, should mean you should always put a Stream in a using block to dispose it.
+
+However, the .NET Framework often has classes that will dispose streams by default to make things "easy" like the following:
+
+```C#
+using (var reader = new StreamReader(File.Open("foo")))
+{
+    ...
+}
+```
+
+In this example, reader should get disposed.  However, stream rules should say the the `FileStream` created by `File.Open` should remain open.  However, the .NET Framework closes it for you by default unless you override the constructor.  In general, you should be writing Stream code like this:
+
+```C#
+using (var fileStream = File.Open("foo"))
+using (var reader = new StreamReader(fileStream))
+{
+    ...
+}
+```
+
+To deal with the "correct" rules as well as the expectations of users, I've decided on this:
+
+* When writing, leave streams open.
+* When reading, close streams 
+
+To be explicit though, consider always using the overloads that use `ReaderOptions` or `WriterOptions` and explicitly set `LeaveStreamOpen` the way you want.
+
+## Samples
+
+Also, look over the tests for more thorough [examples](https://github.com/adamhathcock/sharpcompress/tree/master/test/SharpCompress.Test)
+
+### Create Zip Archive from all files in a directory to a file
+
+```C#
+using (var archive = ZipArchive.Create())
+{
+    archive.AddAllFromDirectory("D:\\temp");
+    archive.SaveTo("C:\\temp.zip", CompressionType.Deflate);
+}
+```
+
+
+### Create Zip Archive from all files in a directory and save in memory
+
+```C#
+
+var memoryStream = new MemoryStream();
+using (var archive = ZipArchive.Create())
+{
+    archive.AddAllFromDirectory("D:\\temp");
+    archive.SaveTo(memoryStream, new WriterOptions(CompressionType.Deflate)
+                                {
+                                    LeaveStreamOpen = true
+                                });
+}
+//reset memoryStream to be usable now
+memoryStream.Position = 0;
+```
+
+### Extract all files from a Rar file to a directory using RarArchive
+
+```C#
+using (var archive = RarArchive.Open("Test.rar"))
+{
+    foreach (var entry in archive.Entries.Where(entry => !entry.IsDirectory))
+    {
+        entry.WriteToDirectory("D:\\temp", new ExtractionOptions()
+        {
+            ExtractFullPath = true,
+            Overwrite = true
+        });
+    }
+}
+```
+
+### Use ReaderFactory to autodetect archive type and Open the entry stream
+
+```C#
+using (Stream stream = File.OpenRead("Tar.tar.bz2"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            Console.WriteLine(reader.Entry.Key);
+            reader.WriteEntryToDirectory(@"C:\temp", new ExtractionOptions()
+            {
+                ExtractFullPath = true,
+                Overwrite = true
+            });
+        }
+    }
+}
+```
+
+### Use ReaderFactory to autodetect archive type and Open the entry stream
+
+```C#
+using (Stream stream = File.OpenRead("Tar.tar.bz2"))
+using (var reader = ReaderFactory.Open(stream))
+{
+    while (reader.MoveToNextEntry())
+    {
+        if (!reader.Entry.IsDirectory)
+        {
+            using (var entryStream = reader.OpenEntryStream())
+            {
+                entryStream.CopyTo(...);
+            }
+        }
+    }
+}
+```
+
+### Use WriterFactory to write all files from a directory in a streaming manner.
+
+```C#
+using (Stream stream = File.OpenWrite("C:\\temp.tgz"))
+using (var writer = WriterFactory.Open(stream, ArchiveType.Tar, new WriterOptions(CompressionType.GZip)
+                                                {
+                                                    LeaveOpenStream = true
+                                                }))
+{
+    writer.WriteAll("D:\\temp", "*", SearchOption.AllDirectories);
+}
+```
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -0,0 +1,28 @@
+version: '{build}'
+image: Visual Studio 2017
+
+pull_requests:
+  do_not_increment_build_number: true
+
+branches:
+  only:
+  - master
+
+nuget:
+  disable_publish_on_pr: true
+
+before_build:
+  - cmd: dotnet restore
+
+build:
+  parallel: true
+  verbosity: minimal
+
+after_build:
+- dotnet pack "src\SharpCompress\SharpCompress.csproj" -c Release
+
+test_script:
+- dotnet test --no-build .\tests\SharpCompress.Test\SharpCompress.Test.csproj
+
+artifacts:
+- path: src\SharpCompress\bin\Release\*.nupkg
--- a/global.json
+++ b/global.json
@@ -1,3 +0,0 @@
-{
-    "projects": ["src","test"]
-}
--- a/src/SharpCompress/Archive/GZip/GZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archive/GZip/GZipWritableArchiveEntry.cs
@@ -1,111 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Common;
-using SharpCompress.IO;
-
-namespace SharpCompress.Archive.GZip
-{
-    internal class GZipWritableArchiveEntry : GZipArchiveEntry, IWritableArchiveEntry
-    {
-        private readonly string path;
-        private readonly long size;
-        private readonly DateTime? lastModified;
-        private readonly bool closeStream;
-        private readonly Stream stream;
-
-        internal GZipWritableArchiveEntry(GZipArchive archive, Stream stream,
-                                          string path, long size, DateTime? lastModified, bool closeStream)
-            : base(archive, null)
-        {
-            this.stream = stream;
-            this.path = path;
-            this.size = size;
-            this.lastModified = lastModified;
-            this.closeStream = closeStream;
-        }
-
-        public override long Crc
-        {
-            get { return 0; }
-        }
-
-        public override string Key
-        {
-            get { return path; }
-        }
-
-        public override long CompressedSize
-        {
-            get { return 0; }
-        }
-
-        public override long Size
-        {
-            get { return size; }
-        }
-
-        public override DateTime? LastModifiedTime
-        {
-            get { return lastModified; }
-        }
-
-        public override DateTime? CreatedTime
-        {
-            get { return null; }
-        }
-
-        public override DateTime? LastAccessedTime
-        {
-            get { return null; }
-        }
-
-        public override DateTime? ArchivedTime
-        {
-            get { return null; }
-        }
-
-        public override bool IsEncrypted
-        {
-            get { return false; }
-        }
-
-        public override bool IsDirectory
-        {
-            get { return false; }
-        }
-
-        public override bool IsSplit
-        {
-            get { return false; }
-        }
-
-        internal override IEnumerable<FilePart> Parts
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        Stream IWritableArchiveEntry.Stream
-        {
-            get
-            {
-                return stream;
-            }
-        }
-
-        public override Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream)
-            {
-                stream.Dispose();
-            }
-        }
-    }
-}
--- a/src/SharpCompress/Archive/Tar/TarWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archive/Tar/TarWritableArchiveEntry.cs
@@ -1,110 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Common;
-using SharpCompress.IO;
-
-namespace SharpCompress.Archive.Tar
-{
-    internal class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
-    {
-        private readonly string path;
-        private readonly long size;
-        private readonly DateTime? lastModified;
-        private readonly bool closeStream;
-        private readonly Stream stream;
-
-        internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType,
-                                         string path, long size, DateTime? lastModified, bool closeStream)
-            : base(archive, null, compressionType)
-        {
-            this.stream = stream;
-            this.path = path;
-            this.size = size;
-            this.lastModified = lastModified;
-            this.closeStream = closeStream;
-        }
-
-        public override long Crc
-        {
-            get { return 0; }
-        }
-
-        public override string Key
-        {
-            get { return path; }
-        }
-
-        public override long CompressedSize
-        {
-            get { return 0; }
-        }
-
-        public override long Size
-        {
-            get { return size; }
-        }
-
-        public override DateTime? LastModifiedTime
-        {
-            get { return lastModified; }
-        }
-
-        public override DateTime? CreatedTime
-        {
-            get { return null; }
-        }
-
-        public override DateTime? LastAccessedTime
-        {
-            get { return null; }
-        }
-
-        public override DateTime? ArchivedTime
-        {
-            get { return null; }
-        }
-
-        public override bool IsEncrypted
-        {
-            get { return false; }
-        }
-
-        public override bool IsDirectory
-        {
-            get { return false; }
-        }
-
-        public override bool IsSplit
-        {
-            get { return false; }
-        }
-
-        internal override IEnumerable<FilePart> Parts
-        {
-            get { throw new NotImplementedException(); }
-        }
-        Stream IWritableArchiveEntry.Stream
-        {
-            get
-            {
-                return stream;
-            }
-        }
-
-        public override Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream)
-            {
-                stream.Dispose();
-            }
-        }
-    }
-}
--- a/src/SharpCompress/Archive/Zip/ZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archive/Zip/ZipWritableArchiveEntry.cs
@@ -1,113 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Common;
-using SharpCompress.IO;
-
-namespace SharpCompress.Archive.Zip
-{
-    internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
-    {
-        private readonly string path;
-        private readonly long size;
-        private readonly DateTime? lastModified;
-        private readonly bool closeStream;
-        private readonly Stream stream;
-        private bool isDisposed;
-
-        internal ZipWritableArchiveEntry(ZipArchive archive, Stream stream, string path, long size,
-                                         DateTime? lastModified, bool closeStream)
-            : base(archive, null)
-        {
-            this.stream = stream;
-            this.path = path;
-            this.size = size;
-            this.lastModified = lastModified;
-            this.closeStream = closeStream;
-        }
-
-        public override long Crc
-        {
-            get { return 0; }
-        }
-
-        public override string Key
-        {
-            get { return path; }
-        }
-
-        public override long CompressedSize
-        {
-            get { return 0; }
-        }
-
-        public override long Size
-        {
-            get { return size; }
-        }
-
-        public override DateTime? LastModifiedTime
-        {
-            get { return lastModified; }
-        }
-
-        public override DateTime? CreatedTime
-        {
-            get { return null; }
-        }
-
-        public override DateTime? LastAccessedTime
-        {
-            get { return null; }
-        }
-
-        public override DateTime? ArchivedTime
-        {
-            get { return null; }
-        }
-
-        public override bool IsEncrypted
-        {
-            get { return false; }
-        }
-
-        public override bool IsDirectory
-        {
-            get { return false; }
-        }
-
-        public override bool IsSplit
-        {
-            get { return false; }
-        }
-
-        internal override IEnumerable<FilePart> Parts
-        {
-            get { throw new NotImplementedException(); }
-        }
-
-        Stream IWritableArchiveEntry.Stream
-        {
-            get
-            {
-                return stream;
-            }
-        }
-
-        public override Stream OpenEntryStream()
-        {
-            //ensure new stream is at the start, this could be reset
-            stream.Seek(0, SeekOrigin.Begin);
-            return new NonDisposingStream(stream);
-        }
-
-        internal override void Close()
-        {
-            if (closeStream && !isDisposed)
-            {
-                stream.Dispose();
-                isDisposed = true;
-            }
-        }
-    }
-}
--- a/src/SharpCompress/Archives/AbstractArchive.cs
+++ b/src/SharpCompress/Archives/AbstractArchive.cs
@@ -3,9 +3,9 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
-using SharpCompress.Reader;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IArchiveExtractionListener
        where TEntry : IArchiveEntry
@@ -20,31 +20,33 @@ namespace SharpCompress.Archive
        public event EventHandler<CompressedBytesReadEventArgs> CompressedBytesRead;
        public event EventHandler<FilePartExtractionBeginEventArgs> FilePartExtractionBegin;

-        protected string Password { get; private set; }
+        protected ReaderOptions ReaderOptions { get; }
+
+        private bool disposed;

 #if !NO_FILE
-        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, Options options, string password)
+        internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
        {
            Type = type;
-            Password = password;
            if (!fileInfo.Exists)
            {
                throw new ArgumentException("File does not exist: " + fileInfo.FullName);
            }
-            options = (Options) FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo, options));
+            ReaderOptions = readerOptions;
+            readerOptions.LeaveStreamOpen = false;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(fileInfo));
            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
        }


-        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file, Options options);
+        protected abstract IEnumerable<TVolume> LoadVolumes(FileInfo file);
 #endif

-        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, Options options, string password)
+        internal AbstractArchive(ArchiveType type, IEnumerable<Stream> streams, ReaderOptions readerOptions)
        {
            Type = type;
-            Password = password;
-            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams), options));
+            ReaderOptions = readerOptions;
+            lazyVolumes = new LazyReadOnlyCollection<TVolume>(LoadVolumes(streams.Select(CheckStreams)));
            lazyEntries = new LazyReadOnlyCollection<TEntry>(LoadEntries(Volumes));
        }

@@ -54,22 +56,17 @@ namespace SharpCompress.Archive
            lazyVolumes = new LazyReadOnlyCollection<TVolume>(Enumerable.Empty<TVolume>());
            lazyEntries = new LazyReadOnlyCollection<TEntry>(Enumerable.Empty<TEntry>());
        }
-        public ArchiveType Type { get; private set; }
+
+        public ArchiveType Type { get; }

        void IArchiveExtractionListener.FireEntryExtractionBegin(IArchiveEntry entry)
        {
-            if (EntryExtractionBegin != null)
-            {
-                EntryExtractionBegin(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-            }
+            EntryExtractionBegin?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
        }

        void IArchiveExtractionListener.FireEntryExtractionEnd(IArchiveEntry entry)
        {
-            if (EntryExtractionEnd != null)
-            {
-                EntryExtractionEnd(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
-            }
+            EntryExtractionEnd?.Invoke(this, new ArchiveExtractionEventArgs<IArchiveEntry>(entry));
        }

        private static Stream CheckStreams(Stream stream)
@@ -84,49 +81,29 @@ namespace SharpCompress.Archive
        /// <summary>
        /// Returns an ReadOnlyCollection of all the RarArchiveEntries across the one or many parts of the RarArchive.
        /// </summary>
-        public virtual ICollection<TEntry> Entries
-        {
-            get { return lazyEntries; }
-        }
+        public virtual ICollection<TEntry> Entries { get { return lazyEntries; } }

        /// <summary>
        /// Returns an ReadOnlyCollection of all the RarArchiveVolumes across the one or many parts of the RarArchive.
        /// </summary>
-        public ICollection<TVolume> Volumes
-        {
-            get { return lazyVolumes; }
-        }
+        public ICollection<TVolume> Volumes { get { return lazyVolumes; } }

        /// <summary>
        /// The total size of the files compressed in the archive.
        /// </summary>
-        public virtual long TotalSize
-        {
-            get { return Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize); }
-        }
+        public virtual long TotalSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.CompressedSize); } }

        /// <summary>
        /// The total size of the files as uncompressed in the archive.
        /// </summary>
-        public virtual long TotalUncompressSize
-        {
-            get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); }
-        }
+        public virtual long TotalUncompressSize { get { return Entries.Aggregate(0L, (total, cf) => total + cf.Size); } }

-        protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams, Options options);
+        protected abstract IEnumerable<TVolume> LoadVolumes(IEnumerable<Stream> streams);
        protected abstract IEnumerable<TEntry> LoadEntries(IEnumerable<TVolume> volumes);

-        IEnumerable<IArchiveEntry> IArchive.Entries
-        {
-            get { return Entries.Cast<IArchiveEntry>(); }
-        }
+        IEnumerable<IArchiveEntry> IArchive.Entries { get { return Entries.Cast<IArchiveEntry>(); } }

-        IEnumerable<IVolume> IArchive.Volumes
-        {
-            get { return lazyVolumes.Cast<IVolume>(); }
-        }
-
-        private bool disposed;
+        IEnumerable<IVolume> IArchive.Volumes { get { return lazyVolumes.Cast<IVolume>(); } }

        public virtual void Dispose()
        {
@@ -146,27 +123,21 @@ namespace SharpCompress.Archive

        void IExtractionListener.FireCompressedBytesRead(long currentPartCompressedBytes, long compressedReadBytes)
        {
-            if (CompressedBytesRead != null)
+            CompressedBytesRead?.Invoke(this, new CompressedBytesReadEventArgs
            {
-                CompressedBytesRead(this, new CompressedBytesReadEventArgs()
-                                              {
-                                                  CurrentFilePartCompressedBytesRead = currentPartCompressedBytes,
-                                                  CompressedBytesRead = compressedReadBytes
-                                              });
-            }
+                CurrentFilePartCompressedBytesRead = currentPartCompressedBytes,
+                CompressedBytesRead = compressedReadBytes
+            });
        }

        void IExtractionListener.FireFilePartExtractionBegin(string name, long size, long compressedSize)
        {
-            if (FilePartExtractionBegin != null)
+            FilePartExtractionBegin?.Invoke(this, new FilePartExtractionBeginEventArgs
            {
-                FilePartExtractionBegin(this, new FilePartExtractionBeginEventArgs()
-                                                  {
-                                                      CompressedSize = compressedSize,
-                                                      Size = size,
-                                                      Name = name,
-                                                  });
-            }
+                CompressedSize = compressedSize,
+                Size = size,
+                Name = name
+            });
        }

        /// <summary>
@@ -191,11 +162,7 @@ namespace SharpCompress.Archive
        /// <summary>
        /// Archive is SOLID (this means the Archive saved bytes by reusing information which helps for archives containing many small files).
        /// </summary>
-        public virtual bool IsSolid
-        {
-            get { return false; }
-        }
-
+        public virtual bool IsSolid { get { return false; } }

        /// <summary>
        /// The archive can find all the parts of the archive needed to fully extract the archive.  This forces the parsing of the entire archive.
--- a/src/SharpCompress/Archives/AbstractWritableArchive.cs
+++ b/src/SharpCompress/Archives/AbstractWritableArchive.cs
@@ -3,8 +3,10 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
+using SharpCompress.Readers;
+using SharpCompress.Writers;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public abstract class AbstractWritableArchive<TEntry, TVolume> : AbstractArchive<TEntry, TVolume>, IWritableArchive
        where TEntry : IArchiveEntry
@@ -21,14 +23,14 @@ namespace SharpCompress.Archive
        {
        }

-        internal AbstractWritableArchive(ArchiveType type, Stream stream, Options options)
-            : base(type, stream.AsEnumerable(), options, null)
+        internal AbstractWritableArchive(ArchiveType type, Stream stream, ReaderOptions readerFactoryOptions)
+            : base(type, stream.AsEnumerable(), readerFactoryOptions)
        {
        }

 #if !NO_FILE
-        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, Options options)
-            : base(type, fileInfo, options, null)
+        internal AbstractWritableArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerFactoryOptions)
+            : base(type, fileInfo, readerFactoryOptions)
        {
        }
 #endif
@@ -53,10 +55,7 @@ namespace SharpCompress.Archive
            modifiedEntries.AddRange(OldEntries.Concat(newEntries));
        }

-        private IEnumerable<TEntry> OldEntries
-        {
-            get { return base.Entries.Where(x => !removedEntries.Contains(x)); }
-        }
+        private IEnumerable<TEntry> OldEntries { get { return base.Entries.Where(x => !removedEntries.Contains(x)); } }

        public void RemoveEntry(TEntry entry)
        {
@@ -66,25 +65,25 @@ namespace SharpCompress.Archive
                RebuildModifiedCollection();
            }
        }
+
        void IWritableArchive.RemoveEntry(IArchiveEntry entry)
        {
            RemoveEntry((TEntry)entry);
        }

        public TEntry AddEntry(string key, Stream source,
-                             long size = 0, DateTime? modified = null)
+                               long size = 0, DateTime? modified = null)
        {
            return AddEntry(key, source, false, size, modified);
        }

-
        IArchiveEntry IWritableArchive.AddEntry(string key, Stream source, bool closeStream, long size, DateTime? modified)
        {
            return AddEntry(key, source, closeStream, size, modified);
        }

        public TEntry AddEntry(string key, Stream source, bool closeStream,
-                             long size = 0, DateTime? modified = null)
+                               long size = 0, DateTime? modified = null)
        {
            if (key.StartsWith("/")
                || key.StartsWith("\\"))
@@ -105,7 +104,7 @@ namespace SharpCompress.Archive
        {
            foreach (var path in Entries.Select(x => x.Key))
            {
-                var p = path.Replace('/','\\');
+                var p = path.Replace('/', '\\');
                if (p.StartsWith("\\"))
                {
                    p = p.Substring(1);
@@ -115,15 +114,15 @@ namespace SharpCompress.Archive
            return false;
        }

-        public void SaveTo(Stream stream, CompressionInfo compressionType)
+        public void SaveTo(Stream stream, WriterOptions options)
        {
            //reset streams of new entries
            newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-            SaveTo(stream, compressionType, OldEntries, newEntries);
+            SaveTo(stream, options, OldEntries, newEntries);
        }

        protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
-            bool closeStream)
+                                     bool closeStream)
        {
            if (!source.CanRead || !source.CanSeek)
            {
@@ -133,10 +132,9 @@ namespace SharpCompress.Archive
        }

        protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
-                                              bool closeStream);
+                                                      bool closeStream);

-        protected abstract void SaveTo(Stream stream, CompressionInfo compressionType,
-                                       IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
+        protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);

        public override void Dispose()
        {
--- a/src/SharpCompress/Archives/ArchiveFactory.cs
+++ b/src/SharpCompress/Archives/ArchiveFactory.cs
@@ -1,13 +1,14 @@
 using System;
 using System.IO;
-using SharpCompress.Archive.GZip;
-using SharpCompress.Archive.Rar;
-using SharpCompress.Archive.SevenZip;
-using SharpCompress.Archive.Tar;
-using SharpCompress.Archive.Zip;
+using SharpCompress.Archives.GZip;
+using SharpCompress.Archives.Rar;
+using SharpCompress.Archives.SevenZip;
+using SharpCompress.Archives.Tar;
+using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public class ArchiveFactory
    {
@@ -15,44 +16,44 @@ namespace SharpCompress.Archive
        /// Opens an Archive for random access
        /// </summary>
        /// <param name="stream"></param>
-        /// <param name="options"></param>
+        /// <param name="readerOptions"></param>
        /// <returns></returns>
-        public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen)
+        public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull("stream");
            if (!stream.CanRead || !stream.CanSeek)
            {
                throw new ArgumentException("Stream should be readable and seekable");
            }
-
+            readerOptions = readerOptions ?? new ReaderOptions();
            if (ZipArchive.IsZipFile(stream, null))
            {
                stream.Seek(0, SeekOrigin.Begin);
-                return ZipArchive.Open(stream, options, null);
+                return ZipArchive.Open(stream, readerOptions);
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (SevenZipArchive.IsSevenZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
-                return SevenZipArchive.Open(stream, options);
+                return SevenZipArchive.Open(stream, readerOptions);
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (GZipArchive.IsGZipFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
-                return GZipArchive.Open(stream, options);
+                return GZipArchive.Open(stream, readerOptions);
            }
            stream.Seek(0, SeekOrigin.Begin);
-            if (RarArchive.IsRarFile(stream, options))
+            if (RarArchive.IsRarFile(stream, readerOptions))
            {
-               stream.Seek(0, SeekOrigin.Begin);
-               return RarArchive.Open(stream, options);
+                stream.Seek(0, SeekOrigin.Begin);
+                return RarArchive.Open(stream, readerOptions);
            }
            stream.Seek(0, SeekOrigin.Begin);
            if (TarArchive.IsTarFile(stream))
            {
                stream.Seek(0, SeekOrigin.Begin);
-                return TarArchive.Open(stream, options);
+                return TarArchive.Open(stream, readerOptions);
            }
            throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
        }
@@ -62,52 +63,35 @@ namespace SharpCompress.Archive
            switch (type)
            {
                case ArchiveType.Zip:
-                    {
-                        return ZipArchive.Create();
-                    }
+                {
+                    return ZipArchive.Create();
+                }
                case ArchiveType.Tar:
-                    {
-                        return TarArchive.Create();
-                    }
+                {
+                    return TarArchive.Create();
+                }
                case ArchiveType.GZip:
-                    {
-                        return GZipArchive.Create();
-                    }
+                {
+                    return GZipArchive.Create();
+                }
                default:
-                    {
-                        throw new NotSupportedException("Cannot create Archives of type: " + type);
-                    }
+                {
+                    throw new NotSupportedException("Cannot create Archives of type: " + type);
+                }
            }
        }

 #if !NO_FILE
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        public static IArchive Open(string filePath)
-        {
-            return Open(filePath, Options.None);
-        }
-
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        public static IArchive Open(FileInfo fileInfo)
-        {
-            return Open(fileInfo, Options.None);
-        }

        /// <summary>
        /// Constructor expects a filepath to an existing file.
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="options"></param>
-        public static IArchive Open(string filePath, Options options)
+        public static IArchive Open(string filePath, ReaderOptions options = null)
        {
            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options);
+            return Open(new FileInfo(filePath), options ?? new ReaderOptions());
        }

        /// <summary>
@@ -115,15 +99,16 @@ namespace SharpCompress.Archive
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="options"></param>
-        public static IArchive Open(FileInfo fileInfo, Options options)
+        public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null)
        {
            fileInfo.CheckNotNull("fileInfo");
+            options = options ?? new ReaderOptions();
            using (var stream = fileInfo.OpenRead())
            {
                if (ZipArchive.IsZipFile(stream, null))
                {
                    stream.Dispose();
-                    return ZipArchive.Open(fileInfo, options, null);
+                    return ZipArchive.Open(fileInfo, options);
                }
                stream.Seek(0, SeekOrigin.Begin);
                if (SevenZipArchive.IsSevenZipFile(stream))
@@ -157,7 +142,7 @@ namespace SharpCompress.Archive
        /// Extract to specific directory, retaining filename
        /// </summary>
        public static void WriteToDirectory(string sourceArchive, string destinationDirectory,
-                                            ExtractOptions options = ExtractOptions.Overwrite)
+                                            ExtractionOptions options = null)
        {
            using (IArchive archive = Open(sourceArchive))
            {
--- a/src/SharpCompress/Archives/GZip/GZipArchive.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchive.cs
@@ -4,11 +4,12 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
-using SharpCompress.Reader;
-using SharpCompress.Reader.GZip;
-using SharpCompress.Writer.GZip;
+using SharpCompress.Readers;
+using SharpCompress.Readers.GZip;
+using SharpCompress.Writers;
+using SharpCompress.Writers.GZip;

-namespace SharpCompress.Archive.GZip
+namespace SharpCompress.Archives.GZip
 {
    public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
    {
@@ -17,62 +18,33 @@ namespace SharpCompress.Archive.GZip
        /// Constructor expects a filepath to an existing file.
        /// </summary>
        /// <param name="filePath"></param>
-        public static GZipArchive Open(string filePath)
-        {
-            return Open(filePath, Options.None);
-        }
-
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        public static GZipArchive Open(FileInfo fileInfo)
-        {
-            return Open(fileInfo, Options.None);
-        }
-
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="options"></param>
-        public static GZipArchive Open(string filePath, Options options)
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(string filePath, ReaderOptions readerOptions = null)
        {
            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options);
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }

        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        public static GZipArchive Open(FileInfo fileInfo, Options options)
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
        {
            fileInfo.CheckNotNull("fileInfo");
-            return new GZipArchive(fileInfo, options);
+            return new GZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
        }
 #endif
-
        /// <summary>
        /// Takes a seekable Stream as a source
        /// </summary>
        /// <param name="stream"></param>
-        public static GZipArchive Open(Stream stream)
+        /// <param name="readerOptions"></param>
+        public static GZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull("stream");
-            return Open(stream, Options.None);
-        }
-
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        public static GZipArchive Open(Stream stream, Options options)
-        {
-            stream.CheckNotNull("stream");
-            return new GZipArchive(stream, options);
+            return new GZipArchive(stream, readerOptions ?? new ReaderOptions());
        }

        public static GZipArchive Create()
@@ -81,19 +53,20 @@ namespace SharpCompress.Archive.GZip
        }

 #if !NO_FILE
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        internal GZipArchive(FileInfo fileInfo, Options options)
+
+/// <summary>
+/// Constructor with a FileInfo object to an existing file.
+/// </summary>
+/// <param name="fileInfo"></param>
+/// <param name="options"></param>
+        internal GZipArchive(FileInfo fileInfo, ReaderOptions options)
            : base(ArchiveType.GZip, fileInfo, options)
        {
        }

-        protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file, Options options)
+        protected override IEnumerable<GZipVolume> LoadVolumes(FileInfo file)
        {
-            return new GZipVolume(file, options).AsEnumerable();
+            return new GZipVolume(file, ReaderOptions).AsEnumerable();
        }

        public static bool IsGZipFile(string filePath)
@@ -122,7 +95,7 @@ namespace SharpCompress.Archive.GZip
        {
            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
            {
-                SaveTo(stream);
+                SaveTo(stream, new WriterOptions(CompressionType.GZip));
            }
        }
 #endif
@@ -135,13 +108,19 @@ namespace SharpCompress.Archive.GZip

            // workitem 8501: handle edge case (decompress empty stream)
            if (n == 0)
+            {
                return false;
+            }

            if (n != 10)
+            {
                return false;
+            }

            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            {
                return false;
+            }

            return true;
        }
@@ -151,7 +130,7 @@ namespace SharpCompress.Archive.GZip
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
-        internal GZipArchive(Stream stream, Options options)
+        internal GZipArchive(Stream stream, ReaderOptions options)
            : base(ArchiveType.GZip, stream, options)
        {
        }
@@ -161,13 +140,8 @@ namespace SharpCompress.Archive.GZip
        {
        }

-        public void SaveTo(Stream stream)
-        {
-            SaveTo(stream, CompressionType.GZip);
-        }
-
        protected override GZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                        bool closeStream)
+                                                                bool closeStream)
        {
            if (Entries.Any())
            {
@@ -176,7 +150,7 @@ namespace SharpCompress.Archive.GZip
            return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
        }

-        protected override void SaveTo(Stream stream, CompressionInfo compressionInfo,
+        protected override void SaveTo(Stream stream, WriterOptions options,
                                       IEnumerable<GZipArchiveEntry> oldEntries,
                                       IEnumerable<GZipArchiveEntry> newEntries)
        {
@@ -197,9 +171,9 @@ namespace SharpCompress.Archive.GZip
            }
        }

-        protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
+        protected override IEnumerable<GZipVolume> LoadVolumes(IEnumerable<Stream> streams)
        {
-            return new GZipVolume(streams.First(), options).AsEnumerable();
+            return new GZipVolume(streams.First(), ReaderOptions).AsEnumerable();
        }

        protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
--- a/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/GZip/GZipArchiveEntry.cs
@@ -2,11 +2,10 @@
 using System.Linq;
 using SharpCompress.Common.GZip;

-namespace SharpCompress.Archive.GZip
+namespace SharpCompress.Archives.GZip
 {
    public class GZipArchiveEntry : GZipEntry, IArchiveEntry
    {
-
        internal GZipArchiveEntry(GZipArchive archive, GZipFilePart part)
            : base(part)
        {
@@ -15,16 +14,20 @@ namespace SharpCompress.Archive.GZip

        public virtual Stream OpenEntryStream()
        {
+            //this is to reset the stream to be read multiple times
+            var part = Parts.Single() as GZipFilePart;
+            if (part.GetRawStream().Position != part.EntryStartPosition)
+            {
+                part.GetRawStream().Position = part.EntryStartPosition;
+            }
            return Parts.Single().GetCompressedStream();
        }

        #region IArchiveEntry Members
-        public IArchive Archive { get; private set; }

-        public bool IsComplete
-        {
-            get { return true; }
-        }
+        public IArchive Archive { get; }
+
+        public bool IsComplete => true;

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

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public interface IArchive : IDisposable
    {
--- a/src/SharpCompress/Archives/IArchiveEntry.cs
+++ b/src/SharpCompress/Archives/IArchiveEntry.cs
@@ -1,7 +1,7 @@
 using System.IO;
 using SharpCompress.Common;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public interface IArchiveEntry : IEntry
    {
--- a/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveEntryExtensions.cs
@@ -1,8 +1,9 @@
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.IO;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public static class IArchiveEntryExtensions
    {
@@ -28,25 +29,33 @@ namespace SharpCompress.Archive
                return;
            }
            using (entryStream)
-            using (Stream s = new ListeningStream(streamListener, entryStream))
            {
-                s.TransferTo(streamToWriteTo);
+                using (Stream s = new ListeningStream(streamListener, entryStream))
+                {
+                    s.TransferTo(streamToWriteTo);
+                }
            }
            streamListener.FireEntryExtractionEnd(archiveEntry);
        }

 #if !NO_FILE
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
+
+/// <summary>
+/// Extract to specific directory, retaining filename
+/// </summary>
        public static void WriteToDirectory(this IArchiveEntry entry, string destinationDirectory,
-                                            ExtractOptions options = ExtractOptions.Overwrite)
+                                            ExtractionOptions options = null)
        {
            string destinationFileName;
            string file = Path.GetFileName(entry.Key);

+            options = options ?? new ExtractionOptions()
+                                 {
+                                     Overwrite = true
+                                 };

-            if (options.HasFlag(ExtractOptions.ExtractFullPath))
+
+            if (options.ExtractFullPath)
            {
                string folder = Path.GetDirectoryName(entry.Key);
                string destdir = Path.Combine(destinationDirectory, folder);
@@ -70,11 +79,16 @@ namespace SharpCompress.Archive
        /// Extract to specific file
        /// </summary>
        public static void WriteToFile(this IArchiveEntry entry, string destinationFileName,
-                                       ExtractOptions options = ExtractOptions.Overwrite)
+                                       ExtractionOptions options = null)
        {
            FileMode fm = FileMode.Create;
+            options = options ?? new ExtractionOptions()
+            {
+                Overwrite = true
+            };

-            if (!options.HasFlag(ExtractOptions.Overwrite))
+
+            if (!options.Overwrite)
            {
                fm = FileMode.CreateNew;
            }
--- a/src/SharpCompress/Archives/IArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IArchiveExtensions.cs
@@ -1,16 +1,20 @@
-using System.Linq;
-using SharpCompress.Common;
+#if !NO_FILE
+using System.Linq;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive
+#endif
+
+namespace SharpCompress.Archives
 {
    public static class IArchiveExtensions
    {
 #if !NO_FILE
-        /// <summary>
-        /// Extract to specific directory, retaining filename
-        /// </summary>
+
+/// <summary>
+/// Extract to specific directory, retaining filename
+/// </summary>
        public static void WriteToDirectory(this IArchive archive, string destinationDirectory,
-                                            ExtractOptions options = ExtractOptions.Overwrite)
+                                            ExtractionOptions options = null)
        {
            foreach (IArchiveEntry entry in archive.Entries.Where(x => !x.IsDirectory))
            {
--- a/src/SharpCompress/Archives/IArchiveExtractionListener.cs
+++ b/src/SharpCompress/Archives/IArchiveExtractionListener.cs
@@ -1,6 +1,6 @@
 using SharpCompress.Common;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    internal interface IArchiveExtractionListener : IExtractionListener
    {
--- a/src/SharpCompress/Archives/IWritableArchive.cs
+++ b/src/SharpCompress/Archives/IWritableArchive.cs
@@ -1,8 +1,8 @@
 using System;
 using System.IO;
-using SharpCompress.Common;
+using SharpCompress.Writers;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public interface IWritableArchive : IArchive
    {
@@ -10,6 +10,6 @@ namespace SharpCompress.Archive

        IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);

-        void SaveTo(Stream stream, CompressionInfo compressionType);
+        void SaveTo(Stream stream, WriterOptions options);
    }
 }
--- a/src/SharpCompress/Archives/IWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/IWritableArchiveEntry.cs
@@ -1,6 +1,6 @@
 using System.IO;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    internal interface IWritableArchiveEntry
    {
--- a/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
+++ b/src/SharpCompress/Archives/IWritableArchiveExtensions.cs
@@ -1,17 +1,13 @@
-using System;
+#if !NO_FILE
+using System;
+#endif
 using System.IO;
-using SharpCompress.Common;
+using SharpCompress.Writers;

-namespace SharpCompress.Archive
+namespace SharpCompress.Archives
 {
    public static class IWritableArchiveExtensions
    {
-        public static void SaveTo(this IWritableArchive writableArchive,
-                                                   Stream stream, CompressionType compressionType)
-        {
-            writableArchive.SaveTo(stream, new CompressionInfo {Type = compressionType});
-        }
-
 #if !NO_FILE

        public static void AddEntry(this IWritableArchive writableArchive,
@@ -26,33 +22,16 @@ namespace SharpCompress.Archive
                                     fileInfo.LastWriteTime);
        }

-        public static void SaveTo(this IWritableArchive writableArchive,
-                                                   string filePath, CompressionType compressionType)
+        public static void SaveTo(this IWritableArchive writableArchive, string filePath, WriterOptions options)
        {
-            writableArchive.SaveTo(new FileInfo(filePath), new CompressionInfo {Type = compressionType});
+            writableArchive.SaveTo(new FileInfo(filePath), options);
        }

-        public static void SaveTo(this IWritableArchive writableArchive,
-                                                   FileInfo fileInfo, CompressionType compressionType)
+        public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options)
        {
            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
            {
-                writableArchive.SaveTo(stream, new CompressionInfo {Type = compressionType});
-            }
-        }
-
-        public static void SaveTo(this IWritableArchive writableArchive,
-                                                   string filePath, CompressionInfo compressionInfo)
-        {
-            writableArchive.SaveTo(new FileInfo(filePath), compressionInfo);
-        }
-
-        public static void SaveTo(this IWritableArchive writableArchive,
-                                                   FileInfo fileInfo, CompressionInfo compressionInfo)
-        {
-            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
-            {
-                writableArchive.SaveTo(stream, compressionInfo);
+                writableArchive.SaveTo(stream, options);
            }
        }

--- a/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarArchiveVolume.cs
@@ -1,42 +1,40 @@
-#if !NO_FILE
+
+#if !NO_FILE
 using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    /// <summary>
    /// A rar part based on a FileInfo object
    /// </summary>
    internal class FileInfoRarArchiveVolume : RarVolume
    {
-        internal FileInfoRarArchiveVolume(FileInfo fileInfo, string password, Options options)
-            : base(StreamingMode.Seekable, fileInfo.OpenRead(), password, FixOptions(options))
+        internal FileInfoRarArchiveVolume(FileInfo fileInfo, ReaderOptions options)
+            : base(StreamingMode.Seekable, fileInfo.OpenRead(), FixOptions(options))
        {
            FileInfo = fileInfo;
-            FileParts = base.GetVolumeFileParts().ToReadOnly();
+            FileParts = GetVolumeFileParts().ToReadOnly();
        }

-        private static Options FixOptions(Options options)
+        private static ReaderOptions FixOptions(ReaderOptions options)
        {
            //make sure we're closing streams with fileinfo
-            if (options.HasFlag(Options.KeepStreamsOpen))
-            {
-                options = (Options) FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
-            }
+            options.LeaveStreamOpen = false;
            return options;
        }

-        internal ReadOnlyCollection<RarFilePart> FileParts { get; private set; }
+        internal ReadOnlyCollection<RarFilePart> FileParts { get; }

-        internal FileInfo FileInfo { get; private set; }
+        internal FileInfo FileInfo { get; }

        internal override RarFilePart CreateFilePart(FileHeader fileHeader, MarkHeader markHeader)
        {
-            return new FileInfoRarFilePart(this, markHeader, fileHeader, FileInfo);
+            return new FileInfoRarFilePart(this, ReaderOptions.Password, markHeader, fileHeader, FileInfo);
        }

        internal override IEnumerable<RarFilePart> ReadFileParts()
--- a/src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/FileInfoRarFilePart.cs
@@ -1,19 +1,19 @@
-#if !NO_FILE
+
+#if !NO_FILE
 using System.IO;
-using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    internal class FileInfoRarFilePart : SeekableFilePart
    {
-        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, MarkHeader mh, FileHeader fh, FileInfo fi)
-            : base(mh, fh, volume.Stream, volume.Password)
+        internal FileInfoRarFilePart(FileInfoRarArchiveVolume volume, string password, MarkHeader mh, FileHeader fh, FileInfo fi)
+            : base(mh, fh, volume.Stream, password)
        {
            FileInfo = fi;
        }

-        internal FileInfo FileInfo { get; private set; }
+        internal FileInfo FileInfo { get; }

        internal override string FilePartName
        {
--- a/src/SharpCompress/Archives/Rar/RarArchive.Extensions.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.Extensions.cs
@@ -1,6 +1,6 @@
 using System.Linq;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    public static class RarArchiveExtensions
    {
--- a/src/SharpCompress/Archives/Rar/RarArchive.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchive.cs
@@ -1,41 +1,35 @@
-using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Compressor.Rar;
+using SharpCompress.Compressors.Rar;
 using SharpCompress.IO;
-using SharpCompress.Reader;
-using SharpCompress.Reader.Rar;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Rar;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
    {
-        private readonly Unpack unpack = new Unpack();
-
-        internal Unpack Unpack
-        {
-            get { return unpack; }
-        }
+        internal Unpack Unpack { get; } = new Unpack();

 #if !NO_FILE
+
        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="options"></param>
-        /// <param name="password"></param>
-        internal RarArchive(FileInfo fileInfo, Options options, string password)
-            : base(ArchiveType.Rar, fileInfo, options, password)
+        internal RarArchive(FileInfo fileInfo, ReaderOptions options)
+            : base(ArchiveType.Rar, fileInfo, options)
        {
        }

-        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file, Options options)
+        protected override IEnumerable<RarVolume> LoadVolumes(FileInfo file)
        {
-            return RarArchiveVolumeFactory.GetParts(file, Password, options);
+            return RarArchiveVolumeFactory.GetParts(file, ReaderOptions);
        }
 #endif

@@ -44,9 +38,8 @@ namespace SharpCompress.Archive.Rar
        /// </summary>
        /// <param name="streams"></param>
        /// <param name="options"></param>
-        /// <param name="password"></param>
-        internal RarArchive(IEnumerable<Stream> streams, Options options, string password)
-            : base(ArchiveType.Rar, streams, options, password)
+        internal RarArchive(IEnumerable<Stream> streams, ReaderOptions options)
+            : base(ArchiveType.Rar, streams, options)
        {
        }

@@ -55,36 +48,33 @@ namespace SharpCompress.Archive.Rar
            return RarArchiveEntryFactory.GetEntries(this, volumes);
        }

-        protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
+        protected override IEnumerable<RarVolume> LoadVolumes(IEnumerable<Stream> streams)
        {
-            return RarArchiveVolumeFactory.GetParts(streams, Password, options);
+            return RarArchiveVolumeFactory.GetParts(streams, ReaderOptions);
        }

        protected override IReader CreateReaderForSolidExtraction()
        {
            var stream = Volumes.First().Stream;
            stream.Position = 0;
-            return RarReader.Open(stream, Password);
+            return RarReader.Open(stream, ReaderOptions);
        }

-        public override bool IsSolid
-        {
-            get { return Volumes.First().IsSolidArchive; }
-        }
+        public override bool IsSolid => Volumes.First().IsSolidArchive;

        #region Creation

 #if !NO_FILE
+
        /// <summary>
-        /// Constructor expects a filepath to an existing file.
+        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static RarArchive Open(string filePath, Options options = Options.None, string password = null)
+        public static RarArchive Open(string filePath, ReaderOptions options = null)
        {
            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options, password);
+            return new RarArchive(new FileInfo(filePath), options ?? new ReaderOptions());
        }

        /// <summary>
@@ -92,23 +82,22 @@ namespace SharpCompress.Archive.Rar
        /// </summary>
        /// <param name="fileInfo"></param>
        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static RarArchive Open(FileInfo fileInfo, Options options = Options.None, string password = null)
+        public static RarArchive Open(FileInfo fileInfo, ReaderOptions options = null)
        {
            fileInfo.CheckNotNull("fileInfo");
-            return new RarArchive(fileInfo, options, password);
+            return new RarArchive(fileInfo, options ?? new ReaderOptions());
        }
 #endif
+
        /// <summary>
        /// Takes a seekable Stream as a source
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static RarArchive Open(Stream stream, Options options = Options.KeepStreamsOpen, string password = null)
+        public static RarArchive Open(Stream stream, ReaderOptions options = null)
        {
            stream.CheckNotNull("stream");
-            return Open(stream.AsEnumerable(), options, password);
+            return Open(stream.AsEnumerable(), options ?? new ReaderOptions());
        }

        /// <summary>
@@ -116,11 +105,10 @@ namespace SharpCompress.Archive.Rar
        /// </summary>
        /// <param name="streams"></param>
        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static RarArchive Open(IEnumerable<Stream> streams, Options options = Options.KeepStreamsOpen, string password = null)
+        public static RarArchive Open(IEnumerable<Stream> streams, ReaderOptions options = null)
        {
            streams.CheckNotNull("streams");
-            return new RarArchive(streams, options, password);
+            return new RarArchive(streams, options ?? new ReaderOptions());
        }

 #if !NO_FILE
@@ -141,17 +129,12 @@ namespace SharpCompress.Archive.Rar
            }
        }
 #endif
-
-        public static bool IsRarFile(Stream stream)
-        {
-            return IsRarFile(stream, Options.None);
-        }
-
-        public static bool IsRarFile(Stream stream, Options options)
+        
+        public static bool IsRarFile(Stream stream, ReaderOptions options = null)
        {
            try
            {
-                var headerFactory = new RarHeaderFactory(StreamingMode.Seekable, options);
+                var headerFactory = new RarHeaderFactory(StreamingMode.Seekable, options ?? new ReaderOptions());
                var markHeader = headerFactory.ReadHeaders(stream).FirstOrDefault() as MarkHeader;
                return markHeader != null && markHeader.IsValid();
            }
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntry.cs
@@ -5,9 +5,9 @@ using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Compressor.Rar;
+using SharpCompress.Compressors.Rar;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    public class RarArchiveEntry : RarEntry, IArchiveEntry
    {
@@ -20,28 +20,13 @@ namespace SharpCompress.Archive.Rar
            this.archive = archive;
        }

-        public override CompressionType CompressionType
-        {
-            get { return CompressionType.Rar; }
-        }
+        public override CompressionType CompressionType => CompressionType.Rar;

-        public IArchive Archive
-        {
-            get
-            {
-                return archive;
-            }
-        }
+        public IArchive Archive => archive;

-        internal override IEnumerable<FilePart> Parts
-        {
-            get { return parts.Cast<FilePart>(); }
-        }
+        internal override IEnumerable<FilePart> Parts => parts.Cast<FilePart>();

-        internal override FileHeader FileHeader
-        {
-            get { return parts.First().FileHeader; }
-        }
+        internal override FileHeader FileHeader => parts.First().FileHeader;

        public override long Crc
        {
@@ -49,11 +34,10 @@ namespace SharpCompress.Archive.Rar
            {
                CheckIncomplete();
                return parts.Select(fp => fp.FileHeader)
-                    .Single(fh => !fh.FileFlags.HasFlag(FileFlags.SPLIT_AFTER)).FileCRC;
+                            .Single(fh => !fh.FileFlags.HasFlag(FileFlags.SPLIT_AFTER)).FileCRC;
            }
        }

-
        public override long Size
        {
            get
@@ -81,10 +65,7 @@ namespace SharpCompress.Archive.Rar
            return new RarStream(archive.Unpack, FileHeader, new MultiVolumeReadOnlyStream(Parts.Cast<RarFilePart>(), archive));
        }

-        public bool IsComplete
-        {
-            get { return parts.Select(fp => fp.FileHeader).Any(fh => !fh.FileFlags.HasFlag(FileFlags.SPLIT_AFTER)); }
-        }
+        public bool IsComplete { get { return parts.Select(fp => fp.FileHeader).Any(fh => !fh.FileFlags.HasFlag(FileFlags.SPLIT_AFTER)); } }

        private void CheckIncomplete()
        {
--- a/src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs
@@ -3,7 +3,7 @@ using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    internal static class RarArchiveEntryFactory
    {
@@ -25,7 +25,7 @@ namespace SharpCompress.Archive.Rar
            {
                groupedParts.Add(fp);

-                if (!FlagUtility.HasFlag((long) fp.FileHeader.FileFlags, (long) FileFlags.SPLIT_AFTER))
+                if (!FlagUtility.HasFlag((long)fp.FileHeader.FileFlags, (long)FileFlags.SPLIT_AFTER))
                {
                    yield return groupedParts;
                    groupedParts = new List<RarFilePart>();
--- a/src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
+++ b/src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs
@@ -1,17 +1,20 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Common.Rar;
+using SharpCompress.Readers;
+#if !NO_FILE
 using System.Linq;
 using System.Text;
 using SharpCompress.Common.Rar.Headers;
-using SharpCompress.Common;
-using SharpCompress.Common.Rar;
+#endif

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    internal static class RarArchiveVolumeFactory
    {
-        internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, string password, Options options)
+        internal static IEnumerable<RarVolume> GetParts(IEnumerable<Stream> streams, ReaderOptions options)
        {
            foreach (Stream s in streams)
            {
@@ -19,15 +22,15 @@ namespace SharpCompress.Archive.Rar
                {
                    throw new ArgumentException("Stream is not readable and seekable");
                }
-                StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, password, options);
+                StreamRarArchiveVolume part = new StreamRarArchiveVolume(s, options);
                yield return part;
            }
        }

 #if !NO_FILE
-        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, string password, Options options)
+        internal static IEnumerable<RarVolume> GetParts(FileInfo fileInfo, ReaderOptions options)
        {
-            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, password, options);
+            FileInfoRarArchiveVolume part = new FileInfoRarArchiveVolume(fileInfo, options);
            yield return part;

            if (!part.ArchiveHeader.ArchiveHeaderFlags.HasFlag(ArchiveFlags.VOLUME))
@@ -39,7 +42,7 @@ namespace SharpCompress.Archive.Rar
            //we use fileinfo because rar is dumb and looks at file names rather than archive info for another volume
            while (fileInfo != null && fileInfo.Exists)
            {
-                part = new FileInfoRarArchiveVolume(fileInfo, password, options);
+                part = new FileInfoRarArchiveVolume(fileInfo, options);

                fileInfo = GetNextFileInfo(ah, part.FileParts.FirstOrDefault() as FileInfoRarFilePart);
                yield return part;
--- a/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
+++ b/src/SharpCompress/Archives/Rar/SeekableFilePart.cs
@@ -1,9 +1,8 @@
-using System;
-using System.IO;
+using System.IO;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    internal class SeekableFilePart : RarFilePart
    {
@@ -29,9 +28,6 @@ namespace SharpCompress.Archive.Rar
            return stream;
        }

-        internal override string FilePartName
-        {
-            get { return "Unknown Stream - File Entry: " + FileHeader.FileName; }
-        }
+        internal override string FilePartName => "Unknown Stream - File Entry: " + FileHeader.FileName;
    }
 }
--- a/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
+++ b/src/SharpCompress/Archives/Rar/StreamRarArchiveVolume.cs
@@ -1,16 +1,16 @@
 using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Common;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive.Rar
+namespace SharpCompress.Archives.Rar
 {
    internal class StreamRarArchiveVolume : RarVolume
    {
-        internal StreamRarArchiveVolume(Stream stream, string password, Options options)
-            : base(StreamingMode.Seekable, stream, password, options)
+        internal StreamRarArchiveVolume(Stream stream, ReaderOptions options)
+            : base(StreamingMode.Seekable, stream, options)
        {
        }

@@ -21,7 +21,7 @@ namespace SharpCompress.Archive.Rar

        internal override RarFilePart CreateFilePart(FileHeader fileHeader, MarkHeader markHeader)
        {
-            return new SeekableFilePart(markHeader, fileHeader, Stream, Password);
+            return new SeekableFilePart(markHeader, fileHeader, Stream, ReaderOptions.Password);
        }
    }
 }
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs
@@ -5,89 +5,57 @@ using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.SevenZip;
 using SharpCompress.IO;
-using SharpCompress.Reader;
+using SharpCompress.Readers;

-namespace SharpCompress.Archive.SevenZip
+namespace SharpCompress.Archives.SevenZip
 {
    public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVolume>
    {
        private ArchiveDatabase database;
 #if !NO_FILE
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        public static SevenZipArchive Open(string filePath)
-        {
-            return Open(filePath, Options.None);
-        }
-
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        public static SevenZipArchive Open(FileInfo fileInfo)
-        {
-            return Open(fileInfo, Options.None);
-        }

        /// <summary>
        /// Constructor expects a filepath to an existing file.
        /// </summary>
        /// <param name="filePath"></param>
-        /// <param name="options"></param>
-        public static SevenZipArchive Open(string filePath, Options options)
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(string filePath, ReaderOptions readerOptions = null)
        {
            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options);
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }

        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        public static SevenZipArchive Open(FileInfo fileInfo, Options options)
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
        {
            fileInfo.CheckNotNull("fileInfo");
-            return new SevenZipArchive(fileInfo, options);
+            return new SevenZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
        }
 #endif
-
        /// <summary>
        /// Takes a seekable Stream as a source
        /// </summary>
        /// <param name="stream"></param>
-        public static SevenZipArchive Open(Stream stream)
+        /// <param name="readerOptions"></param>
+        public static SevenZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull("stream");
-            return Open(stream, Options.None);
-        }
-
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        public static SevenZipArchive Open(Stream stream, Options options)
-        {
-            stream.CheckNotNull("stream");
-            return new SevenZipArchive(stream, options);
+            return new SevenZipArchive(stream, readerOptions ?? new ReaderOptions());
        }

 #if !NO_FILE
-        internal SevenZipArchive(FileInfo fileInfo, Options options)
-            : base(ArchiveType.SevenZip, fileInfo, options, null)
+        internal SevenZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
+            : base(ArchiveType.SevenZip, fileInfo, readerOptions)
        {
        }

-        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file, Options options)
+        protected override IEnumerable<SevenZipVolume> LoadVolumes(FileInfo file)
        {
-            if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
-            {
-                options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
-            }
-            return new SevenZipVolume(file.OpenRead(), options).AsEnumerable();
+            return new SevenZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
        }

        public static bool IsSevenZipFile(string filePath)
@@ -108,8 +76,8 @@ namespace SharpCompress.Archive.SevenZip
        }
 #endif

-        internal SevenZipArchive(Stream stream, Options options)
-            : base(ArchiveType.SevenZip, stream.AsEnumerable(), options, null)
+        internal SevenZipArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.SevenZip, stream.AsEnumerable(), readerOptions)
        {
        }

@@ -118,7 +86,7 @@ namespace SharpCompress.Archive.SevenZip
        {
        }

-        protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
+        protected override IEnumerable<SevenZipVolume> LoadVolumes(IEnumerable<Stream> streams)
        {
            foreach (Stream s in streams)
            {
@@ -126,7 +94,7 @@ namespace SharpCompress.Archive.SevenZip
                {
                    throw new ArgumentException("Stream is not readable and seekable");
                }
-                SevenZipVolume volume = new SevenZipVolume(s, options);
+                SevenZipVolume volume = new SevenZipVolume(s, ReaderOptions);
                yield return volume;
            }
        }
@@ -138,10 +106,7 @@ namespace SharpCompress.Archive.SevenZip
            for (int i = 0; i < database.Files.Count; i++)
            {
                var file = database.Files[i];
-                if (!file.IsDir)
-                {
-                    yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file));
-                }
+                yield return new SevenZipArchiveEntry(this, new SevenZipFilePart(stream, database, i, file));
            }
        }

@@ -156,7 +121,6 @@ namespace SharpCompress.Archive.SevenZip
            }
        }

-
        public static bool IsSevenZipFile(Stream stream)
        {
            try
@@ -169,7 +133,7 @@ namespace SharpCompress.Archive.SevenZip
            }
        }

-        private static readonly byte[] SIGNATURE = new byte[] {(byte) '7', (byte) 'z', 0xBC, 0xAF, 0x27, 0x1C};
+        private static readonly byte[] SIGNATURE = {(byte)'7', (byte)'z', 0xBC, 0xAF, 0x27, 0x1C};

        private static bool SignatureMatch(Stream stream)
        {
@@ -183,10 +147,7 @@ namespace SharpCompress.Archive.SevenZip
            return new SevenZipReader(this);
        }

-        public override bool IsSolid
-        {
-            get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; }
-        }
+        public override bool IsSolid { get { return Entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder).Count() > 1; } }

        public override long TotalSize
        {
@@ -205,16 +166,12 @@ namespace SharpCompress.Archive.SevenZip
            private CFileItem currentItem;

            internal SevenZipReader(SevenZipArchive archive)
-                : base(Options.KeepStreamsOpen, ArchiveType.SevenZip)
+                : base(new ReaderOptions(), ArchiveType.SevenZip)
            {
                this.archive = archive;
            }

-
-            public override SevenZipVolume Volume
-            {
-                get { return archive.Volumes.Single(); }
-            }
+            public override SevenZipVolume Volume => archive.Volumes.Single();

            internal override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
            {
@@ -249,4 +206,4 @@ namespace SharpCompress.Archive.SevenZip
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/SevenZip/SevenZipArchiveEntry.cs
@@ -1,8 +1,7 @@
-using System;
-using System.IO;
+using System.IO;
 using SharpCompress.Common.SevenZip;

-namespace SharpCompress.Archive.SevenZip
+namespace SharpCompress.Archives.SevenZip
 {
    public class SevenZipArchiveEntry : SevenZipEntry, IArchiveEntry
    {
@@ -16,19 +15,14 @@ namespace SharpCompress.Archive.SevenZip
        {
            return FilePart.GetCompressedStream();
        }
-        public IArchive Archive { get; private set; }

-        public bool IsComplete
-        {
-            get { return true; }
-        }
+        public IArchive Archive { get; }
+
+        public bool IsComplete => true;

        /// <summary>
        /// This is a 7Zip Anti item
        /// </summary>
-        public bool IsAnti
-        {
-            get { return FilePart.Header.IsAnti; }
-        }
+        public bool IsAnti => FilePart.Header.IsAnti;
    }
 }
--- a/src/SharpCompress/Archives/Tar/TarArchive.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchive.cs
@@ -6,75 +6,49 @@ using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.IO;
-using SharpCompress.Reader;
-using SharpCompress.Reader.Tar;
-using SharpCompress.Writer.Tar;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Tar;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Tar;

-namespace SharpCompress.Archive.Tar
+namespace SharpCompress.Archives.Tar
 {
    public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
    {
 #if !NO_FILE
+        
        /// <summary>
        /// Constructor expects a filepath to an existing file.
        /// </summary>
        /// <param name="filePath"></param>
-        public static TarArchive Open(string filePath)
-        {
-            return Open(filePath, Options.None);
-        }
-
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        public static TarArchive Open(FileInfo fileInfo)
-        {
-            return Open(fileInfo, Options.None);
-        }
-
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="options"></param>
-        public static TarArchive Open(string filePath, Options options)
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(string filePath, ReaderOptions readerOptions = null)
        {
            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options);
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }

        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        public static TarArchive Open(FileInfo fileInfo, Options options)
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
        {
            fileInfo.CheckNotNull("fileInfo");
-            return new TarArchive(fileInfo, options);
+            return new TarArchive(fileInfo, readerOptions ?? new ReaderOptions());
        }
 #endif
-
+        
        /// <summary>
        /// Takes a seekable Stream as a source
        /// </summary>
        /// <param name="stream"></param>
-        public static TarArchive Open(Stream stream)
+        /// <param name="readerOptions"></param>
+        public static TarArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull("stream");
-            return Open(stream, Options.None);
-        }
-
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        public static TarArchive Open(Stream stream, Options options)
-        {
-            stream.CheckNotNull("stream");
-            return new TarArchive(stream, options);
+            return new TarArchive(stream, readerOptions ?? new ReaderOptions());
        }

 #if !NO_FILE
@@ -102,7 +76,7 @@ namespace SharpCompress.Archive.Tar
            {
                TarHeader tar = new TarHeader();
                tar.Read(new BinaryReader(stream));
-                return tar.Name.Length > 0 && Enum.IsDefined(typeof (EntryType), tar.EntryType);
+                return tar.Name.Length > 0 && Enum.IsDefined(typeof(EntryType), tar.EntryType);
            }
            catch
            {
@@ -111,23 +85,21 @@ namespace SharpCompress.Archive.Tar
        }

 #if !NO_FILE
+
        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        internal TarArchive(FileInfo fileInfo, Options options)
-            : base(ArchiveType.Tar, fileInfo, options)
+        /// <param name="readerOptions"></param>
+        internal TarArchive(FileInfo fileInfo, ReaderOptions readerOptions)
+            : base(ArchiveType.Tar, fileInfo, readerOptions)
        {
        }

-        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file, Options options)
+        protected override IEnumerable<TarVolume> LoadVolumes(FileInfo file)
        {
-            if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
-            {
-                options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
-            }
-            return new TarVolume(file.OpenRead(), options).AsEnumerable();
+            
+            return new TarVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
        }
 #endif

@@ -135,9 +107,9 @@ namespace SharpCompress.Archive.Tar
        /// Takes multiple seekable Streams for a multi-part archive
        /// </summary>
        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        internal TarArchive(Stream stream, Options options)
-            : base(ArchiveType.Tar, stream, options)
+        /// <param name="readerOptions"></param>
+        internal TarArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.Tar, stream, readerOptions)
        {
        }

@@ -146,9 +118,9 @@ namespace SharpCompress.Archive.Tar
        {
        }

-        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
+        protected override IEnumerable<TarVolume> LoadVolumes(IEnumerable<Stream> streams)
        {
-            return new TarVolume(streams.First(), options).AsEnumerable();
+            return new TarVolume(streams.First(), ReaderOptions).AsEnumerable();
        }

        protected override IEnumerable<TarArchiveEntry> LoadEntries(IEnumerable<TarVolume> volumes)
@@ -172,14 +144,16 @@ namespace SharpCompress.Archive.Tar

                            var oldStreamPos = stream.Position;

-                            using(var entryStream = entry.OpenEntryStream())
-                            using(var memoryStream = new MemoryStream())
+                            using (var entryStream = entry.OpenEntryStream())
                            {
-                                entryStream.TransferTo(memoryStream);
-                                memoryStream.Position = 0;
-                                var bytes = memoryStream.ToArray();
+                                using (var memoryStream = new MemoryStream())
+                                {
+                                    entryStream.TransferTo(memoryStream);
+                                    memoryStream.Position = 0;
+                                    var bytes = memoryStream.ToArray();

-                                header.Name = ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length).TrimNulls();
+                                    header.Name = ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length).TrimNulls();
+                                }
                            }

                            stream.Position = oldStreamPos;
@@ -198,17 +172,17 @@ namespace SharpCompress.Archive.Tar
        }

        protected override TarArchiveEntry CreateEntryInternal(string filePath, Stream source,
-                                                       long size, DateTime? modified, bool closeStream)
+                                                               long size, DateTime? modified, bool closeStream)
        {
            return new TarWritableArchiveEntry(this, source, CompressionType.Unknown, filePath, size, modified,
                                               closeStream);
        }

-        protected override void SaveTo(Stream stream, CompressionInfo compressionInfo,
+        protected override void SaveTo(Stream stream, WriterOptions options,
                                       IEnumerable<TarArchiveEntry> oldEntries,
                                       IEnumerable<TarArchiveEntry> newEntries)
        {
-            using (var writer = new TarWriter(stream, compressionInfo))
+            using (var writer = new TarWriter(stream, options))
            {
                foreach (var entry in oldEntries.Concat(newEntries)
                                                .Where(x => !x.IsDirectory))
--- a/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarArchiveEntry.cs
@@ -3,7 +3,7 @@ using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;

-namespace SharpCompress.Archive.Tar
+namespace SharpCompress.Archives.Tar
 {
    public class TarArchiveEntry : TarEntry, IArchiveEntry
    {
@@ -19,12 +19,10 @@ namespace SharpCompress.Archive.Tar
        }

        #region IArchiveEntry Members
-        public IArchive Archive { get; private set; }

-        public bool IsComplete
-        {
-            get { return true; }
-        }
+        public IArchive Archive { get; }
+
+        public bool IsComplete => true;

        #endregion
    }
--- a/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.IO;
+
+namespace SharpCompress.Archives.Tar
+{
+    internal class TarWritableArchiveEntry : TarArchiveEntry, IWritableArchiveEntry
+    {
+        private readonly bool closeStream;
+        private readonly Stream stream;
+
+        internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType,
+                                         string path, long size, DateTime? lastModified, bool closeStream)
+            : base(archive, null, compressionType)
+        {
+            this.stream = stream;
+            Key = path;
+            Size = size;
+            LastModifiedTime = lastModified;
+            this.closeStream = closeStream;
+        }
+
+        public override long Crc => 0;
+
+        public override string Key { get; }
+
+        public override long CompressedSize => 0;
+
+        public override long Size { get; }
+
+        public override DateTime? LastModifiedTime { get; }
+
+        public override DateTime? CreatedTime => null;
+
+        public override DateTime? LastAccessedTime => null;
+
+        public override DateTime? ArchivedTime => null;
+
+        public override bool IsEncrypted => false;
+
+        public override bool IsDirectory => false;
+
+        public override bool IsSplit => false;
+
+        internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
+        Stream IWritableArchiveEntry.Stream => stream;
+
+        public override Stream OpenEntryStream()
+        {
+            //ensure new stream is at the start, this could be reset
+            stream.Seek(0, SeekOrigin.Begin);
+            return new NonDisposingStream(stream);
+        }
+
+        internal override void Close()
+        {
+            if (closeStream)
+            {
+                stream.Dispose();
+            }
+        }
+    }
+}
--- a/src/SharpCompress/Archives/Zip/ZipArchive.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchive.cs
@@ -5,12 +5,13 @@ using System.Linq;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
-using SharpCompress.Compressor.Deflate;
-using SharpCompress.Reader;
-using SharpCompress.Reader.Zip;
-using SharpCompress.Writer.Zip;
+using SharpCompress.Compressors.Deflate;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Zip;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Zip;

-namespace SharpCompress.Archive.Zip
+namespace SharpCompress.Archives.Zip
 {
    public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
    {
@@ -27,68 +28,33 @@ namespace SharpCompress.Archive.Zip
        /// Constructor expects a filepath to an existing file.
        /// </summary>
        /// <param name="filePath"></param>
-        /// <param name="password"></param>
-        public static ZipArchive Open(string filePath, string password = null)
-        {
-            return Open(filePath, Options.None, password);
-        }
-
-        /// <summary>
-        /// Constructor with a FileInfo object to an existing file.
-        /// </summary>
-        /// <param name="fileInfo"></param>
-        /// <param name="password"></param>
-        public static ZipArchive Open(FileInfo fileInfo, string password = null)
-        {
-            return Open(fileInfo, Options.None, password);
-        }
-
-        /// <summary>
-        /// Constructor expects a filepath to an existing file.
-        /// </summary>
-        /// <param name="filePath"></param>
-        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static ZipArchive Open(string filePath, Options options, string password = null)
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(string filePath, ReaderOptions readerOptions = null)
        {
            filePath.CheckNotNullOrEmpty("filePath");
-            return Open(new FileInfo(filePath), options, password);
+            return Open(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
        }

        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static ZipArchive Open(FileInfo fileInfo, Options options, string password = null)
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(FileInfo fileInfo, ReaderOptions readerOptions = null)
        {
            fileInfo.CheckNotNull("fileInfo");
-            return new ZipArchive(fileInfo, options, password);
+            return new ZipArchive(fileInfo, readerOptions ?? new ReaderOptions());
        }
 #endif
-
        /// <summary>
        /// Takes a seekable Stream as a source
        /// </summary>
        /// <param name="stream"></param>
-        /// <param name="password"></param>
-        public static ZipArchive Open(Stream stream, string password = null)
+        /// <param name="readerOptions"></param>
+        public static ZipArchive Open(Stream stream, ReaderOptions readerOptions = null)
        {
            stream.CheckNotNull("stream");
-            return Open(stream, Options.None, password);
-        }
-
-        /// <summary>
-        /// Takes a seekable Stream as a source
-        /// </summary>
-        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        /// <param name="password"></param>
-        public static ZipArchive Open(Stream stream, Options options, string password = null)
-        {
-            stream.CheckNotNull("stream");
-            return new ZipArchive(stream, options, password);
+            return new ZipArchive(stream, readerOptions ?? new ReaderOptions());
        }

 #if !NO_FILE
@@ -121,7 +87,7 @@ namespace SharpCompress.Archive.Zip
                {
                    return false;
                }
-                return Enum.IsDefined(typeof (ZipHeaderType), header.ZipHeaderType);
+                return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
            }
            catch (CryptographicException)
            {
@@ -134,25 +100,21 @@ namespace SharpCompress.Archive.Zip
        }

 #if !NO_FILE
+
        /// <summary>
        /// Constructor with a FileInfo object to an existing file.
        /// </summary>
        /// <param name="fileInfo"></param>
-        /// <param name="options"></param>
-        /// <param name="password"></param>
-        internal ZipArchive(FileInfo fileInfo, Options options, string password = null)
-            : base(ArchiveType.Zip, fileInfo, options)
+        /// <param name="readerOptions"></param>
+        internal ZipArchive(FileInfo fileInfo, ReaderOptions readerOptions)
+            : base(ArchiveType.Zip, fileInfo, readerOptions)
        {
-            headerFactory = new SeekableZipHeaderFactory(password);
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password);
        }

-        protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file, Options options)
+        protected override IEnumerable<ZipVolume> LoadVolumes(FileInfo file)
        {
-            if (FlagUtility.HasFlag(options, Options.KeepStreamsOpen))
-            {
-                options = (Options)FlagUtility.SetFlag(options, Options.KeepStreamsOpen, false);
-            }
-            return new ZipVolume(file.OpenRead(), options).AsEnumerable();
+            return new ZipVolume(file.OpenRead(), ReaderOptions).AsEnumerable();
        }
 #endif

@@ -165,17 +127,16 @@ namespace SharpCompress.Archive.Zip
        /// Takes multiple seekable Streams for a multi-part archive
        /// </summary>
        /// <param name="stream"></param>
-        /// <param name="options"></param>
-        /// <param name="password"></param>
-        internal ZipArchive(Stream stream, Options options, string password = null)
-            : base(ArchiveType.Zip, stream, options)
+        /// <param name="readerOptions"></param>
+        internal ZipArchive(Stream stream, ReaderOptions readerOptions)
+            : base(ArchiveType.Zip, stream, readerOptions)
        {
-            headerFactory = new SeekableZipHeaderFactory(password);
+            headerFactory = new SeekableZipHeaderFactory(readerOptions.Password);
        }

-        protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams, Options options)
+        protected override IEnumerable<ZipVolume> LoadVolumes(IEnumerable<Stream> streams)
        {
-            return new ZipVolume(streams.First(), options).AsEnumerable();
+            return new ZipVolume(streams.First(), ReaderOptions).AsEnumerable();
        }

        protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
@@ -189,43 +150,48 @@ namespace SharpCompress.Archive.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 = ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length);
-                                yield break;
-                            }
+                        {
+                            byte[] bytes = (h as DirectoryEndHeader).Comment;
+                            volume.Comment = ArchiveEncoding.Default.GetString(bytes, 0, bytes.Length);
+                            yield break;
+                        }
                    }
                }
            }
        }

-        protected override void SaveTo(Stream stream, CompressionInfo compressionInfo,
+        public void SaveTo(Stream stream)
+        {
+            SaveTo(stream, new WriterOptions(CompressionType.Deflate));
+        }
+
+        protected override void SaveTo(Stream stream, WriterOptions options,
                                       IEnumerable<ZipArchiveEntry> oldEntries,
                                       IEnumerable<ZipArchiveEntry> newEntries)
        {
-            using (var writer = new ZipWriter(stream, compressionInfo, string.Empty))
+            using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
            {
                foreach (var entry in oldEntries.Concat(newEntries)
                                                .Where(x => !x.IsDirectory))
                {
                    using (var entryStream = entry.OpenEntryStream())
                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime, string.Empty);
+                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
                    }
                }
            }
        }

        protected override ZipArchiveEntry CreateEntryInternal(string filePath, Stream source, long size, DateTime? modified,
-                                                       bool closeStream)
+                                                               bool closeStream)
        {
            return new ZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
        }
--- a/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs
@@ -2,7 +2,7 @@
 using System.Linq;
 using SharpCompress.Common.Zip;

-namespace SharpCompress.Archive.Zip
+namespace SharpCompress.Archives.Zip
 {
    public class ZipArchiveEntry : ZipEntry, IArchiveEntry
    {
@@ -19,18 +19,12 @@ namespace SharpCompress.Archive.Zip

        #region IArchiveEntry Members

-        public IArchive Archive { get; private set; }
+        public IArchive Archive { get; }

-        public bool IsComplete
-        {
-            get { return true; }
-        }
+        public bool IsComplete => true;

        #endregion

-        public string Comment
-        {
-            get { return (Parts.Single() as SeekableZipFilePart).Comment; }
-        }
+        public string Comment => (Parts.Single() as SeekableZipFilePart).Comment;
    }
 }
--- a/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
+++ b/src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common;
+using SharpCompress.IO;
+
+namespace SharpCompress.Archives.Zip
+{
+    internal class ZipWritableArchiveEntry : ZipArchiveEntry, IWritableArchiveEntry
+    {
+        private readonly bool closeStream;
+        private readonly Stream stream;
+        private bool isDisposed;
+
+        internal ZipWritableArchiveEntry(ZipArchive archive, Stream stream, string path, long size,
+                                         DateTime? lastModified, bool closeStream)
+            : base(archive, null)
+        {
+            this.stream = stream;
+            Key = path;
+            Size = size;
+            LastModifiedTime = lastModified;
+            this.closeStream = closeStream;
+        }
+
+        public override long Crc => 0;
+
+        public override string Key { get; }
+
+        public override long CompressedSize => 0;
+
+        public override long Size { get; }
+
+        public override DateTime? LastModifiedTime { get; }
+
+        public override DateTime? CreatedTime => null;
+
+        public override DateTime? LastAccessedTime => null;
+
+        public override DateTime? ArchivedTime => null;
+
+        public override bool IsEncrypted => false;
+
+        public override bool IsDirectory => false;
+
+        public override bool IsSplit => false;
+
+        internal override IEnumerable<FilePart> Parts => throw new NotImplementedException();
+
+        Stream IWritableArchiveEntry.Stream => stream;
+
+        public override Stream OpenEntryStream()
+        {
+            //ensure new stream is at the start, this could be reset
+            stream.Seek(0, SeekOrigin.Begin);
+            return new NonDisposingStream(stream);
+        }
+
+        internal override void Close()
+        {
+            if (closeStream && !isDisposed)
+            {
+                stream.Dispose();
+                isDisposed = true;
+            }
+        }
+    }
+}
--- a/src/SharpCompress/AssemblyInfo.cs
+++ b/src/SharpCompress/AssemblyInfo.cs
@@ -2,12 +2,24 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;

-
 [assembly: AssemblyTitle("SharpCompress")]
 [assembly: AssemblyProduct("SharpCompress")]
-
-
-[assembly: InternalsVisibleTo("SharpCompress.Test")]
-[assembly: InternalsVisibleTo("SharpCompress.Test.Portable")]
-
+[assembly: InternalsVisibleTo("SharpCompress.Test" + SharpCompress.AssemblyInfo.PublicKeySuffix)]
+[assembly: InternalsVisibleTo("SharpCompress.Test.Portable"  + SharpCompress.AssemblyInfo.PublicKeySuffix)]
 [assembly: CLSCompliant(true)]
+
+namespace SharpCompress
+{
+    /// <summary>
+    /// Just a static class to house the public key, to avoid repetition.
+    /// </summary>
+    internal static class AssemblyInfo
+    {
+        internal const string PublicKeySuffix =
+            ",PublicKey=002400000480000094000000060200000024000052534131000400000100010059acfa17d26c44" +
+            "7a4d03f16eaa72c9187c04f16e6569dd168b080e39a6f5c9fd00f28c768cd8e9a089d5a0e1b34c" +
+            "cd971488e7afe030ce5ce8df2053cf12ec89f6d38065c434c09ee6af3ee284c5dc08f44774b679" +
+            "bf39298e57efe30d4b00aecf9e4f6f8448b2cb0146d8956dfcab606cc64a0ac38c60a7d78b0d65" +
+            "d3b98dc0";
+    }
+}
--- a/src/SharpCompress/Common/ArchiveType.cs
+++ b/src/SharpCompress/Common/ArchiveType.cs
@@ -6,6 +6,6 @@
        Zip,
        Tar,
        SevenZip,
-        GZip,
+        GZip
    }
 }
--- a/src/SharpCompress/Common/CompressionInfo.cs
+++ b/src/SharpCompress/Common/CompressionInfo.cs
@@ -1,30 +0,0 @@
-using SharpCompress.Compressor.Deflate;
-
-namespace SharpCompress.Common
-{
-    /// <summary>
-    /// Detailed compression properties when saving.
-    /// </summary>
-    public class CompressionInfo
-    {
-        public CompressionInfo()
-        {
-            DeflateCompressionLevel = CompressionLevel.Default;
-        }
-
-        /// <summary>
-        /// The algorthm to use.  Must be valid for the format type.
-        /// </summary>
-        public CompressionType Type { get; set; }
-
-        /// <summary>
-        /// When CompressionType.Deflate is used, this property is referenced.  Defaults to CompressionLevel.Default.
-        /// </summary>
-        public CompressionLevel DeflateCompressionLevel { get; set; }
-
-        public static implicit operator CompressionInfo(CompressionType compressionType)
-        {
-            return new CompressionInfo() {Type = compressionType};
-        }
-    }
-}
--- a/src/SharpCompress/Common/CompressionType.cs
+++ b/src/SharpCompress/Common/CompressionType.cs
@@ -11,6 +11,7 @@
        LZMA,
        BCJ,
        BCJ2,
-        Unknown,
+        LZip,
+        Unknown
    }
 }
--- a/src/SharpCompress/Common/Entry.cs
+++ b/src/SharpCompress/Common/Entry.cs
@@ -70,16 +70,11 @@ namespace SharpCompress.Common

        internal virtual void Close()
        {
-
        }

        /// <summary>
        /// Entry file attribute.
        /// </summary>
-        public virtual int? Attrib
-        {
-            get { throw new NotImplementedException(); }
-        }
-
+        public virtual int? Attrib => throw new NotImplementedException();
    }
 }
--- a/src/SharpCompress/Common/EntryStream.cs
+++ b/src/SharpCompress/Common/EntryStream.cs
@@ -1,19 +1,19 @@
 using System;
 using System.IO;
-using SharpCompress.Reader;
+using SharpCompress.Readers;

 namespace SharpCompress.Common
 {
    public class EntryStream : Stream
    {
-        public IReader Reader { get; private set; }
-        private Stream stream;
+        public IReader Reader { get; }
+        private readonly Stream stream;
        private bool completed;
        private bool isDisposed;

        internal EntryStream(IReader reader, Stream stream)
        {
-            this.Reader = reader;
+            Reader = reader;
            this.stream = stream;
        }

@@ -44,36 +44,20 @@ namespace SharpCompress.Common
            stream.Dispose();
        }

-        public override bool CanRead
-        {
-            get { return true; }
-        }
+        public override bool CanRead => true;

-        public override bool CanSeek
-        {
-            get { return false; }
-        }
+        public override bool CanSeek => false;

-        public override bool CanWrite
-        {
-            get { return false; }
-        }
+        public override bool CanWrite => false;

        public override void Flush()
        {
            throw new NotSupportedException();
        }

-        public override long Length
-        {
-            get { throw new NotSupportedException(); }
-        }
+        public override long Length => throw new NotSupportedException();

-        public override long Position
-        {
-            get { throw new NotSupportedException(); }
-            set { throw new NotSupportedException(); }
-        }
+        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }

        public override int Read(byte[] buffer, int offset, int count)
        {
--- a/src/SharpCompress/Common/FlagUtility.cs
+++ b/src/SharpCompress/Common/FlagUtility.cs
@@ -48,7 +48,7 @@ namespace SharpCompress.Common
        {
            return ((bitField & flag) == flag);
        }
-        
+
        /// <summary>
        /// Returns true if the flag is set on the specified bit field.
        /// Currently only works with 32-bit bitfields. 
@@ -75,7 +75,6 @@ namespace SharpCompress.Common
            return ((bitField & flag) == flag);
        }

-
        /// <summary>
        /// Sets a bit-field to either on or off for the specified flag.
        /// </summary>
@@ -83,9 +82,9 @@ namespace SharpCompress.Common
        /// <param name="flag">Flag to change</param>
        /// <param name="on">bool</param>
        /// <returns>The flagged variable with the flag changed</returns>
-        public static long SetFlag(long bitField, long flag, bool @on)
+        public static long SetFlag(long bitField, long flag, bool on)
        {
-            if (@on)
+            if (on)
            {
                return bitField | flag;
            }
@@ -100,10 +99,10 @@ namespace SharpCompress.Common
        /// <param name="flag">Flag to change</param>
        /// <param name="on">bool</param>
        /// <returns>The flagged variable with the flag changed</returns>
-        public static long SetFlag<T>(T bitField, T flag, bool @on)
+        public static long SetFlag<T>(T bitField, T flag, bool on)
            where T : struct
        {
-            return SetFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag), @on);
+            return SetFlag(Convert.ToInt64(bitField), Convert.ToInt64(flag), on);
        }
    }
 }
--- a/src/SharpCompress/Common/GZip/GZipEntry.cs
+++ b/src/SharpCompress/Common/GZip/GZipEntry.cs
@@ -13,70 +13,31 @@ namespace SharpCompress.Common.GZip
            this.filePart = filePart;
        }

-        public override CompressionType CompressionType
-        {
-            get { return CompressionType.GZip; }
-        }
+        public override CompressionType CompressionType => CompressionType.GZip;

-        public override long Crc
-        {
-            get { return 0; }
-        }
+        public override long Crc => 0;

-        public override string Key
-        {
-            get { return filePart.FilePartName; }
-        }
+        public override string Key => filePart.FilePartName;

-        public override long CompressedSize
-        {
-            get { return 0; }
-        }
+        public override long CompressedSize => 0;

-        public override long Size
-        {
-            get { return 0; }
-        }
+        public override long Size => 0;

-        public override DateTime? LastModifiedTime
-        {
-            get { return filePart.DateModified; }
-        }
+        public override DateTime? LastModifiedTime => filePart.DateModified;

-        public override DateTime? CreatedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? CreatedTime => null;

-        public override DateTime? LastAccessedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? LastAccessedTime => null;

-        public override DateTime? ArchivedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? ArchivedTime => null;

-        public override bool IsEncrypted
-        {
-            get { return false; }
-        }
+        public override bool IsEncrypted => false;

-        public override bool IsDirectory
-        {
-            get { return false; }
-        }
+        public override bool IsDirectory => false;

-        public override bool IsSplit
-        {
-            get { return false; }
-        }
+        public override bool IsSplit => false;

-        internal override IEnumerable<FilePart> Parts
-        {
-            get { return filePart.AsEnumerable<FilePart>(); }
-        }
+        internal override IEnumerable<FilePart> Parts => filePart.AsEnumerable<FilePart>();

        internal static IEnumerable<GZipEntry> GetEntries(Stream stream)
        {
--- a/src/SharpCompress/Common/GZip/GZipFilePart.cs
+++ b/src/SharpCompress/Common/GZip/GZipFilePart.cs
@@ -1,9 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
-using SharpCompress.Compressor;
-using SharpCompress.Compressor.Deflate;
-using SharpCompress.Converter;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.Deflate;
+using SharpCompress.Converters;

 namespace SharpCompress.Common.GZip
 {
@@ -15,15 +16,15 @@ namespace SharpCompress.Common.GZip
        internal GZipFilePart(Stream stream)
        {
            ReadAndValidateGzipHeader(stream);
+            EntryStartPosition = stream.Position;
            this.stream = stream;
        }

+        internal long EntryStartPosition { get; }
+
        internal DateTime? DateModified { get; private set; }

-        internal override string FilePartName
-        {
-            get { return name; }
-        }
+        internal override string FilePartName => name;

        internal override Stream GetCompressedStream()
        {
@@ -43,13 +44,19 @@ namespace SharpCompress.Common.GZip

            // workitem 8501: handle edge case (decompress empty stream)
            if (n == 0)
+            {
                return;
+            }

            if (n != 10)
+            {
                throw new ZlibException("Not a valid GZIP stream.");
+            }

            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            {
                throw new ZlibException("Bad GZIP header.");
+            }

            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
            DateModified = TarHeader.Epoch.AddSeconds(timet);
@@ -58,7 +65,7 @@ namespace SharpCompress.Common.GZip
                // read and discard extra field
                n = stream.Read(header, 0, 2); // 2-byte length field

-                Int16 extraLength = (Int16) (header[0] + header[1]*256);
+                Int16 extraLength = (Int16)(header[0] + header[1] * 256);
                byte[] extra = new byte[extraLength];
                n = stream.Read(extra, 0, extra.Length);
                if (n != extraLength)
@@ -67,18 +74,23 @@ namespace SharpCompress.Common.GZip
                }
            }
            if ((header[3] & 0x08) == 0x08)
+            {
                name = ReadZeroTerminatedString(stream);
+            }
            if ((header[3] & 0x10) == 0x010)
+            {
                ReadZeroTerminatedString(stream);
+            }
            if ((header[3] & 0x02) == 0x02)
+            {
                stream.ReadByte(); // CRC16, ignore
+            }
        }

-
        private static string ReadZeroTerminatedString(Stream stream)
        {
            byte[] buf1 = new byte[1];
-            var list = new System.Collections.Generic.List<byte>();
+            var list = new List<byte>();
            bool done = false;
            do
            {
@@ -96,7 +108,8 @@ namespace SharpCompress.Common.GZip
                {
                    list.Add(buf1[0]);
                }
-            } while (!done);
+            }
+            while (!done);
            byte[] a = list.ToArray();
            return ArchiveEncoding.Default.GetString(a, 0, a.Length);
        }
--- a/src/SharpCompress/Common/GZip/GZipVolume.cs
+++ b/src/SharpCompress/Common/GZip/GZipVolume.cs
@@ -1,29 +1,25 @@
 using System.IO;
+using SharpCompress.Readers;

 namespace SharpCompress.Common.GZip
 {
    public class GZipVolume : Volume
    {
-        public GZipVolume(Stream stream, Options options)
+        public GZipVolume(Stream stream, ReaderOptions options)
            : base(stream, options)
        {
        }

 #if !NO_FILE
-        public GZipVolume(FileInfo fileInfo, Options options)
+        public GZipVolume(FileInfo fileInfo, ReaderOptions options)
            : base(fileInfo.OpenRead(), options)
        {
+            options.LeaveStreamOpen = false;
        }
 #endif

-        public override bool IsFirstVolume
-        {
-            get { return true; }
-        }
+        public override bool IsFirstVolume => true;

-        public override bool IsMultiVolume
-        {
-            get { return true; }
-        }
+        public override bool IsMultiVolume => true;
    }
 }
--- a/src/SharpCompress/Common/IEntry.Extensions.cs
+++ b/src/SharpCompress/Common/IEntry.Extensions.cs
@@ -1,14 +1,16 @@
-#if !NO_FILE
+
+#if !NO_FILE
 using System.IO;
+using SharpCompress.Readers;

 namespace SharpCompress.Common
 {
    internal static class IEntryExtensions
    {
        internal static void PreserveExtractionOptions(this IEntry entry, string destinationFileName,
-                                                        ExtractOptions options)
+                                                        ExtractionOptions options)
        {
-            if (options.HasFlag(ExtractOptions.PreserveFileTime) || options.HasFlag(ExtractOptions.PreserveAttributes))
+            if (options.PreserveFileTime || options.PreserveAttributes)
            {
                FileInfo nf = new FileInfo(destinationFileName);
                if (!nf.Exists)
@@ -17,7 +19,7 @@ namespace SharpCompress.Common
                }

                // update file time to original packed time
-                if (options.HasFlag(ExtractOptions.PreserveFileTime))
+                if (options.PreserveFileTime)
                {
                    if (entry.CreatedTime.HasValue)
                    {
@@ -35,7 +37,7 @@ namespace SharpCompress.Common
                    }
                }

-                if (options.HasFlag(ExtractOptions.PreserveAttributes))
+                if (options.PreserveAttributes)
                {
                    if (entry.Attrib.HasValue)
                    {
@@ -46,4 +48,4 @@ namespace SharpCompress.Common
        }
    }
 }
-#endif
+#endif
--- a/src/SharpCompress/Common/IVolume.cs
+++ b/src/SharpCompress/Common/IVolume.cs
@@ -1,4 +1,5 @@
 using System;
+
 #if !NO_FILE
 using System.IO;
 #endif
--- a/src/SharpCompress/Common/Options.cs
+++ b/src/SharpCompress/Common/Options.cs
@@ -1,23 +0,0 @@
-using System;
-
-namespace SharpCompress.Common
-{
-    [Flags]
-    public enum Options
-    {
-        /// <summary>
-        /// No options specified
-        /// </summary>
-        None = 0,
-
-        /// <summary>
-        /// SharpCompress will keep the supplied streams open
-        /// </summary>
-        KeepStreamsOpen = 1,
-
-        /// <summary>
-        /// Look for RarArchive (Check for self-extracting archives or cases where RarArchive isn't at the start of the file)
-        /// </summary>
-        LookForHeader = 2,
-    }
-}
--- a/src/SharpCompress/Common/OptionsBase.cs
+++ b/src/SharpCompress/Common/OptionsBase.cs
@@ -0,0 +1,10 @@
+namespace SharpCompress.Common
+{
+    public class OptionsBase
+    {
+        /// <summary>
+        /// SharpCompress will keep the supplied streams open.  Default is true.
+        /// </summary>
+        public bool LeaveStreamOpen { get; set; } = true;
+    }
+}
--- a/src/SharpCompress/Common/Rar/Headers/ArchiveHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/ArchiveHeader.cs
@@ -17,10 +17,7 @@ namespace SharpCompress.Common.Rar.Headers
            }
        }

-        internal ArchiveFlags ArchiveHeaderFlags
-        {
-            get { return (ArchiveFlags) base.Flags; }
-        }
+        internal ArchiveFlags ArchiveHeaderFlags => (ArchiveFlags)Flags;

        internal short HighPosAv { get; private set; }

@@ -28,9 +25,6 @@ namespace SharpCompress.Common.Rar.Headers

        internal byte EncryptionVersion { get; private set; }

-        public bool HasPassword
-        {
-            get { return ArchiveHeaderFlags.HasFlag(ArchiveFlags.PASSWORD); }
-        }
+        public bool HasPassword => ArchiveHeaderFlags.HasFlag(ArchiveFlags.PASSWORD);
    }
 }
--- a/src/SharpCompress/Common/Rar/Headers/EndArchiveHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/EndArchiveHeader.cs
@@ -16,10 +16,7 @@ namespace SharpCompress.Common.Rar.Headers
            }
        }

-        internal EndArchiveFlags EndArchiveFlags
-        {
-            get { return (EndArchiveFlags) base.Flags; }
-        }
+        internal EndArchiveFlags EndArchiveFlags => (EndArchiveFlags)Flags;

        internal int? ArchiveCRC { get; private set; }

--- a/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/FileHeader.cs
@@ -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 = DecodeDefault(fileNameBytes);
-                            }
+                            length++;
+                        }
+                        if (length != nameSize)
+                        {
+                            length++;
+                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
                        }
                        else
                        {
                            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;
            }

@@ -155,6 +155,7 @@ namespace SharpCompress.Common.Rar.Headers
                byte b = reader.ReadByte();
                nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
            }
+
            //10^-7 to 10^-3
            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
        }
@@ -207,10 +208,7 @@ namespace SharpCompress.Common.Rar.Headers

        internal int FileAttributes { get; private set; }

-        internal FileFlags FileFlags
-        {
-            get { return (FileFlags)base.Flags; }
-        }
+        internal FileFlags FileFlags => (FileFlags)Flags;

        internal long CompressedSize { get; private set; }
        internal long UncompressedSize { get; private set; }
--- a/src/SharpCompress/Common/Rar/Headers/FileNameDecoder.cs
+++ b/src/SharpCompress/Common/Rar/Headers/FileNameDecoder.cs
@@ -32,19 +32,19 @@ namespace SharpCompress.Common.Rar.Headers
                switch (flags >> 6)
                {
                    case 0:
-                        buf.Append((char) (GetChar(name, encPos++)));
+                        buf.Append((char)(GetChar(name, encPos++)));
                        ++decPos;
                        break;

                    case 1:
-                        buf.Append((char) (GetChar(name, encPos++) + (highByte << 8)));
+                        buf.Append((char)(GetChar(name, encPos++) + (highByte << 8)));
                        ++decPos;
                        break;

                    case 2:
                        low = GetChar(name, encPos);
                        high = GetChar(name, encPos + 1);
-                        buf.Append((char) ((high << 8) + low));
+                        buf.Append((char)((high << 8) + low));
                        ++decPos;
                        encPos += 2;
                        break;
@@ -57,14 +57,14 @@ namespace SharpCompress.Common.Rar.Headers
                            for (length = (length & 0x7f) + 2; length > 0 && decPos < name.Length; length--, decPos++)
                            {
                                low = (GetChar(name, decPos) + correction) & 0xff;
-                                buf.Append((char) ((highByte << 8) + low));
+                                buf.Append((char)((highByte << 8) + low));
                            }
                        }
                        else
                        {
                            for (length += 2; length > 0 && decPos < name.Length; length--, decPos++)
                            {
-                                buf.Append((char) (GetChar(name, decPos)));
+                                buf.Append((char)(GetChar(name, decPos)));
                            }
                        }
                        break;
--- a/src/SharpCompress/Common/Rar/Headers/Flags.cs
+++ b/src/SharpCompress/Common/Rar/Headers/Flags.cs
@@ -13,12 +13,12 @@ namespace SharpCompress.Common.Rar.Headers
        ProtectHeader = 0x78,
        SignHeader = 0x79,
        NewSubHeader = 0x7a,
-        EndArchiveHeader = 0x7b,
+        EndArchiveHeader = 0x7b
    }

    internal enum HeaderFlags : short
    {
-        LONG_BLOCK = -0x8000,
+        LONG_BLOCK = -0x8000
    }

    [Flags]
@@ -33,7 +33,7 @@ namespace SharpCompress.Common.Rar.Headers
        PROTECT = 0x0040,
        PASSWORD = 0x0080,
        FIRSTVOLUME = 0x0100,
-        ENCRYPTVER = 0x0200,
+        ENCRYPTVER = 0x0200
    }

    internal enum HostOS
@@ -70,16 +70,15 @@ namespace SharpCompress.Common.Rar.Headers
        SALT = 0x0400,
        VERSION = 0x0800,
        EXTTIME = 0x1000,
-        EXTFLAGS = 0x2000,
+        EXTFLAGS = 0x2000
    }

-
    [Flags]
    internal enum EndArchiveFlags
    {
        EARC_NEXT_VOLUME = 0x0001,
        EARC_DATACRC = 0x0002,
        EARC_REVSPACE = 0x0004,
-        EARC_VOLNUMBER = 0x0008,
+        EARC_VOLNUMBER = 0x0008
    }
 }
--- a/src/SharpCompress/Common/Rar/Headers/NewSubHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/NewSubHeader.cs
@@ -20,14 +20,14 @@ namespace SharpCompress.Common.Rar.Headers

        //internal static final NewSubHeaderType SUBHEAD_TYPE_BEOSEA = new NewSubHeaderType(new byte[]{'E','A','B','E'});

-        private byte[] bytes;
+        private readonly byte[] bytes;

        private NewSubHeaderType(params char[] chars)
        {
            bytes = new byte[chars.Length];
            for (int i = 0; i < chars.Length; ++i)
            {
-                bytes[i] = (byte) chars[i];
+                bytes[i] = (byte)chars[i];
            }
        }

--- a/src/SharpCompress/Common/Rar/Headers/ProtectHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/ProtectHeader.cs
@@ -13,10 +13,10 @@ namespace SharpCompress.Common.Rar.Headers
            Mark = reader.ReadBytes(8);
        }

-        internal uint DataSize { get { return AdditionalSize; } }
+        internal uint DataSize => AdditionalSize;
        internal byte Version { get; private set; }
        internal ushort RecSectors { get; private set; }
        internal uint TotalBlocks { get; private set; }
        internal byte[] Mark { get; private set; }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/Headers/RarHeader.cs
+++ b/src/SharpCompress/Common/Rar/Headers/RarHeader.cs
@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Rar.Headers
@@ -18,14 +19,14 @@ namespace SharpCompress.Common.Rar.Headers
            ReadBytes = baseHeader.ReadBytes;
        }

-        internal static RarHeader Create(MarkingBinaryReader reader)
+        internal static RarHeader Create(RarCrcBinaryReader reader)
        {
            try
            {
                RarHeader header = new RarHeader();

                reader.Mark();
-                header.ReadFromReader(reader);
+                header.ReadStartFromReader(reader);
                header.ReadBytes += reader.CurrentReadByteCount;

                return header;
@@ -35,9 +36,11 @@ namespace SharpCompress.Common.Rar.Headers
                return null;
            }
        }
-        protected virtual void ReadFromReader(MarkingBinaryReader reader)
+
+        private void ReadStartFromReader(RarCrcBinaryReader reader)
        {
-            HeadCRC = reader.ReadInt16();
+            HeadCRC = reader.ReadUInt16();
+            reader.ResetCrc();
            HeaderType = (HeaderType)(reader.ReadByte() & 0xff);
            Flags = reader.ReadInt16();
            HeaderSize = reader.ReadInt16();
@@ -47,7 +50,11 @@ namespace SharpCompress.Common.Rar.Headers
            }
        }

-        internal T PromoteHeader<T>(MarkingBinaryReader reader)
+        protected virtual void ReadFromReader(MarkingBinaryReader reader) {
+            throw new NotImplementedException();
+        }
+
+        internal T PromoteHeader<T>(RarCrcBinaryReader reader)
            where T : RarHeader, new()
        {
            T header = new T();
@@ -64,9 +71,21 @@ namespace SharpCompress.Common.Rar.Headers
                reader.ReadBytes(headerSizeDiff);
            }

+            VerifyHeaderCrc(reader.GetCrc());
+
            return header;
        }

+        private void VerifyHeaderCrc(ushort crc) {
+            if (HeaderType != HeaderType.MarkHeader) 
+            {
+                if (crc != HeadCRC) 
+                {
+                    throw new InvalidFormatException("rar header crc mismatch");
+                }
+            }
+        }
+
        protected virtual void PostReadingBytes(MarkingBinaryReader reader)
        {
        }
@@ -76,7 +95,7 @@ namespace SharpCompress.Common.Rar.Headers
        /// </summary>
        protected long ReadBytes { get; private set; }

-        protected short HeadCRC { get; private set; }
+        protected ushort HeadCRC { get; private set; }

        internal HeaderType HeaderType { get; private set; }

--- a/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
+++ b/src/SharpCompress/Common/Rar/Headers/RarHeaderFactory.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.IO;
+using SharpCompress.Readers;

 namespace SharpCompress.Common.Rar.Headers
 {
@@ -9,21 +10,19 @@ namespace SharpCompress.Common.Rar.Headers
    {
        private const int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136

-        internal RarHeaderFactory(StreamingMode mode, Options options, string password = null)
+        internal RarHeaderFactory(StreamingMode mode, ReaderOptions options)
        {
            StreamingMode = mode;
            Options = options;
-            Password = password;
        }

-        private Options Options { get; set; }
-        public string Password { get; private set; }
-        internal StreamingMode StreamingMode { get; private set; }
+        private ReaderOptions Options { get; }
+        internal StreamingMode StreamingMode { get; }
        internal bool IsEncrypted { get; private set; }
-        
+
        internal IEnumerable<RarHeader> ReadHeaders(Stream stream)
        {
-            if (Options.HasFlag(Options.LookForHeader))
+            if (Options.LookForHeader)
            {
                stream = CheckSFX(stream);
            }
@@ -91,7 +90,7 @@ namespace SharpCompress.Common.Rar.Headers
            }
            catch (Exception e)
            {
-                if (!Options.HasFlag(Options.KeepStreamsOpen))
+                if (!Options.LeaveStreamOpen)
                {
 #if NET35
                    reader.Close();
@@ -114,15 +113,14 @@ namespace SharpCompress.Common.Rar.Headers
            return rewindableStream;
        }

-
        private RarHeader ReadNextHeader(Stream stream)
        {
 #if !NO_CRYPTO
-            var reader = new RarCryptoBinaryReader(stream, Password);
+            var reader = new RarCryptoBinaryReader(stream, Options.Password);
            
            if (IsEncrypted)
            {
-                if (Password == null)
+                if (Options.Password == null)
                {
                    throw new CryptographicException("Encrypted Rar archive has no password specified.");
                }
@@ -131,7 +129,7 @@ namespace SharpCompress.Common.Rar.Headers
                reader.InitializeAes(salt);
            }
 #else
-            var reader = new MarkingBinaryReader(stream);
+            var reader = new RarCrcBinaryReader(stream);

 #endif

@@ -143,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)
-                        {
-                            case StreamingMode.Seekable:
-                                {
-                                    reader.BaseStream.Position += ph.DataSize;
-                                }
-                                break;
-                            case StreamingMode.Streaming:
-                                {
-                                    reader.BaseStream.Skip(ph.DataSize);
-                                }
-                                break;
-                            default:
-                                {
-                                    throw new InvalidFormatException("Invalid StreamingMode");
-                                }
-                        }
+                {
+                    ProtectHeader ph = header.PromoteHeader<ProtectHeader>(reader);

-                        return ph;
+                    // skip the recovery record data, we do not use it.
+                    switch (StreamingMode)
+                    {
+                        case StreamingMode.Seekable:
+                        {
+                            reader.BaseStream.Position += ph.DataSize;
+                        }
+                            break;
+                        case StreamingMode.Streaming:
+                        {
+                            reader.BaseStream.Skip(ph.DataSize);
+                        }
+                            break;
+                        default:
+                        {
+                            throw new InvalidFormatException("Invalid StreamingMode");
+                        }
                    }

+                    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;
+                        }
+                            break;
+                        case StreamingMode.Streaming:
+                        {
+                            //skip the data because it's useless?
+                            reader.BaseStream.Skip(fh.CompressedSize);
+                        }
+                            break;
+                        default:
+                        {
+                            throw new InvalidFormatException("Invalid StreamingMode");
                        }
-                        return fh;
                    }
+                    return fh;
+                }
                case HeaderType.FileHeader:
+                {
+                    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:
-                                {
-                                    var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                                    if (fh.Salt == null)
-                                    {
-                                        fh.PackedStream = ms;
-                                    }
-                                    else
-                                    {
-#if !NO_CRYPTO
-                                        fh.PackedStream = new RarCryptoWrapper(ms, Password,  fh.Salt);
-#else
-                                        throw new NotSupportedException("RarCrypto not supported");
-#endif
-                                    }
-                                }
-                                break;
-                            default:
-                                {
-                                    throw new InvalidFormatException("Invalid StreamingMode");
-                                }
+                            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);
+#else
+                                throw new NotSupportedException("RarCrypto not supported");
+#endif
+                            }
+                        }
+                            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.ToString());
-                    }
+                {
+                    throw new InvalidFormatException("Invalid Rar Header: " + header.HeaderType);
+                }
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Rar/RarCrcBinaryReader.cs
+++ b/src/SharpCompress/Common/Rar/RarCrcBinaryReader.cs
@@ -0,0 +1,40 @@
+using System.IO;
+using SharpCompress.Compressors.Rar;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar {
+    internal class RarCrcBinaryReader : MarkingBinaryReader {
+        private uint currentCrc;
+
+        public RarCrcBinaryReader(Stream stream) : base(stream)
+        {
+        }
+
+        public ushort GetCrc() 
+        {
+            return (ushort)~currentCrc;
+        }
+
+        public void ResetCrc()
+        {
+            currentCrc = 0xffffffff;
+        }
+
+        protected void UpdateCrc(byte b) 
+        {
+            currentCrc = RarCRC.CheckCrc(currentCrc, b);
+        }
+
+        protected byte[] ReadBytesNoCrc(int count)
+        {
+            return base.ReadBytes(count);
+        }
+
+        public override byte[] ReadBytes(int count)
+        {
+            var result = base.ReadBytes(count);
+            currentCrc = RarCRC.CheckCrc(currentCrc, result, 0, result.Length);
+            return result;
+        }
+    }
+}
--- a/src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs
@@ -1,16 +1,18 @@
-#if !NO_CRYPTO
+
+#if !NO_CRYPTO
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.IO;

 namespace SharpCompress.Common.Rar
 {
-    internal class RarCryptoBinaryReader : MarkingBinaryReader
+    internal class RarCryptoBinaryReader : RarCrcBinaryReader
    {
        private RarRijndael rijndael;
        private byte[] salt;
        private readonly string password;
        private readonly Queue<byte> data = new Queue<byte>();
+        private long readCount;

        public RarCryptoBinaryReader(Stream stream, string password )
            : base(stream)
@@ -18,6 +20,22 @@ namespace SharpCompress.Common.Rar
            this.password = password;
        }

+        // track read count ourselves rather than using the underlying stream since we buffer
+        public override long CurrentReadByteCount {
+            get 
+            {
+                return this.readCount;
+            }
+            protected set 
+            {
+                // ignore
+            }
+        }
+
+        public override void Mark() {
+            this.readCount = 0;
+        }
+        
        protected bool UseEncryption
        {
            get { return salt != null; }
@@ -35,6 +53,7 @@ namespace SharpCompress.Common.Rar
            {
                return ReadAndDecryptBytes(count);
            }
+            this.readCount += count;
            return base.ReadBytes(count);
        }

@@ -49,7 +68,7 @@ namespace SharpCompress.Common.Rar
                for (int i = 0; i < alignedSize / 16; i++)
                {
                    //long ax = System.currentTimeMillis();
-                    byte[] cipherText = base.ReadBytes(16);
+                    byte[] cipherText = base.ReadBytesNoCrc(16);
                    var readBytes = rijndael.ProcessBlock(cipherText);
                    foreach (var readByte in readBytes)
                        data.Enqueue(readByte);
@@ -62,8 +81,11 @@ namespace SharpCompress.Common.Rar

            for (int i = 0; i < count; i++)
            {
-                decryptedBytes[i] = data.Dequeue();
+                var b = data.Dequeue();
+                decryptedBytes[i] = b;
+                UpdateCrc(b);
            }
+            this.readCount += count;
            return decryptedBytes;
        }

--- a/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
+++ b/src/SharpCompress/Common/Rar/RarCryptoWrapper.cs
@@ -1,3 +1,4 @@
+
 #if !NO_CRYPTO
 using System;
 using System.Collections.Generic;
--- a/src/SharpCompress/Common/Rar/RarEntry.cs
+++ b/src/SharpCompress/Common/Rar/RarEntry.cs
@@ -10,71 +10,44 @@ namespace SharpCompress.Common.Rar
        /// <summary>
        /// The File's 32 bit CRC Hash
        /// </summary>
-        public override long Crc
-        {
-            get { return FileHeader.FileCRC; }
-        }
+        public override long Crc => FileHeader.FileCRC;

        /// <summary>
        /// The path of the file internal to the Rar Archive.
        /// </summary>
-        public override string Key
-        {
-            get { return FileHeader.FileName; }
-        }
+        public override string Key => FileHeader.FileName;

        /// <summary>
        /// The entry last modified time in the archive, if recorded
        /// </summary>
-        public override DateTime? LastModifiedTime
-        {
-            get { return FileHeader.FileLastModifiedTime; }
-        }
+        public override DateTime? LastModifiedTime => FileHeader.FileLastModifiedTime;

        /// <summary>
        /// The entry create time in the archive, if recorded
        /// </summary>
-        public override DateTime? CreatedTime
-        {
-            get { return FileHeader.FileCreatedTime; }
-        }
+        public override DateTime? CreatedTime => FileHeader.FileCreatedTime;

        /// <summary>
        /// The entry last accessed time in the archive, if recorded
        /// </summary>
-        public override DateTime? LastAccessedTime
-        {
-            get { return FileHeader.FileLastAccessedTime; }
-        }
+        public override DateTime? LastAccessedTime => FileHeader.FileLastAccessedTime;

        /// <summary>
        /// The entry time whend archived, if recorded
        /// </summary>
-        public override DateTime? ArchivedTime
-        {
-            get { return FileHeader.FileArchivedTime; }
-        }
+        public override DateTime? ArchivedTime => FileHeader.FileArchivedTime;

        /// <summary>
        /// Entry is password protected and encrypted and cannot be extracted.
        /// </summary>
-        public override bool IsEncrypted
-        {
-            get { return FileHeader.FileFlags.HasFlag(FileFlags.PASSWORD); }
-        }
+        public override bool IsEncrypted => FileHeader.FileFlags.HasFlag(FileFlags.PASSWORD);

        /// <summary>
        /// Entry is password protected and encrypted and cannot be extracted.
        /// </summary>
-        public override bool IsDirectory
-        {
-            get { return FileHeader.FileFlags.HasFlag(FileFlags.DIRECTORY); }
-        }
+        public override bool IsDirectory => FileHeader.FileFlags.HasFlag(FileFlags.DIRECTORY);

-        public override bool IsSplit
-        {
-            get { return FileHeader.FileFlags.HasFlag(FileFlags.SPLIT_AFTER); }
-        }
+        public override bool IsSplit => FileHeader.FileFlags.HasFlag(FileFlags.SPLIT_AFTER);

        public override string ToString()
        {
--- a/src/SharpCompress/Common/Rar/RarRijndael.cs
+++ b/src/SharpCompress/Common/Rar/RarRijndael.cs
@@ -74,13 +74,16 @@ namespace SharpCompress.Common.Rar

            byte[] aesKey = new byte[CRYPTO_BLOCK_SIZE];
            for (int i = 0; i < 4; i++)
+            {
                for (int j = 0; j < 4; j++)
+                {
                    aesKey[i*4 + j] = (byte)
                        (((digest[i*4]*0x1000000) & 0xff000000 |
                          (uint) ((digest[i*4 + 1]*0x10000) & 0xff0000) |
                          (uint) ((digest[i*4 + 2]*0x100) & 0xff00) |
                          (uint) (digest[i*4 + 3] & 0xff)) >> (j*8));
-
+                }
+            }

            rijndael.Init(false, new KeyParameter(aesKey));

@@ -100,10 +103,14 @@ namespace SharpCompress.Common.Rar
            rijndael.ProcessBlock(cipherText, 0, plainText, 0);

            for (int j = 0; j < plainText.Length; j++)
+            {
                decryptedBytes.Add((byte) (plainText[j] ^ aesInitializationVector[j%16])); //32:114, 33:101
+            }

            for (int j = 0; j < aesInitializationVector.Length; j++)
+            {
                aesInitializationVector[j] = cipherText[j];
+            }
            return decryptedBytes.ToArray();
        }

--- a/src/SharpCompress/Common/Rar/RarVolume.cs
+++ b/src/SharpCompress/Common/Rar/RarVolume.cs
@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
+using SharpCompress.Readers;

 namespace SharpCompress.Common.Rar
 {
@@ -13,20 +14,14 @@ namespace SharpCompress.Common.Rar
    public abstract class RarVolume : Volume
    {
        private readonly RarHeaderFactory headerFactory;
-            
-        internal RarVolume(StreamingMode mode, Stream stream, string password, Options options)
+
+        internal RarVolume(StreamingMode mode, Stream stream, ReaderOptions options)
            : base(stream, options)
        {
-            headerFactory = new RarHeaderFactory(mode, options, password);
-            Password = password;
+            headerFactory = new RarHeaderFactory(mode, options);
        }

-        internal string Password { get; private set; }
-
-        internal StreamingMode Mode
-        {
-            get { return headerFactory.StreamingMode; }
-        }
+        internal StreamingMode Mode => headerFactory.StreamingMode;

        internal abstract IEnumerable<RarFilePart> ReadFileParts();

@@ -35,26 +30,26 @@ namespace SharpCompress.Common.Rar
        internal IEnumerable<RarFilePart> GetVolumeFileParts()
        {
            MarkHeader previousMarkHeader = null;
-            foreach (RarHeader header in headerFactory.ReadHeaders(this.Stream))
+            foreach (RarHeader header in headerFactory.ReadHeaders(Stream))
            {
                switch (header.HeaderType)
                {
                    case HeaderType.ArchiveHeader:
-                        {
-                            ArchiveHeader = header as ArchiveHeader;
-                        }
+                    {
+                        ArchiveHeader = header as ArchiveHeader;
+                    }
                        break;
                    case HeaderType.MarkHeader:
-                        {
-                            previousMarkHeader = header as MarkHeader;
-                        }
+                    {
+                        previousMarkHeader = header as MarkHeader;
+                    }
                        break;
                    case HeaderType.FileHeader:
-                        {
-                            FileHeader fh = header as FileHeader;
-                            RarFilePart fp = CreateFilePart(fh, previousMarkHeader);
-                            yield return fp;
-                        }
+                    {
+                        FileHeader fh = header as FileHeader;
+                        RarFilePart fp = CreateFilePart(fh, previousMarkHeader);
+                        yield return fp;
+                    }
                        break;
                }
            }
@@ -70,6 +65,7 @@ namespace SharpCompress.Common.Rar
                {
                    throw new InvalidOperationException("ArchiveHeader should never been null in a streaming read.");
                }
+
                //we only want to load the archive header to avoid overhead but have to do the nasty thing and reset the stream
                GetVolumeFileParts().First();
                Stream.Position = 0;
--- a/src/SharpCompress/Common/ReaderExtractionEventArgs.cs
+++ b/src/SharpCompress/Common/ReaderExtractionEventArgs.cs
@@ -1,13 +1,17 @@
 using System;
+using SharpCompress.Readers;

 namespace SharpCompress.Common
 {
    public class ReaderExtractionEventArgs<T> : EventArgs
    {
-        internal ReaderExtractionEventArgs(T entry)
+        internal ReaderExtractionEventArgs(T entry, ReaderProgress readerProgress = null)
        {
            Item = entry;
+            ReaderProgress = readerProgress;
        }
+
        public T Item { get; private set; }
+        public ReaderProgress ReaderProgress { get; private set; }
    }
-}
+}
--- a/src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs
@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using SharpCompress.Compressor.LZMA;
-using SharpCompress.Compressor.LZMA.Utilites;
+using SharpCompress.Compressors.LZMA;
+using SharpCompress.Compressors.LZMA.Utilites;

 namespace SharpCompress.Common.SevenZip
 {
@@ -80,15 +80,19 @@ namespace SharpCompress.Common.SevenZip
                {
                    // v3.13 incorrectly worked with empty folders
                    // v4.07: Loop for skipping empty folders
-                    for (; ; )
+                    for (;;)
                    {
                        if (folderIndex >= Folders.Count)
+                        {
                            throw new InvalidOperationException();
+                        }

                        FolderStartFileIndex.Add(i); // check it

                        if (NumUnpackStreamsVector[folderIndex] != 0)
+                        {
                            break;
+                        }

                        folderIndex++;
                    }
@@ -97,7 +101,9 @@ namespace SharpCompress.Common.SevenZip
                FileIndexToFolderIndexMap.Add(folderIndex);

                if (emptyStream)
+                {
                    continue;
+                }

                indexInFolder++;

@@ -128,7 +134,9 @@ namespace SharpCompress.Common.SevenZip

            long size = 0;
            for (int i = 0; i < folder.PackStreams.Count; i++)
+            {
                size += PackSizes[packStreamIndex + i];
+            }

            return size;
        }
@@ -139,7 +147,9 @@ namespace SharpCompress.Common.SevenZip
            long folderStartPackPos = GetFolderStreamPos(folder, 0);
            List<long> packSizes = new List<long>();
            for (int j = 0; j < folder.PackStreams.Count; j++)
+            {
                packSizes.Add(PackSizes[packStreamIndex + j]);
+            }

            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes.ToArray(), folder, pw);
        }
@@ -153,8 +163,12 @@ namespace SharpCompress.Common.SevenZip
        {
            int folderIndex = FileIndexToFolderIndexMap[fileIndex];
            if (folderIndex != -1)
+            {
                if (FolderStartFileIndex[folderIndex] == fileIndex)
+                {
                    return GetFolderFullPackSize(folderIndex);
+                }
+            }
            return 0;
        }
    }
--- a/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
+++ b/src/SharpCompress/Common/SevenZip/ArchiveReader.cs
@@ -1,9 +1,10 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using SharpCompress.Compressor.LZMA;
-using SharpCompress.Compressor.LZMA.Utilites;
+using SharpCompress.Compressors.LZMA;
+using SharpCompress.Compressors.LZMA.Utilites;
 using SharpCompress.IO;

 namespace SharpCompress.Common.SevenZip
@@ -17,7 +18,7 @@ namespace SharpCompress.Common.SevenZip
        internal long _streamEnding;
        internal byte[] _header;

-        private Dictionary<int, Stream> _cachedStreams = new Dictionary<int, Stream>();
+        private readonly Dictionary<int, Stream> _cachedStreams = new Dictionary<int, Stream>();

        internal void AddByteStream(byte[] buffer, int offset, int length)
        {
@@ -66,7 +67,9 @@ namespace SharpCompress.Common.SevenZip
        {
            ulong id = _currentReader.ReadNumber();
            if (id > 25)
+            {
                return null;
+            }
 #if DEBUG
            Log.WriteLine("ReadId: {0}", (BlockType)id);
 #endif
@@ -85,13 +88,17 @@ namespace SharpCompress.Common.SevenZip

        private void WaitAttribute(BlockType attribute)
        {
-            for (; ; )
+            for (;;)
            {
                BlockType? type = ReadId();
                if (type == attribute)
+                {
                    return;
+                }
                if (type == BlockType.End)
+                {
                    throw new InvalidOperationException();
+                }
                SkipData();
            }
        }
@@ -99,7 +106,9 @@ namespace SharpCompress.Common.SevenZip
        private void ReadArchiveProperties()
        {
            while (ReadId() != BlockType.End)
+            {
                SkipData();
+            }
        }

        #endregion
@@ -122,7 +131,9 @@ namespace SharpCompress.Common.SevenZip
                }

                if ((data & mask) != 0)
+                {
                    bits.SetBit(i);
+                }

                mask >>= 1;
            }
@@ -134,7 +145,9 @@ namespace SharpCompress.Common.SevenZip
        {
            byte allTrue = ReadByte();
            if (allTrue != 0)
+            {
                return new BitVector(length, true);
+            }

            return ReadBitVector(length);
        }
@@ -150,9 +163,13 @@ namespace SharpCompress.Common.SevenZip
                for (int i = 0; i < numFiles; i++)
                {
                    if (defined[i])
+                    {
                        action(i, checked((long)ReadUInt64()));
+                    }
                    else
+                    {
                        action(i, null);
+                    }
                }
            }
        }
@@ -166,9 +183,10 @@ namespace SharpCompress.Common.SevenZip
        private DateTime? TranslateTime(long? time)
        {
            if (time.HasValue)
+            {
                return TranslateTime(time.Value);
-            else
-                return null;
+            }
+            return null;
        }

        private void ReadDateTimeVector(List<byte[]> dataVector, int numFiles, Action<int, DateTime?> action)
@@ -185,9 +203,13 @@ namespace SharpCompress.Common.SevenZip
                for (int i = 0; i < numFiles; i++)
                {
                    if (boolVector[i])
+                    {
                        action(i, ReadUInt32());
+                    }
                    else
+                    {
                        action(i, null);
+                    }
                }
            }
        }
@@ -230,10 +252,14 @@ namespace SharpCompress.Common.SevenZip
                        Log.WriteLine("MethodId: " + String.Join("", Enumerable.Range(0, idSize).Select(x => longID[x].ToString("x2")).ToArray()));
 #endif
                        if (idSize > 8)
+                        {
                            throw new NotSupportedException();
+                        }
                        ulong id = 0;
                        for (int j = 0; j < idSize; j++)
+                        {
                            id |= (ulong)longID[idSize - 1 - j] << (8 * j);
+                        }
                        coder.MethodId = new CMethodId(id);

                        if ((mainByte & 0x10) != 0)
@@ -264,7 +290,9 @@ namespace SharpCompress.Common.SevenZip
                        }

                        if ((mainByte & 0x80) != 0)
+                        {
                            throw new NotSupportedException();
+                        }

                        numInStreams += coder.NumInStreams;
                        numOutStreams += coder.NumOutStreams;
@@ -298,9 +326,12 @@ namespace SharpCompress.Common.SevenZip
 #endif

                if (numInStreams < numBindPairs)
+                {
                    throw new NotSupportedException();
+                }

                int numPackStreams = numInStreams - numBindPairs;
+
                //folder.PackStreams.Reserve(numPackStreams);
                if (numPackStreams == 1)
                {
@@ -317,7 +348,9 @@ namespace SharpCompress.Common.SevenZip
                    }

                    if (folder.PackStreams.Count != 1)
+                    {
                        throw new NotSupportedException();
+                    }
                }
                else
                {
@@ -417,11 +450,13 @@ namespace SharpCompress.Common.SevenZip
 #endif

                BlockType? type;
-                for (; ; )
+                for (;;)
                {
                    type = ReadId();
                    if (type == BlockType.End)
+                    {
                        break;
+                    }
                    if (type == BlockType.CRC)
                    {
                        packCRCs = ReadHashDigests(numPackStreams);
@@ -434,7 +469,9 @@ namespace SharpCompress.Common.SevenZip
                {
                    packCRCs = new List<uint?>(numPackStreams);
                    for (int i = 0; i < numPackStreams; i++)
+                    {
                        packCRCs.Add(null);
+                    }
                }
            }
            finally
@@ -462,13 +499,14 @@ namespace SharpCompress.Common.SevenZip
                using (CStreamSwitch streamSwitch = new CStreamSwitch())
                {
                    streamSwitch.Set(this, dataVector);
+
                    //folders.Clear();
                    //folders.Reserve(numFolders);
                    folders = new List<CFolder>(numFolders);
                    int index = 0;
                    for (int i = 0; i < numFolders; i++)
                    {
-                        var f = new CFolder { FirstPackStreamId = index };
+                        var f = new CFolder {FirstPackStreamId = index};
                        folders.Add(f);
                        GetNextFolderItem(f);
                        index += f.PackStreams.Count;
@@ -499,17 +537,21 @@ namespace SharpCompress.Common.SevenZip
 #endif
                }

-                for (; ; )
+                for (;;)
                {
                    BlockType? type = ReadId();
                    if (type == BlockType.End)
+                    {
                        return;
+                    }

                    if (type == BlockType.CRC)
                    {
                        List<uint?> crcs = ReadHashDigests(numFolders);
                        for (int i = 0; i < numFolders; i++)
+                        {
                            folders[i].UnpackCRC = crcs[i];
+                        }
                        continue;
                    }

@@ -536,7 +578,7 @@ namespace SharpCompress.Common.SevenZip
                numUnpackStreamsInFolders = null;

                BlockType? type;
-                for (; ; )
+                for (;;)
                {
                    type = ReadId();
                    if (type == BlockType.NumUnpackStream)
@@ -559,9 +601,13 @@ namespace SharpCompress.Common.SevenZip
                        continue;
                    }
                    if (type == BlockType.CRC || type == BlockType.Size)
+                    {
                        break;
+                    }
                    if (type == BlockType.End)
+                    {
                        break;
+                    }
                    SkipData();
                }

@@ -569,7 +615,9 @@ namespace SharpCompress.Common.SevenZip
                {
                    numUnpackStreamsInFolders = new List<int>(folders.Count);
                    for (int i = 0; i < folders.Count; i++)
+                    {
                        numUnpackStreamsInFolders.Add(1);
+                    }
                }

                unpackSizes = new List<long>(folders.Count);
@@ -579,7 +627,9 @@ namespace SharpCompress.Common.SevenZip
                    // v4.07: we check that folder is empty
                    int numSubstreams = numUnpackStreamsInFolders[i];
                    if (numSubstreams == 0)
+                    {
                        continue;
+                    }
 #if DEBUG
                    Log.Write("#{0} StreamSizes:", i);
 #endif
@@ -602,7 +652,9 @@ namespace SharpCompress.Common.SevenZip
 #endif
                }
                if (type == BlockType.Size)
+                {
                    type = ReadId();
+                }

                int numDigests = 0;
                int numDigestsTotal = 0;
@@ -610,13 +662,15 @@ namespace SharpCompress.Common.SevenZip
                {
                    int numSubstreams = numUnpackStreamsInFolders[i];
                    if (numSubstreams != 1 || !folders[i].UnpackCRCDefined)
+                    {
                        numDigests += numSubstreams;
+                    }
                    numDigestsTotal += numSubstreams;
                }

                digests = null;

-                for (; ; )
+                for (;;)
                {
                    if (type == BlockType.CRC)
                    {
@@ -636,12 +690,16 @@ namespace SharpCompress.Common.SevenZip
                            else
                            {
                                for (int j = 0; j < numSubstreams; j++, digestIndex++)
+                                {
                                    digests.Add(digests2[digestIndex]);
+                                }
                            }
                        }

                        if (digestIndex != numDigests || numDigestsTotal != digests.Count)
-                            System.Diagnostics.Debugger.Break();
+                        {
+                            Debugger.Break();
+                        }
                    }
                    else if (type == BlockType.End)
                    {
@@ -649,7 +707,9 @@ namespace SharpCompress.Common.SevenZip
                        {
                            digests = new List<uint?>(numDigestsTotal);
                            for (int i = 0; i < numDigestsTotal; i++)
+                            {
                                digests.Add(null);
+                            }
                        }
                        return;
                    }
@@ -693,7 +753,7 @@ namespace SharpCompress.Common.SevenZip
                unpackSizes = null;
                digests = null;

-                for (; ; )
+                for (;;)
                {
                    switch (ReadId())
                    {
@@ -768,12 +828,18 @@ namespace SharpCompress.Common.SevenZip
                    byte[] data = new byte[unpackSize];
                    outStream.ReadExact(data, 0, data.Length);
                    if (outStream.ReadByte() >= 0)
+                    {
                        throw new InvalidOperationException("Decoded stream is longer than expected.");
+                    }
                    dataVector.Add(data);

                    if (folder.UnpackCRCDefined)
+                    {
                        if (CRC.Finish(CRC.Update(CRC.kInitCRC, data, 0, unpackSize)) != folder.UnpackCRC)
+                        {
                            throw new InvalidOperationException("Decoded stream does not match expected CRC.");
+                        }
+                    }
                }
                return dataVector;
            }
@@ -842,10 +908,14 @@ namespace SharpCompress.Common.SevenZip
                db.Files.Clear();

                if (type == BlockType.End)
+                {
                    return;
+                }

                if (type != BlockType.FilesInfo)
+                {
                    throw new InvalidOperationException();
+                }

                int numFiles = ReadNum();
 #if DEBUG
@@ -853,18 +923,22 @@ namespace SharpCompress.Common.SevenZip
 #endif
                db.Files = new List<CFileItem>(numFiles);
                for (int i = 0; i < numFiles; i++)
+                {
                    db.Files.Add(new CFileItem());
+                }

                BitVector emptyStreamVector = new BitVector(numFiles);
                BitVector emptyFileVector = null;
                BitVector antiFileVector = null;
                int numEmptyStreams = 0;

-                for (; ; )
+                for (;;)
                {
                    type = ReadId();
                    if (type == BlockType.End)
+                    {
                        break;
+                    }

                    long size = checked((long)ReadNumber()); // TODO: throw invalid data on negative
                    int oldPos = _currentReader.Offset;
@@ -894,12 +968,34 @@ namespace SharpCompress.Common.SevenZip
                            Log.Write("WinAttributes:");
 #endif
                            ReadAttributeVector(dataVector, numFiles, delegate(int i, uint? attr)
+                                                                      {
+                                                                          // Some third party implementations established an unofficial extension
+                                                                          // of the 7z archive format by placing posix file attributes in the high
+                                                                          // bits of the windows file attributes. This makes use of the fact that
+                                                                          // the official implementation does not perform checks on this value.
+                                                                          //
+                                                                          // Newer versions of the official 7z GUI client will try to parse this
+                                                                          // extension, thus acknowledging the unofficial use of these bits.
+                                                                          //
+                                                                          // For us it is safe to just discard the upper bits if they are set and
+                                                                          // keep the windows attributes from the lower bits (which should be set
+                                                                          // properly even if posix file attributes are present, in order to be
+                                                                          // compatible with older 7z archive readers)
+                                                                          //
+                                                                          // Note that the 15th bit is used by some implementations to indicate
+                                                                          // presence of the extension, but not all implementations do that so
+                                                                          // we can't trust that bit and must ignore it.
+                                                                          //
+                                                                          if (attr.HasValue && (attr.Value >> 16) != 0)
                                                                          {
-                                                                              db.Files[i].Attrib = attr;
+                                                                              attr = attr.Value & 0x7FFFu;
+                                                                          }
+
+                                                                          db.Files[i].Attrib = attr;
 #if DEBUG
-                                                                              Log.Write("  " + (attr.HasValue ? attr.Value.ToString("x8") : "n/a"));
+                                                                          Log.Write("  " + (attr.HasValue ? attr.Value.ToString("x8") : "n/a"));
 #endif
-                                                                          });
+                                                                      });
 #if DEBUG
                            Log.WriteLine();
 #endif
@@ -938,7 +1034,9 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                            Log.Write("EmptyFile: ");
                            for (int i = 0; i < numEmptyStreams; i++)
+                            {
                                Log.Write(emptyFileVector[i] ? "x" : ".");
+                            }
                            Log.WriteLine();
 #endif
                            break;
@@ -947,7 +1045,9 @@ namespace SharpCompress.Common.SevenZip
 #if DEBUG
                            Log.Write("Anti: ");
                            for (int i = 0; i < numEmptyStreams; i++)
+                            {
                                Log.Write(antiFileVector[i] ? "x" : ".");
+                            }
                            Log.WriteLine();
 #endif
                            break;
@@ -956,12 +1056,12 @@ namespace SharpCompress.Common.SevenZip
                            Log.Write("StartPos:");
 #endif
                            ReadNumberVector(dataVector, numFiles, delegate(int i, long? startPos)
-                                                                       {
-                                                                           db.Files[i].StartPos = startPos;
+                                                                   {
+                                                                       db.Files[i].StartPos = startPos;
 #if DEBUG
-                                                                           Log.Write("  " + (startPos.HasValue ? startPos.Value.ToString() : "n/a"));
+                                                                       Log.Write("  " + (startPos.HasValue ? startPos.Value.ToString() : "n/a"));
 #endif
-                                                                       });
+                                                                   });
 #if DEBUG
                            Log.WriteLine();
 #endif
@@ -971,12 +1071,12 @@ namespace SharpCompress.Common.SevenZip
                            Log.Write("CTime:");
 #endif
                            ReadDateTimeVector(dataVector, numFiles, delegate(int i, DateTime? time)
-                                                                         {
-                                                                             db.Files[i].CTime = time;
+                                                                     {
+                                                                         db.Files[i].CTime = time;
 #if DEBUG
-                                                                             Log.Write("  " + (time.HasValue ? time.Value.ToString() : "n/a"));
+                                                                         Log.Write("  " + (time.HasValue ? time.Value.ToString() : "n/a"));
 #endif
-                                                                         });
+                                                                     });
 #if DEBUG
                            Log.WriteLine();
 #endif
@@ -986,12 +1086,12 @@ namespace SharpCompress.Common.SevenZip
                            Log.Write("ATime:");
 #endif
                            ReadDateTimeVector(dataVector, numFiles, delegate(int i, DateTime? time)
-                                                                         {
-                                                                             db.Files[i].ATime = time;
+                                                                     {
+                                                                         db.Files[i].ATime = time;
 #if DEBUG
-                                                                             Log.Write("  " + (time.HasValue ? time.Value.ToString() : "n/a"));
+                                                                         Log.Write("  " + (time.HasValue ? time.Value.ToString() : "n/a"));
 #endif
-                                                                         });
+                                                                     });
 #if DEBUG
                            Log.WriteLine();
 #endif
@@ -1001,12 +1101,12 @@ namespace SharpCompress.Common.SevenZip
                            Log.Write("MTime:");
 #endif
                            ReadDateTimeVector(dataVector, numFiles, delegate(int i, DateTime? time)
-                                                                         {
-                                                                             db.Files[i].MTime = time;
+                                                                     {
+                                                                         db.Files[i].MTime = time;
 #if DEBUG
-                                                                             Log.Write("  " + (time.HasValue ? time.Value.ToString() : "n/a"));
+                                                                         Log.Write("  " + (time.HasValue ? time.Value.ToString() : "n/a"));
 #endif
-                                                                         });
+                                                                     });
 #if DEBUG
                            Log.WriteLine();
 #endif
@@ -1016,8 +1116,12 @@ namespace SharpCompress.Common.SevenZip
                            Log.Write("Dummy: " + size);
 #endif
                            for (long j = 0; j < size; j++)
+                            {
                                if (ReadByte() != 0)
+                                {
                                    throw new InvalidOperationException();
+                                }
+                            }
                            break;
                        default:
                            SkipData(size);
@@ -1027,7 +1131,9 @@ namespace SharpCompress.Common.SevenZip
                    // since 0.3 record sizes must be correct
                    bool checkRecordsSize = (db.MajorVersion > 0 || db.MinorVersion > 2);
                    if (checkRecordsSize && _currentReader.Offset - oldPos != size)
+                    {
                        throw new InvalidOperationException();
+                    }
                }

                int emptyFileIndex = 0;
@@ -1075,11 +1181,13 @@ namespace SharpCompress.Common.SevenZip

            // TODO: Check Signature!
            _header = new byte[0x20];
-            for (int offset = 0; offset < 0x20; )
+            for (int offset = 0; offset < 0x20;)
            {
                int delta = stream.Read(_header, offset, 0x20 - offset);
                if (delta == 0)
+                {
                    throw new EndOfStreamException();
+                }
                offset += delta;
            }

@@ -1089,10 +1197,14 @@ namespace SharpCompress.Common.SevenZip
        public void Close()
        {
            if (_stream != null)
+            {
                _stream.Dispose();
+            }

            foreach (var stream in _cachedStreams.Values)
+            {
                stream.Dispose();
+            }

            _cachedStreams.Clear();
        }
@@ -1106,7 +1218,9 @@ namespace SharpCompress.Common.SevenZip
            db.MinorVersion = _header[7];

            if (db.MajorVersion != 0)
+            {
                throw new InvalidOperationException();
+            }

            uint crcFromArchive = DataReader.Get32(_header, 8);
            long nextHeaderOffset = (long)DataReader.Get64(_header, 0xC);
@@ -1120,7 +1234,9 @@ namespace SharpCompress.Common.SevenZip
            crc = CRC.Finish(crc);

            if (crc != crcFromArchive)
+            {
                throw new InvalidOperationException();
+            }

            db.StartPositionAfterHeader = _streamOrigin + 0x20;

@@ -1131,12 +1247,15 @@ namespace SharpCompress.Common.SevenZip
                return db;
            }

-
            if (nextHeaderOffset < 0 || nextHeaderSize < 0 || nextHeaderSize > Int32.MaxValue)
+            {
                throw new InvalidOperationException();
+            }

            if (nextHeaderOffset > _streamEnding - db.StartPositionAfterHeader)
+            {
                throw new IndexOutOfRangeException();
+            }

            _stream.Seek(nextHeaderOffset, SeekOrigin.Current);

@@ -1144,7 +1263,9 @@ namespace SharpCompress.Common.SevenZip
            _stream.ReadExact(header, 0, header.Length);

            if (CRC.Finish(CRC.Update(CRC.kInitCRC, header, 0, header.Length)) != nextHeaderCrc)
+            {
                throw new InvalidOperationException();
+            }

            using (CStreamSwitch streamSwitch = new CStreamSwitch())
            {
@@ -1154,7 +1275,9 @@ namespace SharpCompress.Common.SevenZip
                if (type != BlockType.Header)
                {
                    if (type != BlockType.EncodedHeader)
+                    {
                        throw new InvalidOperationException();
+                    }

                    var dataVector = ReadAndDecodePackedStreams(db.StartPositionAfterHeader, pass);

@@ -1166,12 +1289,16 @@ namespace SharpCompress.Common.SevenZip
                    }

                    if (dataVector.Count != 1)
+                    {
                        throw new InvalidOperationException();
+                    }

                    streamSwitch.Set(this, dataVector[0]);

                    if (ReadId() != BlockType.Header)
+                    {
                        throw new InvalidOperationException();
+                    }
                }

                ReadHeader(db, pass);
@@ -1191,55 +1318,41 @@ namespace SharpCompress.Common.SevenZip
                FileIndex = fileIndex;
                FolderIndex = folderIndex;
                if (fileIndex != -1)
+                {
                    ExtractStatuses.Add(true);
+                }
            }
        }

        private class FolderUnpackStream : Stream
        {
-            private ArchiveDatabase _db;
-            private int _startIndex;
-            private List<bool> _extractStatuses;
+            private readonly ArchiveDatabase _db;
+            private readonly int _startIndex;
+            private readonly List<bool> _extractStatuses;

            public FolderUnpackStream(ArchiveDatabase db, int p, int startIndex, List<bool> list)
            {
-                this._db = db;
-                this._startIndex = startIndex;
-                this._extractStatuses = list;
+                _db = db;
+                _startIndex = startIndex;
+                _extractStatuses = list;
            }

            #region Stream

-            public override bool CanRead
-            {
-                get { return true; }
-            }
+            public override bool CanRead => true;

-            public override bool CanSeek
-            {
-                get { return false; }
-            }
+            public override bool CanSeek => false;

-            public override bool CanWrite
-            {
-                get { return false; }
-            }
+            public override bool CanWrite => false;

            public override void Flush()
            {
                throw new NotSupportedException();
            }

-            public override long Length
-            {
-                get { throw new NotSupportedException(); }
-            }
+            public override long Length => throw new NotSupportedException();

-            public override long Position
-            {
-                get { throw new NotSupportedException(); }
-                set { throw new NotSupportedException(); }
-            }
+            public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }

            public override int Read(byte[] buffer, int offset, int count)
            {
@@ -1278,9 +1391,13 @@ namespace SharpCompress.Common.SevenZip
                Log.WriteLine(_db.Files[index].Name);
 #endif
                if (_db.Files[index].CrcDefined)
+                {
                    _stream = new CrcCheckStream(_db.Files[index].Crc.Value);
+                }
                else
+                {
                    _stream = new MemoryStream();
+                }
                _rem = _db.Files[index].Size;
            }

@@ -1292,7 +1409,9 @@ namespace SharpCompress.Common.SevenZip
                    {
                        int write = count;
                        if (write > _rem)
+                        {
                            write = (int)_rem;
+                        }
                        _stream.Write(buffer, offset, write);
                        count -= write;
                        _rem -= write;
@@ -1311,7 +1430,7 @@ namespace SharpCompress.Common.SevenZip
                        if (_currentIndex == _extractStatuses.Count)
                        {
                            // we support partial extracting
-                            System.Diagnostics.Debugger.Break();
+                            Debugger.Break();
                            throw new NotSupportedException();
                        }
                        OpenFile();
@@ -1332,7 +1451,9 @@ namespace SharpCompress.Common.SevenZip
                long folderStartPackPos = _db.GetFolderStreamPos(folderInfo, 0);
                List<long> packSizes = new List<long>();
                for (int j = 0; j < folderInfo.PackStreams.Count; j++)
+                {
                    packSizes.Add(_db.PackSizes[packStreamIndex + j]);
+                }

                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
                                                            pw);
@@ -1347,12 +1468,16 @@ namespace SharpCompress.Common.SevenZip
            int numFilesInFolder = _db.NumUnpackStreamsVector[folderIndex];
            int firstFileIndex = _db.FolderStartFileIndex[folderIndex];
            if (firstFileIndex > fileIndex || fileIndex - firstFileIndex >= numFilesInFolder)
+            {
                throw new InvalidOperationException();
+            }

            int skipCount = fileIndex - firstFileIndex;
            long skipSize = 0;
            for (int i = 0; i < skipCount; i++)
+            {
                skipSize += _db.Files[firstFileIndex + i].Size;
+            }

            Stream s = GetCachedDecoderStream(_db, folderIndex, pw);
            s.Position = skipSize;
@@ -1364,12 +1489,18 @@ namespace SharpCompress.Common.SevenZip
            int numItems;
            bool allFilesMode = (indices == null);
            if (allFilesMode)
+            {
                numItems = _db.Files.Count;
+            }
            else
+            {
                numItems = indices.Length;
+            }

            if (numItems == 0)
+            {
                return;
+            }

            List<CExtractFolderInfo> extractFolderInfoVector = new List<CExtractFolderInfo>();
            for (int i = 0; i < numItems; i++)
@@ -1384,27 +1515,37 @@ namespace SharpCompress.Common.SevenZip
                }

                if (extractFolderInfoVector.Count == 0 || folderIndex != extractFolderInfoVector.Last().FolderIndex)
+                {
                    extractFolderInfoVector.Add(new CExtractFolderInfo(-1, folderIndex));
+                }

                CExtractFolderInfo efi = extractFolderInfoVector.Last();

                int startIndex = _db.FolderStartFileIndex[folderIndex];
                for (int index = efi.ExtractStatuses.Count; index <= fileIndex - startIndex; index++)
+                {
                    efi.ExtractStatuses.Add(index == fileIndex - startIndex);
+                }
            }

            foreach (CExtractFolderInfo efi in extractFolderInfoVector)
            {
                int startIndex;
                if (efi.FileIndex != -1)
+                {
                    startIndex = efi.FileIndex;
+                }
                else
+                {
                    startIndex = _db.FolderStartFileIndex[efi.FolderIndex];
+                }

                var outStream = new FolderUnpackStream(_db, 0, startIndex, efi.ExtractStatuses);

                if (efi.FileIndex != -1)
+                {
                    continue;
+                }

                int folderIndex = efi.FolderIndex;
                CFolder folderInfo = _db.Folders[folderIndex];
@@ -1414,18 +1555,22 @@ namespace SharpCompress.Common.SevenZip

                List<long> packSizes = new List<long>();
                for (int j = 0; j < folderInfo.PackStreams.Count; j++)
+                {
                    packSizes.Add(_db.PackSizes[packStreamIndex + j]);
+                }

                // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?

                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
                                                                   folderInfo, pw);
                byte[] buffer = new byte[4 << 10];
-                for (; ; )
+                for (;;)
                {
                    int processed = s.Read(buffer, 0, buffer.Length);
                    if (processed == 0)
+                    {
                        break;
+                    }
                    outStream.Write(buffer, 0, processed);
                }
            }
--- a/src/SharpCompress/Common/SevenZip/CFileItem.cs
+++ b/src/SharpCompress/Common/SevenZip/CFileItem.cs
@@ -12,19 +12,13 @@ namespace SharpCompress.Common.SevenZip
        public bool HasStream { get; internal set; }
        public bool IsDir { get; internal set; }

-        public bool CrcDefined
-        {
-            get { return Crc != null; }
-        }
+        public bool CrcDefined => Crc != null;

-        public bool AttribDefined
-        {
-            get { return Attrib != null; }
-        }
+        public bool AttribDefined => Attrib != null;

        public void SetAttrib(uint attrib)
        {
-            this.Attrib = attrib;
+            Attrib = attrib;
        }

        public DateTime? CTime { get; internal set; }
--- a/src/SharpCompress/Common/SevenZip/CFolder.cs
+++ b/src/SharpCompress/Common/SevenZip/CFolder.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using SharpCompress.Compressor.LZMA;
+using SharpCompress.Compressors.LZMA;

 namespace SharpCompress.Common.SevenZip
 {
@@ -13,19 +13,22 @@ namespace SharpCompress.Common.SevenZip
        internal List<long> UnpackSizes = new List<long>();
        internal uint? UnpackCRC;

-        internal bool UnpackCRCDefined
-        {
-            get { return UnpackCRC != null; }
-        }
+        internal bool UnpackCRCDefined => UnpackCRC != null;

        public long GetUnpackSize()
        {
            if (UnpackSizes.Count == 0)
+            {
                return 0;
+            }

            for (int i = UnpackSizes.Count - 1; i >= 0; i--)
+            {
                if (FindBindPairForOutStream(i) < 0)
+                {
                    return UnpackSizes[i];
+                }
+            }

            throw new Exception();
        }
@@ -34,7 +37,9 @@ namespace SharpCompress.Common.SevenZip
        {
            int count = 0;
            for (int i = 0; i < Coders.Count; i++)
+            {
                count += Coders[i].NumOutStreams;
+            }

            return count;
        }
@@ -42,8 +47,12 @@ namespace SharpCompress.Common.SevenZip
        public int FindBindPairForInStream(int inStreamIndex)
        {
            for (int i = 0; i < BindPairs.Count; i++)
+            {
                if (BindPairs[i].InIndex == inStreamIndex)
+                {
                    return i;
+                }
+            }

            return -1;
        }
@@ -51,8 +60,12 @@ namespace SharpCompress.Common.SevenZip
        public int FindBindPairForOutStream(int outStreamIndex)
        {
            for (int i = 0; i < BindPairs.Count; i++)
+            {
                if (BindPairs[i].OutIndex == outStreamIndex)
+                {
                    return i;
+                }
+            }

            return -1;
        }
@@ -60,8 +73,12 @@ namespace SharpCompress.Common.SevenZip
        public int FindPackStreamArrayIndex(int inStreamIndex)
        {
            for (int i = 0; i < PackStreams.Count; i++)
+            {
                if (PackStreams[i] == inStreamIndex)
+                {
                    return i;
+                }
+            }

            return -1;
        }
@@ -69,8 +86,12 @@ namespace SharpCompress.Common.SevenZip
        public bool IsEncrypted()
        {
            for (int i = Coders.Count - 1; i >= 0; i--)
+            {
                if (Coders[i].MethodId == CMethodId.kAES)
+                {
                    return true;
+                }
+            }

            return false;
        }
@@ -82,25 +103,39 @@ namespace SharpCompress.Common.SevenZip
            const int kNumBindsMax = 32;

            if (Coders.Count > kNumCodersMax || BindPairs.Count > kNumBindsMax)
+            {
                return false;
+            }

            {
                var v = new BitVector(BindPairs.Count + PackStreams.Count);

                for (int i = 0; i < BindPairs.Count; i++)
+                {
                    if (v.GetAndSet(BindPairs[i].InIndex))
+                    {
                        return false;
+                    }
+                }

                for (int i = 0; i < PackStreams.Count; i++)
+                {
                    if (v.GetAndSet(PackStreams[i]))
+                    {
                        return false;
+                    }
+                }
            }

            {
                var v = new BitVector(UnpackSizes.Count);
                for (int i = 0; i < BindPairs.Count; i++)
+                {
                    if (v.GetAndSet(BindPairs[i].OutIndex))
+                    {
                        return false;
+                    }
+                }
            }

            uint[] mask = new uint[kMaskSize];
@@ -112,9 +147,13 @@ namespace SharpCompress.Common.SevenZip
                {
                    CCoderInfo coder = Coders[i];
                    for (int j = 0; j < coder.NumInStreams; j++)
+                    {
                        inStreamToCoder.Add(i);
+                    }
                    for (int j = 0; j < coder.NumOutStreams; j++)
+                    {
                        outStreamToCoder.Add(i);
+                    }
                }

                for (int i = 0; i < BindPairs.Count; i++)
@@ -125,13 +164,23 @@ namespace SharpCompress.Common.SevenZip
            }

            for (int i = 0; i < kMaskSize; i++)
+            {
                for (int j = 0; j < kMaskSize; j++)
+                {
                    if (((1u << j) & mask[i]) != 0)
+                    {
                        mask[i] |= mask[j];
+                    }
+                }
+            }

            for (int i = 0; i < kMaskSize; i++)
+            {
                if (((1u << i) & mask[i]) != 0)
+                {
                    return false;
+                }
+            }

            return true;
        }
--- a/src/SharpCompress/Common/SevenZip/CMethodId.cs
+++ b/src/SharpCompress/Common/SevenZip/CMethodId.cs
@@ -16,7 +16,7 @@

        public CMethodId(ulong id)
        {
-            this.Id = id;
+            Id = id;
        }

        public override int GetHashCode()
@@ -26,7 +26,7 @@

        public override bool Equals(object obj)
        {
-            return obj is CMethodId && (CMethodId) obj == this;
+            return obj is CMethodId && (CMethodId)obj == this;
        }

        public bool Equals(CMethodId other)
@@ -48,7 +48,9 @@
        {
            int bytes = 0;
            for (ulong value = Id; value != 0; value >>= 8)
+            {
                bytes++;
+            }
            return bytes;
        }
    }
--- a/src/SharpCompress/Common/SevenZip/CStreamSwitch.cs
+++ b/src/SharpCompress/Common/SevenZip/CStreamSwitch.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
-using SharpCompress.Compressor.LZMA;
+using SharpCompress.Compressors.LZMA;

 namespace SharpCompress.Common.SevenZip
 {
@@ -47,7 +46,9 @@ namespace SharpCompress.Common.SevenZip
            {
                int dataIndex = archive.ReadNum();
                if (dataIndex < 0 || dataIndex >= dataVector.Count)
+                {
                    throw new InvalidOperationException();
+                }

 #if DEBUG
                Log.WriteLine("[switch to stream {0}]", dataIndex);
--- a/src/SharpCompress/Common/SevenZip/DataReader.cs
+++ b/src/SharpCompress/Common/SevenZip/DataReader.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using System.Text;
-using SharpCompress.Compressor.LZMA;
+using SharpCompress.Compressors.LZMA;

 namespace SharpCompress.Common.SevenZip
 {
@@ -11,31 +11,30 @@ namespace SharpCompress.Common.SevenZip

        public static uint Get32(byte[] buffer, int offset)
        {
-            return (uint) buffer[offset]
-                   + ((uint) buffer[offset + 1] << 8)
-                   + ((uint) buffer[offset + 2] << 16)
-                   + ((uint) buffer[offset + 3] << 24);
+            return buffer[offset]
+                   + ((uint)buffer[offset + 1] << 8)
+                   + ((uint)buffer[offset + 2] << 16)
+                   + ((uint)buffer[offset + 3] << 24);
        }

        public static ulong Get64(byte[] buffer, int offset)
        {
-            return (ulong) buffer[offset]
-                   + ((ulong) buffer[offset + 1] << 8)
-                   + ((ulong) buffer[offset + 2] << 16)
-                   + ((ulong) buffer[offset + 3] << 24)
-                   + ((ulong) buffer[offset + 4] << 32)
-                   + ((ulong) buffer[offset + 5] << 40)
-                   + ((ulong) buffer[offset + 6] << 48)
-                   + ((ulong) buffer[offset + 7] << 56);
+            return buffer[offset]
+                   + ((ulong)buffer[offset + 1] << 8)
+                   + ((ulong)buffer[offset + 2] << 16)
+                   + ((ulong)buffer[offset + 3] << 24)
+                   + ((ulong)buffer[offset + 4] << 32)
+                   + ((ulong)buffer[offset + 5] << 40)
+                   + ((ulong)buffer[offset + 6] << 48)
+                   + ((ulong)buffer[offset + 7] << 56);
        }

        #endregion

        #region Variables

-        private byte[] _buffer;
-        private int _offset;
-        private int _ending;
+        private readonly byte[] _buffer;
+        private readonly int _ending;

        #endregion

@@ -44,38 +43,43 @@ namespace SharpCompress.Common.SevenZip
        public DataReader(byte[] buffer, int offset, int length)
        {
            _buffer = buffer;
-            _offset = offset;
+            Offset = offset;
            _ending = offset + length;
        }

-        public int Offset
-        {
-            get { return _offset; }
-        }
+        public int Offset { get; private set; }

        public Byte ReadByte()
        {
-            if (_offset >= _ending)
+            if (Offset >= _ending)
+            {
                throw new EndOfStreamException();
+            }

-            return _buffer[_offset++];
+            return _buffer[Offset++];
        }

        public void ReadBytes(byte[] buffer, int offset, int length)
        {
-            if (length > _ending - _offset)
+            if (length > _ending - Offset)
+            {
                throw new EndOfStreamException();
+            }

            while (length-- > 0)
-                buffer[offset++] = _buffer[_offset++];
+            {
+                buffer[offset++] = _buffer[Offset++];
+            }
        }

        public void SkipData(long size)
        {
-            if (size > _ending - _offset)
+            if (size > _ending - Offset)
+            {
                throw new EndOfStreamException();
+            }

-            _offset += (int) size;
+            Offset += (int)size;
 #if DEBUG
            Log.WriteLine("SkipData {0}", size);
 #endif
@@ -83,15 +87,17 @@ namespace SharpCompress.Common.SevenZip

        public void SkipData()
        {
-            SkipData(checked((long) ReadNumber()));
+            SkipData(checked((long)ReadNumber()));
        }

        public ulong ReadNumber()
        {
-            if (_offset >= _ending)
+            if (Offset >= _ending)
+            {
                throw new EndOfStreamException();
+            }

-            byte firstByte = _buffer[_offset++];
+            byte firstByte = _buffer[Offset++];
            byte mask = 0x80;
            ulong value = 0;

@@ -100,14 +106,16 @@ namespace SharpCompress.Common.SevenZip
                if ((firstByte & mask) == 0)
                {
                    ulong highPart = firstByte & (mask - 1u);
-                    value += highPart << (i*8);
+                    value += highPart << (i * 8);
                    return value;
                }

-                if (_offset >= _ending)
+                if (Offset >= _ending)
+                {
                    throw new EndOfStreamException();
+                }

-                value |= (ulong) _buffer[_offset++] << (8*i);
+                value |= (ulong)_buffer[Offset++] << (8 * i);
                mask >>= 1;
            }

@@ -118,48 +126,58 @@ namespace SharpCompress.Common.SevenZip
        {
            ulong value = ReadNumber();
            if (value > Int32.MaxValue)
+            {
                throw new NotSupportedException();
+            }

-            return (int) value;
+            return (int)value;
        }

        public uint ReadUInt32()
        {
-            if (_offset + 4 > _ending)
+            if (Offset + 4 > _ending)
+            {
                throw new EndOfStreamException();
+            }

-            uint res = Get32(_buffer, _offset);
-            _offset += 4;
+            uint res = Get32(_buffer, Offset);
+            Offset += 4;
            return res;
        }

        public ulong ReadUInt64()
        {
-            if (_offset + 8 > _ending)
+            if (Offset + 8 > _ending)
+            {
                throw new EndOfStreamException();
+            }

-            ulong res = Get64(_buffer, _offset);
-            _offset += 8;
+            ulong res = Get64(_buffer, Offset);
+            Offset += 8;
            return res;
        }

        public string ReadString()
        {
-            int ending = _offset;
+            int ending = Offset;

            for (;;)
            {
                if (ending + 2 > _ending)
+                {
                    throw new EndOfStreamException();
+                }

                if (_buffer[ending] == 0 && _buffer[ending + 1] == 0)
+                {
                    break;
+                }

                ending += 2;
            }

-            string str = Encoding.Unicode.GetString(_buffer, _offset, ending - _offset);
-            _offset = ending + 2;
+            string str = Encoding.Unicode.GetString(_buffer, Offset, ending - Offset);
+            Offset = ending + 2;
            return str;
        }

--- a/src/SharpCompress/Common/SevenZip/SevenZipEntry.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipEntry.cs
@@ -7,79 +7,37 @@ namespace SharpCompress.Common.SevenZip
    {
        internal SevenZipEntry(SevenZipFilePart filePart)
        {
-            this.FilePart = filePart;
+            FilePart = filePart;
        }

-        internal SevenZipFilePart FilePart { get; private set; }
+        internal SevenZipFilePart FilePart { get; }

-        public override CompressionType CompressionType
-        {
-            get { return FilePart.CompressionType; }
-        }
+        public override CompressionType CompressionType => FilePart.CompressionType;

-        public override long Crc
-        {
-            get { return FilePart.Header.Crc ?? 0; }
-        }
+        public override long Crc => FilePart.Header.Crc ?? 0;

-        public override string Key
-        {
-            get { return FilePart.Header.Name; }
-        }
+        public override string Key => FilePart.Header.Name;

-        public override long CompressedSize
-        {
-            get { return 0; }
-        }
+        public override long CompressedSize => 0;

-        public override long Size
-        {
-            get { return (long) FilePart.Header.Size; }
-        }
+        public override long Size => FilePart.Header.Size;

-        public override DateTime? LastModifiedTime
-        {
-            get { return FilePart.Header.MTime; }
-        }
+        public override DateTime? LastModifiedTime => FilePart.Header.MTime;

-        public override DateTime? CreatedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? CreatedTime => null;

-        public override DateTime? LastAccessedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? LastAccessedTime => null;

-        public override DateTime? ArchivedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? ArchivedTime => null;

-        public override bool IsEncrypted
-        {
-            get { return false; }
-        }
+        public override bool IsEncrypted => false;

-        public override bool IsDirectory
-        {
-            get { return FilePart.Header.IsDir; }
-        }
+        public override bool IsDirectory => FilePart.Header.IsDir;

-        public override bool IsSplit
-        {
-            get { return false; }
-        }
+        public override bool IsSplit => false;

-        public override int? Attrib
-        {
-            get { return (int) FilePart.Header.Attrib; }
-        }
+        public override int? Attrib => (int)FilePart.Header.Attrib;

-        internal override IEnumerable<FilePart> Parts
-        {
-            get { return FilePart.AsEnumerable<FilePart>(); }
-        }
+        internal override IEnumerable<FilePart> Parts => FilePart.AsEnumerable<FilePart>();
    }
 }
--- a/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipFilePart.cs
@@ -8,8 +8,8 @@ namespace SharpCompress.Common.SevenZip
    internal class SevenZipFilePart : FilePart
    {
        private CompressionType? type;
-        private Stream stream;
-        private ArchiveDatabase database;
+        private readonly Stream stream;
+        private readonly ArchiveDatabase database;

        internal SevenZipFilePart(Stream stream, ArchiveDatabase database, int index, CFileItem fileEntry)
        {
@@ -24,14 +24,11 @@ namespace SharpCompress.Common.SevenZip
        }

        internal Stream BaseStream { get; private set; }
-        internal CFileItem Header { get; private set; }
-        internal CFolder Folder { get; private set; }
-        internal int Index { get; private set; }
+        internal CFileItem Header { get; }
+        internal CFolder Folder { get; }
+        internal int Index { get; }

-        internal override string FilePartName
-        {
-            get { return Header.Name; }
-        }
+        internal override string FilePartName => Header.Name;

        internal override Stream GetRawStream()
        {
@@ -90,17 +87,17 @@ namespace SharpCompress.Common.SevenZip
            {
                case k_LZMA:
                case k_LZMA2:
-                    {
-                        return CompressionType.LZMA;
-                    }
+                {
+                    return CompressionType.LZMA;
+                }
                case k_PPMD:
-                    {
-                        return CompressionType.PPMd;
-                    }
+                {
+                    return CompressionType.PPMd;
+                }
                case k_BZip2:
-                    {
-                        return CompressionType.BZip2;
-                    }
+                {
+                    return CompressionType.BZip2;
+                }
                default:
                    throw new NotImplementedException();
            }
--- a/src/SharpCompress/Common/SevenZip/SevenZipVolume.cs
+++ b/src/SharpCompress/Common/SevenZip/SevenZipVolume.cs
@@ -1,11 +1,13 @@
 using System.IO;
+using SharpCompress.Archives;
+using SharpCompress.Readers;

 namespace SharpCompress.Common.SevenZip
 {
    public class SevenZipVolume : Volume
    {
-        public SevenZipVolume(Stream stream, Options options)
-            : base(stream, options)
+        public SevenZipVolume(Stream stream, ReaderOptions readerFactoryOptions)
+            : base(stream, readerFactoryOptions)
        {
        }
    }
--- a/src/SharpCompress/Common/Tar/Headers/EntryType.cs
+++ b/src/SharpCompress/Common/Tar/Headers/EntryType.cs
@@ -3,17 +3,17 @@
    internal enum EntryType : byte
    {
        File = 0,
-        OldFile = (byte) '0',
-        HardLink = (byte) '1',
-        SymLink = (byte) '2',
-        CharDevice = (byte) '3',
-        BlockDevice = (byte) '4',
-        Directory = (byte) '5',
-        Fifo = (byte) '6',
-        LongLink = (byte) 'K',
-        LongName = (byte) 'L',
-        SparseFile = (byte) 'S',
-        VolumeHeader = (byte) 'V',
-        GlobalExtendedHeader = (byte) 'g',
+        OldFile = (byte)'0',
+        HardLink = (byte)'1',
+        SymLink = (byte)'2',
+        CharDevice = (byte)'3',
+        BlockDevice = (byte)'4',
+        Directory = (byte)'5',
+        Fifo = (byte)'6',
+        LongLink = (byte)'K',
+        LongName = (byte)'L',
+        SparseFile = (byte)'S',
+        VolumeHeader = (byte)'V',
+        GlobalExtendedHeader = (byte)'g'
    }
 }
--- a/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
+++ b/src/SharpCompress/Common/Tar/Headers/TarHeader.cs
@@ -1,7 +1,7 @@
 using System;
 using System.IO;
 using System.Text;
-using SharpCompress.Converter;
+using SharpCompress.Converters;

 namespace SharpCompress.Common.Tar.Headers
 {
@@ -10,6 +10,7 @@ namespace SharpCompress.Common.Tar.Headers
        internal static readonly DateTime Epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

        internal string Name { get; set; }
+
        //internal int Mode { get; set; }
        //internal int UserId { get; set; }
        //internal string UserName { get; set; }
@@ -77,7 +78,9 @@ namespace SharpCompress.Common.Tar.Headers
            // pad to multiple of BlockSize bytes, and make sure a terminating null is added
            int numPaddingBytes = BlockSize - (nameBytes.Length % BlockSize);
            if (numPaddingBytes == 0)
+            {
                numPaddingBytes = BlockSize;
+            }
            output.Write(new byte[numPaddingBytes], 0, numPaddingBytes);
        }

@@ -131,11 +134,15 @@ namespace SharpCompress.Common.Tar.Headers
        private string ReadLongName(BinaryReader reader, byte[] buffer)
        {
            var size = ReadSize(buffer);
-            var nameLength = (int) size;
+            var nameLength = (int)size;
            var nameBytes = reader.ReadBytes(nameLength);
-            var remainingBytesToRead = BlockSize - (nameLength%BlockSize);
+            var remainingBytesToRead = BlockSize - (nameLength % BlockSize);
+
            // Read the rest of the block and discard the data
-            if (remainingBytesToRead < BlockSize) reader.ReadBytes(remainingBytesToRead);
+            if (remainingBytesToRead < BlockSize)
+            {
+                reader.ReadBytes(remainingBytesToRead);
+            }
            return ArchiveEncoding.Default.GetString(nameBytes, 0, nameBytes.Length).TrimNulls();
        }

@@ -157,9 +164,9 @@ namespace SharpCompress.Common.Tar.Headers
        {
            byte[] buffer = reader.ReadBytes(BlockSize);

-            if (buffer.Length < BlockSize)
+            if (buffer.Length != 0 && buffer.Length < BlockSize)
            {
-                throw new InvalidOperationException();
+                throw new InvalidOperationException("Buffer is invalid size");
            }
            return buffer;
        }
--- a/src/SharpCompress/Common/Tar/TarEntry.cs
+++ b/src/SharpCompress/Common/Tar/TarEntry.cs
@@ -9,78 +9,38 @@ namespace SharpCompress.Common.Tar
    public class TarEntry : Entry
    {
        private readonly TarFilePart filePart;
-        private readonly CompressionType type;

        internal TarEntry(TarFilePart filePart, CompressionType type)
        {
            this.filePart = filePart;
-            this.type = type;
+            CompressionType = type;
        }

-        public override CompressionType CompressionType
-        {
-            get { return type; }
-        }
+        public override CompressionType CompressionType { get; }

-        public override long Crc
-        {
-            get { return 0; }
-        }
+        public override long Crc => 0;

-        public override string Key
-        {
-            get { return filePart.Header.Name; }
-        }
+        public override string Key => filePart.Header.Name;

-        public override long CompressedSize
-        {
-            get { return filePart.Header.Size; }
-        }
+        public override long CompressedSize => filePart.Header.Size;

-        public override long Size
-        {
-            get { return filePart.Header.Size; }
-        }
+        public override long Size => filePart.Header.Size;

-        public override DateTime? LastModifiedTime
-        {
-            get { return filePart.Header.LastModifiedTime; }
-        }
+        public override DateTime? LastModifiedTime => filePart.Header.LastModifiedTime;

-        public override DateTime? CreatedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? CreatedTime => null;

-        public override DateTime? LastAccessedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? LastAccessedTime => null;

-        public override DateTime? ArchivedTime
-        {
-            get { return null; }
-        }
+        public override DateTime? ArchivedTime => null;

-        public override bool IsEncrypted
-        {
-            get { return false; }
-        }
+        public override bool IsEncrypted => false;

-        public override bool IsDirectory
-        {
-            get { return filePart.Header.EntryType == EntryType.Directory; }
-        }
+        public override bool IsDirectory => filePart.Header.EntryType == EntryType.Directory;

-        public override bool IsSplit
-        {
-            get { return false; }
-        }
+        public override bool IsSplit => false;

-        internal override IEnumerable<FilePart> Parts
-        {
-            get { return filePart.AsEnumerable<FilePart>(); }
-        }
+        internal override IEnumerable<FilePart> Parts => filePart.AsEnumerable<FilePart>();

        internal static IEnumerable<TarEntry> GetEntries(StreamingMode mode, Stream stream,
                                                         CompressionType compressionType)
--- a/src/SharpCompress/Common/Tar/TarFilePart.cs
+++ b/src/SharpCompress/Common/Tar/TarFilePart.cs
@@ -14,12 +14,9 @@ namespace SharpCompress.Common.Tar
            Header = header;
        }

-        internal TarHeader Header { get; private set; }
+        internal TarHeader Header { get; }

-        internal override string FilePartName
-        {
-            get { return Header.Name; }
-        }
+        internal override string FilePartName => Header.Name;

        internal override Stream GetCompressedStream()
        {
--- a/src/SharpCompress/Common/Tar/TarHeaderFactory.cs
+++ b/src/SharpCompress/Common/Tar/TarHeaderFactory.cs
@@ -23,21 +23,22 @@ namespace SharpCompress.Common.Tar
                    switch (mode)
                    {
                        case StreamingMode.Seekable:
-                            {
-                                header.DataStartPosition = reader.BaseStream.Position;
-                                //skip to nearest 512
-                                reader.BaseStream.Position += PadTo512(header.Size);
-                            }
+                        {
+                            header.DataStartPosition = reader.BaseStream.Position;
+
+                            //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
@@ -50,7 +51,7 @@ namespace SharpCompress.Common.Tar

        private static long PadTo512(long size)
        {
-            int zeros = (int) (size%512);
+            int zeros = (int)(size % 512);
            if (zeros == 0)
            {
                return size;
--- a/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs
+++ b/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs
@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;

 namespace SharpCompress.Common.Tar
 {
@@ -39,38 +40,22 @@ namespace SharpCompress.Common.Tar

        private long BytesLeftToRead { get; set; }

-        public Stream Stream { get; private set; }
+        public Stream Stream { get; }

-        public override bool CanRead
-        {
-            get { return true; }
-        }
+        public override bool CanRead => true;

-        public override bool CanSeek
-        {
-            get { return false; }
-        }
+        public override bool CanSeek => false;

-        public override bool CanWrite
-        {
-            get { return false; }
-        }
+        public override bool CanWrite => false;

        public override void Flush()
        {
-            throw new System.NotSupportedException();
+            throw new NotSupportedException();
        }

-        public override long Length
-        {
-            get { throw new System.NotSupportedException(); }
-        }
+        public override long Length => throw new NotSupportedException();

-        public override long Position
-        {
-            get { throw new System.NotSupportedException(); }
-            set { throw new System.NotSupportedException(); }
-        }
+        public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }

        public override int Read(byte[] buffer, int offset, int count)
        {
@@ -89,17 +74,17 @@ namespace SharpCompress.Common.Tar

        public override long Seek(long offset, SeekOrigin origin)
        {
-            throw new System.NotSupportedException();
+            throw new NotSupportedException();
        }

        public override void SetLength(long value)
        {
-            throw new System.NotSupportedException();
+            throw new NotSupportedException();
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
-            throw new System.NotSupportedException();
+            throw new NotSupportedException();
        }
    }
 }
--- a/src/SharpCompress/Common/Tar/TarVolume.cs
+++ b/src/SharpCompress/Common/Tar/TarVolume.cs
@@ -1,11 +1,12 @@
 using System.IO;
+using SharpCompress.Readers;

 namespace SharpCompress.Common.Tar
 {
    public class TarVolume : Volume
    {
-        public TarVolume(Stream stream, Options options)
-            : base(stream, options)
+        public TarVolume(Stream stream, ReaderOptions readerOptions)
+            : base(stream, readerOptions)
        {
        }
    }
--- a/src/SharpCompress/Common/Volume.cs
+++ b/src/SharpCompress/Common/Volume.cs
@@ -1,5 +1,6 @@
 using System.IO;
 using SharpCompress.IO;
+using SharpCompress.Readers;

 namespace SharpCompress.Common
 {
@@ -7,41 +8,32 @@ namespace SharpCompress.Common
    {
        private readonly Stream actualStream;

-        internal Volume(Stream stream, Options options)
+        internal Volume(Stream stream, ReaderOptions readerOptions)
        {
            actualStream = stream;
-            Options = options;
+            ReaderOptions = readerOptions;
        }

-        internal Stream Stream
-        {
-            get { return new NonDisposingStream(actualStream); }
-        }
+        internal Stream Stream => new NonDisposingStream(actualStream);

-        internal Options Options { get; private set; }
+        protected ReaderOptions ReaderOptions { get; }

        /// <summary>
        /// RarArchive is the first volume of a multi-part archive.
        /// Only Rar 3.0 format and higher
        /// </summary>
-        public virtual bool IsFirstVolume
-        {
-            get { return true; }
-        }
+        public virtual bool IsFirstVolume => true;

        /// <summary>
        /// RarArchive is part of a multi-part archive.
        /// </summary>
-        public virtual bool IsMultiVolume
-        {
-            get { return true; }
-        }
+        public virtual bool IsMultiVolume => true;

        private bool disposed;

        public void Dispose()
        {
-            if (!Options.HasFlag(Options.KeepStreamsOpen) && !disposed)
+            if (!ReaderOptions.LeaveStreamOpen && !disposed)
            {
                actualStream.Dispose();
                disposed = true;
--- a/src/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/DirectoryEndHeader.cs
@@ -48,5 +48,9 @@ namespace SharpCompress.Common.Zip.Headers
        public byte[] Comment { get; private set; }

        public ushort TotalNumberOfEntries { get; private set; }
+
+        public bool IsZip64 => TotalNumberOfEntriesInDisk == ushort.MaxValue
+                               || DirectorySize == uint.MaxValue
+                               || DirectoryStartOffsetRelativeToDisk == uint.MaxValue;
    }
 }
--- a/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/DirectoryEntryHeader.cs
@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Linq;

 namespace SharpCompress.Common.Zip.Headers
@@ -14,8 +15,8 @@ namespace SharpCompress.Common.Zip.Headers
        {
            Version = reader.ReadUInt16();
            VersionNeededToExtract = reader.ReadUInt16();
-            Flags = (HeaderFlags) reader.ReadUInt16();
-            CompressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
+            Flags = (HeaderFlags)reader.ReadUInt16();
+            CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
            LastModifiedTime = reader.ReadUInt16();
            LastModifiedDate = reader.ReadUInt16();
            Crc = reader.ReadUInt32();
@@ -41,33 +42,72 @@ namespace SharpCompress.Common.Zip.Headers
            {
                Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
            }
+
+            var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
+            if (zip64ExtraData != null)
+            {
+                if (CompressedSize == uint.MaxValue)
+                {
+                    CompressedSize = zip64ExtraData.CompressedSize;
+                }
+                if (UncompressedSize == uint.MaxValue)
+                {
+                    UncompressedSize = zip64ExtraData.UncompressedSize;
+                }
+                if (RelativeOffsetOfEntryHeader == uint.MaxValue)
+                {
+                    RelativeOffsetOfEntryHeader = zip64ExtraData.RelativeOffsetOfEntryHeader;
+                }
+            }
        }

        internal override void Write(BinaryWriter writer)
        {
+            var zip64 = CompressedSize >= uint.MaxValue || UncompressedSize >= uint.MaxValue || RelativeOffsetOfEntryHeader >= uint.MaxValue;
+            if (zip64)
+                Version = (ushort)(Version > 45 ? Version : 45);
+
            writer.Write(Version);
            writer.Write(VersionNeededToExtract);
-            writer.Write((ushort) Flags);
-            writer.Write((ushort) CompressionMethod);
+            writer.Write((ushort)Flags);
+            writer.Write((ushort)CompressionMethod);
            writer.Write(LastModifiedTime);
            writer.Write(LastModifiedDate);
            writer.Write(Crc);
-            writer.Write(CompressedSize);
-            writer.Write(UncompressedSize);
+            writer.Write(zip64 ? uint.MaxValue : CompressedSize);
+            writer.Write(zip64 ? uint.MaxValue : UncompressedSize);

            byte[] nameBytes = EncodeString(Name);
-            writer.Write((ushort) nameBytes.Length);
-            //writer.Write((ushort)Extra.Length);
-            writer.Write((ushort) 0);
-            writer.Write((ushort) Comment.Length);
+            writer.Write((ushort)nameBytes.Length);
+
+            if (zip64)
+            {
+                writer.Write((ushort)(2 + 2 + 8 + 8 + 8 + 4));
+            }
+            else
+            {
+                //writer.Write((ushort)Extra.Length);
+                writer.Write((ushort)0);
+            }
+            writer.Write((ushort)Comment.Length);

            writer.Write(DiskNumberStart);
            writer.Write(InternalFileAttributes);
            writer.Write(ExternalFileAttributes);
-            writer.Write(RelativeOffsetOfEntryHeader);
+            writer.Write(zip64 ? uint.MaxValue : RelativeOffsetOfEntryHeader);

            writer.Write(nameBytes);
-            // writer.Write(Extra);
+
+            if (zip64)
+            {
+                writer.Write((ushort)0x0001);
+                writer.Write((ushort)((8 + 8 + 8 + 4)));
+
+                writer.Write((ulong)UncompressedSize);
+                writer.Write((ulong)CompressedSize);
+                writer.Write((ulong)RelativeOffsetOfEntryHeader);
+                writer.Write((uint)0); // VolumeNumber = 0
+            }
            writer.Write(Comment);
        }

@@ -75,7 +115,7 @@ namespace SharpCompress.Common.Zip.Headers

        public ushort VersionNeededToExtract { get; set; }

-        public uint RelativeOffsetOfEntryHeader { get; set; }
+        public long RelativeOffsetOfEntryHeader { get; set; }

        public uint ExternalFileAttributes { get; set; }

--- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeader.cs
@@ -13,8 +13,8 @@ namespace SharpCompress.Common.Zip.Headers
        internal override void Read(BinaryReader reader)
        {
            Version = reader.ReadUInt16();
-            Flags = (HeaderFlags) reader.ReadUInt16();
-            CompressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
+            Flags = (HeaderFlags)reader.ReadUInt16();
+            CompressionMethod = (ZipCompressionMethod)reader.ReadUInt16();
            LastModifiedTime = reader.ReadUInt16();
            LastModifiedDate = reader.ReadUInt16();
            Crc = reader.ReadUInt32();
@@ -28,32 +28,73 @@ namespace SharpCompress.Common.Zip.Headers
            LoadExtra(extra);

            var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
-            if (unicodePathExtra!=null)
+            if (unicodePathExtra != null)
            {
-                Name = ((ExtraUnicodePathExtraField) unicodePathExtra).UnicodeName;
+                Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
+            }
+
+            var zip64ExtraData = Extra.OfType<Zip64ExtendedInformationExtraField>().FirstOrDefault();
+            if (zip64ExtraData != null)
+            {
+                if (CompressedSize == uint.MaxValue)
+                {
+                    CompressedSize = zip64ExtraData.CompressedSize;
+                }
+                if (UncompressedSize == uint.MaxValue)
+                {
+                    UncompressedSize = zip64ExtraData.UncompressedSize;
+                }
            }
        }

        internal override void Write(BinaryWriter writer)
        {
+            if (IsZip64)
+                Version = (ushort)(Version > 45 ? Version : 45);
+
            writer.Write(Version);
-            writer.Write((ushort) Flags);
-            writer.Write((ushort) CompressionMethod);
+            
+            writer.Write((ushort)Flags);
+            writer.Write((ushort)CompressionMethod);
            writer.Write(LastModifiedTime);
            writer.Write(LastModifiedDate);
            writer.Write(Crc);
-            writer.Write(CompressedSize);
-            writer.Write(UncompressedSize);
+
+            if (IsZip64)
+            {
+                writer.Write(uint.MaxValue);
+                writer.Write(uint.MaxValue);
+            }
+            else
+            {
+                writer.Write(CompressedSize);
+                writer.Write(UncompressedSize);
+            }

            byte[] nameBytes = EncodeString(Name);

-            writer.Write((ushort) nameBytes.Length);
-            writer.Write((ushort) 0);
+            writer.Write((ushort)nameBytes.Length);
+            if (IsZip64)
+            {
+                writer.Write((ushort)(2 + 2 + (2 * 8)));
+            }
+            else
+            {
+                writer.Write((ushort)0);
+            }
+
            //if (Extra != null)
            //{
            //    writer.Write(Extra);
            //}
            writer.Write(nameBytes);
+            if (IsZip64)
+            {
+                writer.Write((ushort)0x0001);
+                writer.Write((ushort)(2 * 8));
+                writer.Write((ulong)CompressedSize);
+                writer.Write((ulong)UncompressedSize);
+            }
        }

        internal ushort Version { get; private set; }
--- a/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs
+++ b/src/SharpCompress/Common/Zip/Headers/LocalEntryHeaderExtraFactory.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using SharpCompress.Converters;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -8,9 +9,11 @@ namespace SharpCompress.Common.Zip.Headers
        WinZipAes = 0x9901,

        NotImplementedExtraData = 0xFFFF,
+
        // Third Party Mappings
        // -Info-ZIP Unicode Path Extra Field
-        UnicodePathExtraField = 0x7075
+        UnicodePathExtraField = 0x7075,
+        Zip64ExtendedInformationExtraField = 0x0001
    }

    internal class ExtraData
@@ -22,17 +25,14 @@ namespace SharpCompress.Common.Zip.Headers

    internal class ExtraUnicodePathExtraField : ExtraData
    {
-        internal byte Version
-        {
-            get { return this.DataBytes[0]; }
-        }
+        internal byte Version => DataBytes[0];

        internal byte[] NameCRC32
        {
            get
            {
                var crc = new byte[4];
-                Buffer.BlockCopy(this.DataBytes, 1, crc, 0, 4);
+                Buffer.BlockCopy(DataBytes, 1, crc, 0, 4);
                return crc;
            }
        }
@@ -42,34 +42,108 @@ namespace SharpCompress.Common.Zip.Headers
            get
            {
                // PathNamelength = dataLength - Version(1 byte) - NameCRC32(4 bytes)
-                var length = this.Length - 5;
-                var nameStr = Encoding.UTF8.GetString(this.DataBytes, 5, length);
+                var length = Length - 5;
+                var nameStr = Encoding.UTF8.GetString(DataBytes, 5, length);
                return nameStr;
            }
        }
    }

+    internal class Zip64ExtendedInformationExtraField : ExtraData
+    {
+
+        public Zip64ExtendedInformationExtraField(ExtraDataType type, ushort length, byte[] dataBytes)
+        {
+            Type = type;
+            Length = length;
+            DataBytes = dataBytes;
+            Process();
+        }
+
+        //From the spec values are only in the extradata if the standard
+        //value is set to 0xFFFF, but if one of the sizes are present, both are.
+        //Hence if length == 4 volume only
+        //      if length == 8 offset only
+        //      if length == 12 offset + volume
+        //      if length == 16 sizes only
+        //      if length == 20 sizes + volume
+        //      if length == 24 sizes + offset
+        //      if length == 28 everything.
+        //It is unclear how many of these are used in the wild.
+
+        private void Process()
+        {
+            switch (DataBytes.Length)
+            {
+                case 4:
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 0);
+                    return;
+                case 8:
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    return;
+                case 12:
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 8);
+                    return;
+                case 16:
+                     UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                     CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    return;
+                case 20:
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 16);
+                    return;
+                case 24:
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
+                    return;
+                case 28:
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 16);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 24);
+                    return;
+                default:
+                throw new ArchiveException("Unexpected size of of Zip64 extended information extra field");
+            }
+        }
+
+        public long UncompressedSize { get; private set; }
+        public long CompressedSize { get; private set; }
+        public long RelativeOffsetOfEntryHeader { get; private set; }
+        public uint VolumeNumber { get; private set; }
+    }
+
    internal static class LocalEntryHeaderExtraFactory
    {
-        internal static ExtraData Create(ExtraDataType type,ushort length, byte[] extraData)
+        internal static ExtraData Create(ExtraDataType type, ushort length, byte[] extraData)
        {
            switch (type)
            {
                case ExtraDataType.UnicodePathExtraField:
-                    return new ExtraUnicodePathExtraField()
-                    {
-                        Type = type,
-                        Length = length,
-                        DataBytes = extraData
-                    };
+                    return new ExtraUnicodePathExtraField
+                           {
+                               Type = type,
+                               Length = length,
+                               DataBytes = extraData
+                           };
+                case ExtraDataType.Zip64ExtendedInformationExtraField:
+                    return new Zip64ExtendedInformationExtraField
+                            (
+                                type, 
+                                length,
+                                extraData
+                           );
                default:
                    return new ExtraData
-                    {
-                        Type = type,
-                        Length = length,
-                        DataBytes = extraData
-                    };
+                           {
+                               Type = type,
+                               Length = length,
+                               DataBytes = extraData
+                           };
            }
        }
    }
-}
+}
--- a/src/SharpCompress/Common/Zip/Headers/SplitHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/SplitHeader.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -9,12 +10,12 @@ namespace SharpCompress.Common.Zip.Headers
        {
        }

-        internal override void Read(System.IO.BinaryReader reader)
+        internal override void Read(BinaryReader reader)
        {
            throw new NotImplementedException();
        }

-        internal override void Write(System.IO.BinaryWriter writer)
+        internal override void Write(BinaryWriter writer)
        {
            throw new NotImplementedException();
        }
--- a/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndHeader.cs
@@ -0,0 +1,54 @@
+using System;
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class Zip64DirectoryEndHeader : ZipHeader
+    {
+        public Zip64DirectoryEndHeader()
+            : base(ZipHeaderType.Zip64DirectoryEnd)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            SizeOfDirectoryEndRecord = (long)reader.ReadUInt64();
+            VersionMadeBy = reader.ReadUInt16();
+            VersionNeededToExtract = reader.ReadUInt16();
+            VolumeNumber = reader.ReadUInt32();
+            FirstVolumeWithDirectory = reader.ReadUInt32();
+            TotalNumberOfEntriesInDisk = (long)reader.ReadUInt64();
+            TotalNumberOfEntries = (long)reader.ReadUInt64();
+            DirectorySize = (long)reader.ReadUInt64();
+            DirectoryStartOffsetRelativeToDisk = (long)reader.ReadUInt64();
+            DataSector = reader.ReadBytes((int)(SizeOfDirectoryEndRecord - SizeOfFixedHeaderDataExceptSignatureAndSizeFields));
+        }
+
+        const int SizeOfFixedHeaderDataExceptSignatureAndSizeFields = 44;
+
+        internal override void Write(BinaryWriter writer)
+        {
+            throw new NotImplementedException();
+        }
+
+        public long SizeOfDirectoryEndRecord { get; private set; }
+
+        public ushort VersionMadeBy { get; private set; }
+
+        public ushort VersionNeededToExtract { get; private set; }
+
+        public uint VolumeNumber { get; private set; }
+
+        public uint FirstVolumeWithDirectory { get; private set; }
+
+        public long TotalNumberOfEntriesInDisk { get; private set; }
+
+        public long TotalNumberOfEntries { get; private set; }
+
+        public long DirectorySize { get; private set; }
+
+        public long DirectoryStartOffsetRelativeToDisk { get; private set; }
+
+        public byte[] DataSector { get; private set; }
+    }
+}
--- a/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndLocatorHeader.cs
+++ b/src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndLocatorHeader.cs
@@ -0,0 +1,30 @@
+using System.IO;
+
+namespace SharpCompress.Common.Zip.Headers
+{
+    internal class Zip64DirectoryEndLocatorHeader : ZipHeader
+    {
+        public Zip64DirectoryEndLocatorHeader()
+            : base(ZipHeaderType.Zip64DirectoryEndLocator)
+        {
+        }
+
+        internal override void Read(BinaryReader reader)
+        {
+            FirstVolumeWithDirectory = reader.ReadUInt32();
+            RelativeOffsetOfTheEndOfDirectoryRecord = (long)reader.ReadUInt64();
+            TotalNumberOfVolumes = reader.ReadUInt32();
+        }
+
+        internal override void Write(BinaryWriter writer)
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public uint FirstVolumeWithDirectory { get; private set; }
+
+        public long RelativeOffsetOfTheEndOfDirectoryRecord { get; private set; }
+
+        public uint TotalNumberOfVolumes { get; private set; }
+    }
+}
--- a/src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
+++ b/src/SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
-using SharpCompress.Converter;
+using SharpCompress.Converters;

 namespace SharpCompress.Common.Zip.Headers
 {
@@ -19,13 +19,14 @@ namespace SharpCompress.Common.Zip.Headers
            get
            {
                if (Name.EndsWith("/"))
+                {
                    return true;
+                }

                //.NET Framework 4.5 : System.IO.Compression::CreateFromDirectory() probably writes backslashes to headers
                return CompressedSize == 0
-                        && UncompressedSize == 0
-                        && Name.EndsWith("\\");
-
+                       && UncompressedSize == 0
+                       && Name.EndsWith("\\");
            }
        }

@@ -56,15 +57,31 @@ namespace SharpCompress.Common.Zip.Headers

        internal ZipCompressionMethod CompressionMethod { get; set; }

-        internal uint CompressedSize { get; set; }
+        internal long CompressedSize { get; set; }

        internal long? DataStartPosition { get; set; }

-        internal uint UncompressedSize { get; set; }
+        internal long UncompressedSize { get; set; }

        internal List<ExtraData> Extra { get; set; }
+        
+        public string Password { get; set; }
+
+        internal PkwareTraditionalEncryptionData ComposeEncryptionData(Stream archiveStream)
+        {
+            if (archiveStream == null)
+            {
+                throw new ArgumentNullException(nameof(archiveStream));
+            }
+
+            var buffer = new byte[12];
+            archiveStream.Read(buffer, 0, 12);
+
+            PkwareTraditionalEncryptionData encryptionData = PkwareTraditionalEncryptionData.ForRead(Password, this, buffer);
+            
+            return encryptionData;
+        }

-        internal PkwareTraditionalEncryptionData PkwareTraditionalEncryptionData { get; set; }
 #if !NO_CRYPTO
        internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
 #endif
@@ -77,10 +94,10 @@ namespace SharpCompress.Common.Zip.Headers

        protected void LoadExtra(byte[] extra)
        {
-            for (int i = 0; i < extra.Length-4;)
+            for (int i = 0; i < extra.Length - 4;)
            {
                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
-                if (!Enum.IsDefined(typeof (ExtraDataType), type))
+                if (!Enum.IsDefined(typeof(ExtraDataType), type))
                {
                    type = ExtraDataType.NotImplementedExtraData;
                }
@@ -88,12 +105,14 @@ namespace SharpCompress.Common.Zip.Headers
                ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
                byte[] data = new byte[length];
                Buffer.BlockCopy(extra, i + 4, data, 0, length);
-                Extra.Add(LocalEntryHeaderExtraFactory.Create(type,length,data));
+                Extra.Add(LocalEntryHeaderExtraFactory.Create(type, length, data));

                i += length + 4;
            }
        }

        internal ZipFilePart Part { get; set; }
+
+        internal bool IsZip64 => CompressedSize == uint.MaxValue;
    }
 }
--- a/src/SharpCompress/Common/Zip/Headers/ZipHeaderType.cs
+++ b/src/SharpCompress/Common/Zip/Headers/ZipHeaderType.cs
@@ -7,5 +7,7 @@
        DirectoryEntry,
        DirectoryEnd,
        Split,
+        Zip64DirectoryEnd,
+        Zip64DirectoryEndLocator
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Hathcock	c63d7a07fc	Attempt to use native zlib for gzip. Need lower level access	2017-05-19 11:47:25 +01:00
Adam Hathcock	057ac9b001	Enable test	2017-05-19 11:03:31 +01:00
Adam Hathcock	8be931bbcb	Doing some resharper clean up	2017-05-19 10:52:49 +01:00
Adam Hathcock	3197ef289c	Forgot to hit save	2017-05-19 10:15:19 +01:00
Adam Hathcock	631578c175	Update to next version. Stop Zip64 tests from running all the time and some clean up	2017-05-19 10:10:23 +01:00
Adam Hathcock	f1809163c7	correct gitignore	2017-05-19 09:44:45 +01:00
Adam Hathcock	60e1fe86f2	Fix test running	2017-05-19 09:40:37 +01:00
Adam Hathcock	59d7de5bfc	Try again appveyor	2017-05-19 09:36:05 +01:00
Adam Hathcock	6e95c1d84a	Drop net35 support as dot net tooling doesn’t support it currently	2017-05-19 09:34:02 +01:00
Adam Hathcock	ee64670755	Move test folder to be tests	2017-05-19 09:19:37 +01:00
Adam Hathcock	3f7d0f5b68	Update test project	2017-05-19 09:14:43 +01:00
Adam Hathcock	e3514c5c4b	Don’t attempt to autodeploy	2017-05-19 09:06:18 +01:00
Adam Hathcock	cc3a9cff88	Merge pull request #231 from adamhathcock/VS2017 Vs2017	2017-05-19 09:02:12 +01:00
Adam Hathcock	15e821aa39	Remove unused events	2017-05-19 08:49:44 +01:00
Adam Hathcock	8dd1dbab5f	Remove Cake as it’s unnecessary for basic build/test/publish	2017-05-19 08:47:17 +01:00
Adam Hathcock	65ce91ddf6	Update. Only use net35, net standard 1.0 and net standard 1.3	2017-05-19 08:46:27 +01:00
Adam Hathcock	bf55595d6f	Merge pull request #226 from gardebring/master Add new event handler to allow tracking of progress of extraction progress for individual entry	2017-04-25 13:07:44 +01:00
Anders Gardebring	2aa123ccd7	Remove begin and end events since this can now be tracked via progress instead	2017-04-25 13:21:04 +02:00
Anders Gardebring	0990b06cc9	Create new TransferTo method and pass Entry and IReaderExtractionListener instead of passing an action lambda.	2017-04-25 12:48:56 +02:00
Anders Gardebring	e05f9843ba	Use strongly typed ReaderProgress instead of object[]	2017-04-25 12:36:32 +02:00
Anders Gardebring	683d2714d0	Add new event to be able to track progress of extraction of individual entry when extracting an archive. This allows for showing or logging progress of the extraction process, especially useful for large files that might take a long time to extract.	2017-04-24 13:50:45 +02:00
Anders Gardebring	b8ef1ecafc	Revert "Add new feature to allow injection of an action into the extraction process. This allows for showing or logging progress of the extraction process, especially useful for large files that might take a long time to extract." This reverts commit `467fc2d03d`.	2017-04-24 10:22:49 +02:00
Anders Gardebring	467fc2d03d	Add new feature to allow injection of an action into the extraction process. This allows for showing or logging progress of the extraction process, especially useful for large files that might take a long time to extract.	2017-04-20 11:45:53 +02:00
Adam Hathcock	58b4fe4f28	Merge pull request #220 from coderb/master verify RAR crc on header and file data	2017-04-07 11:56:06 +01:00
Brien Oberstein	97d5e0aac4	verify rar CRC on header and file data	2017-04-04 12:20:06 -04:00
Adam Hathcock	356c977cff	Merge pull request #215 from mnadareski/master Removed restriction on 7zip file entries	2017-03-17 09:20:59 +00:00
Matt Nadareski	99d6062376	Removed restriction on 7zip file entries	2017-03-16 15:55:20 -07:00
Adam Hathcock	f8538403e4	Merge pull request #211 from kenkendk/add_zip64 Add zip64	2017-03-13 10:23:26 +00:00
Kenneth Skovhede	726b9c80f6	Fixed compiling the unittest	2017-03-11 01:05:58 +01:00
Kenneth Skovhede	2894711c51	Added a test suite to verify zip64 write support is working, and can be read in both Archive and Stream mode	2017-03-11 00:54:06 +01:00
Kenneth Skovhede	85280f6f4f	Changed the logic to throw exceptions when sizes exceed the zip archive limits, and zip64 is not enabled. This changes the logic, such that archives larger than 4GiB are still automatically written correct (only the central header is special). Archives with individual streams larger than 4 GiB must set the zip64 flag, either on the archive or the individual streams.	2017-03-11 00:53:42 +01:00
Kenneth Skovhede	d7f4c0ee32	Fixed an error in the zip64 central end of header: the signature + length (12 bytes) are not included in the reported length.	2017-03-10 23:10:06 +01:00
Kenneth Skovhede	1263c0d976	Added support for writing zip64 headers	2017-03-09 23:56:42 +01:00
Kenneth Skovhede	cd3cbd2b32	Support for writing zip64 headers in the unused code	2017-03-09 23:18:57 +01:00
Adam Hathcock	b3a4fed8be	Mark for 0.15.2	2017-03-09 11:02:44 +00:00
Adam Hathcock	d0b4af6666	Merge pull request #210 from kenkendk/fix_invalid_headers Fix invalid headers	2017-03-09 10:41:18 +00:00
Kenneth Skovhede	81ab5c189d	Fixed writing correct headers in zip archives	2017-03-09 11:34:24 +01:00
Kenneth Skovhede	6ef3be4b5c	Fixed writing correct headers in zip archives	2017-03-09 11:32:20 +01:00
Adam Hathcock	9f90a1d651	Mark for 0.15.1	2017-01-25 09:31:01 +00:00
Adam Hathcock	ce9a3fd1ef	Add file ordering fix for OS X	2017-01-25 09:29:13 +00:00
Adam Hathcock	7c6f05058e	Merge pull request #206 from markryd/zip64-extraction Zip64 extending information and ZipReader	2017-01-25 09:03:43 +00:00
Mark Rydstrom	a8c3a7439e	Add support for zip64 to ZipReader	2017-01-25 17:05:48 +10:00
Mark Rydstrom	839b3ab0cf	Add support for zip64 extended information field	2017-01-25 16:51:15 +10:00
Adam Hathcock	44d54db80e	Fix some path issues on OS X when running tests.	2017-01-24 17:36:51 +00:00
Adam Hathcock	a67d7bc429	Mark for 0.15	2017-01-24 17:25:19 +00:00
Adam Hathcock	079a818c6c	Merge pull request #205 from markryd/zip64-extraction Add zip64 support for ZipArchive extraction	2017-01-24 16:56:42 +00:00
Mark Rydstrom	6be6ef0b5c	Add zip64 support for ZipArchive extraction	2017-01-24 13:04:03 +10:00
Adam Hathcock	8e51d9d646	0.14.1	2016-11-30 14:26:18 +00:00
Adam Hathcock	ea206f4f02	Merge pull request #199 from adamhathcock/Issue-198 Gzip entry can't be read multiple times	2016-11-25 09:33:56 +00:00
Adam Hathcock	f175a2a252	Merge branch 'master' into Issue-198	2016-11-25 09:21:44 +00:00
Adam Hathcock	3f7e559b86	Merge pull request #200 from ITnent/bug/Issue-197 Open branch, to fix multiple crashes on repeated zip archives reading…	2016-11-25 09:21:34 +00:00
Vladimir Demidov	2959b4d701	Modified check integrity condition for the encrypted file.	2016-11-24 20:41:08 +03:00
Vladimir Demidov	031286c5eb	Fixed defects after review.	2016-11-24 18:01:49 +03:00
Vladimir Demidov	e181fa8c4a	Restored original tabs.	2016-11-24 17:11:43 +03:00
Vladimir Demidov	7b035bec5d	Fixed some issues after review.	2016-11-24 16:21:02 +03:00
Vladimir Demidov	f39d2bf53a	Open branch, to fix multiple crashes on repeated zip archives reading. Added fix.	2016-11-24 15:14:29 +03:00
Adam Hathcock	7c8e407182	Merge branch 'master' into Issue-198	2016-11-21 12:21:29 +00:00
Adam Hathcock	a09136d46b	Merge pull request #195 from jskeet/strong-naming Strong-name both the main and test projects	2016-11-21 12:06:13 +00:00
Adam Hathcock	5fe1363ee1	Gzip entry can't be read multiple times https://github.com/adamhathcock/sharpcompress/issues/198	2016-11-21 12:04:35 +00:00
Jon Skeet	b41823fc10	Strong-name both the main and test projects It's not clear whether SharpCompress.Test.Portable (as referenced in AssemblyInfo.cs) still exists, but build.ps1 certainly works.	2016-11-15 18:42:56 +00:00
Adam Hathcock	0a64fe28b0	Oops, removed too much from project.json	2016-10-14 09:03:15 +01:00
Adam Hathcock	e320ccfa9a	0.14.0	2016-10-14 08:59:19 +01:00
Adam Hathcock	9628ff9456	Merge pull request #191 from jskeet/lzip Initial read-only support for LZip	2016-10-14 08:50:32 +01:00
Jon Skeet	d540f78cfc	Initial read-only support for LZip LZip has no notion of flienames, so an LzipReader wouldn't make very much sense; I've just implemented the stream, and hooked it into tar support.	2016-10-12 15:08:56 +01:00
Adam Hathcock	66420cd299	Merge pull request #189 from ziaa/master Remove unbalanced parentheses in code samples	2016-10-08 18:25:30 +01:00
Seyed Zia Azimi	dd0594471f	Remove unbalanced parentheses in samples	2016-10-07 19:33:41 +03:30
Adam Hathcock	844ba228ee	Make 0.13.1	2016-10-03 13:44:19 +01:00
Adam Hathcock	7efc701b32	Merge pull request #188 from adamhathcock/fix_nulls Fix null password on ReaderFactory. Fix null options on SevenZipArchive	2016-10-03 13:41:55 +01:00
Adam Hathcock	d7e29f7c4d	Fix occasionally failing test	2016-10-03 13:37:04 +01:00
Adam Hathcock	f26ba91386	Fix null password on ReaderFactory. Fix null options on SevenZipArchive	2016-10-03 13:32:53 +01:00
Adam Hathcock	c73ac2039c	Merge pull request #185 from adamhathcock/ppmd_allocation_zipwriter Make PpmdProperties lazy to avoid unnecessary allocations.	2016-10-03 13:04:14 +01:00
Adam Hathcock	671f9cd0cb	Empty commit to kick build	2016-10-03 12:58:23 +01:00
Adam Hathcock	131b5b9714	Can't use Lazy on .NET 3.5 :(	2016-10-03 11:20:29 +01:00
Adam Hathcock	74af0889b9	Make PpmdProperties lazy to avoid unnecessary allocations.	2016-10-03 10:16:26 +01:00
Adam Hathcock	e5ee399045	Merge pull request #181 from claunia/patch-1 Update FORMATS.md	2016-09-30 07:08:52 +01:00
Natalia Portillo	deeb7a0f64	Update FORMATS.md Add ADC to formats list.	2016-09-29 22:53:51 +01:00
Adam Hathcock	5af3bab1dc	Merge pull request #180 from adamhathcock/documenting Add Markdown files to document things.	2016-09-29 11:58:19 +01:00
Adam Hathcock	28be84d315	For all branches	2016-09-29 11:35:54 +01:00
Adam Hathcock	a0528c737d	Trying just to build once	2016-09-29 11:34:50 +01:00
Adam Hathcock	b506e488e8	Add build badge	2016-09-29 11:32:31 +01:00
Adam Hathcock	58eb0e08d6	Don't save artifacts for PRs	2016-09-29 11:22:26 +01:00
Adam Hathcock	562701894f	Save nupkgs	2016-09-29 11:13:05 +01:00
Adam Hathcock	54a562273b	Incomplete refactoring	2016-09-29 11:10:11 +01:00
Adam Hathcock	3f8c9c4cb0	Update for 0.13.0	2016-09-29 11:03:11 +01:00
Adam Hathcock	3e7d28b043	Can I fix tables?	2016-09-29 10:57:49 +01:00
Adam Hathcock	40b10d4a26	Add Markdown files to document things.	2016-09-29 10:55:04 +01:00
Adam Hathcock	f367630a2a	Merge pull request #179 from adamhathcock/tar_fix Allow empty tar header to be read to know there are no more tar heade…	2016-09-28 13:57:09 +01:00
Adam Hathcock	b9e4f00862	Merge branch 'master' into tar_fix	2016-09-28 13:50:45 +01:00
Adam Hathcock	d6e74d6163	Merge pull request #178 from adamhathcock/7zip_deflate Allow deflate decoder for 7zip	2016-09-28 13:50:35 +01:00
Adam Hathcock	4a4522b842	Merge branch 'master' into 7zip_deflate	2016-09-28 13:44:46 +01:00
Adam Hathcock	710ba4423d	Merge branch 'master' into tar_fix	2016-09-28 13:43:21 +01:00
Adam Hathcock	2a5494a804	Merge pull request #174 from adamhathcock/redo_options Redo options	2016-09-28 13:40:54 +01:00
Adam Hathcock	568909800c	Allow empty tar header to be read to know there are no more tar headers to read	2016-09-28 12:00:48 +01:00
Adam Hathcock	7513a608b1	Allow deflate decoder	2016-09-28 11:59:31 +01:00
Adam Hathcock	911e9878bd	Merge branch 'master' into redo_options	2016-09-27 13:09:07 +01:00
Adam Hathcock	899d7d6e61	Appveyor (#175 ) * First pass of Cake build * Update Cake but still need cake itself to run on full CLR * Test out appveyor * 3.5 build fix * Build master and PRs differently. Still scared to auto publish to nuget.	2016-09-27 13:08:42 +01:00
Adam Hathcock	260c0ee776	Add SaveTo overload for zip archives	2016-09-27 11:19:52 +01:00
Adam Hathcock	d71520808d	Helps if I rename everything	2016-09-27 11:08:54 +01:00
Adam Hathcock	177fc2a12c	Flags were a better idea when I was younger. It's not clear though.	2016-09-27 10:50:36 +01:00
Adam Hathcock	5dafcb02d4	Redo options classes	2016-09-27 10:23:35 +01:00
Adam Hathcock	c4fde80c5e	Create proper options objects to remove flags from API	2016-09-27 10:14:08 +01:00
Adam Hathcock	06e3486ec4	Bump version	2016-09-26 11:53:35 +01:00
Adam Hathcock	bd7c783aaf	Test fixes	2016-09-26 11:51:35 +01:00
Adam Hathcock	d732e3cfa4	Renamespace for proper pluralization	2016-09-26 11:49:49 +01:00
Adam Hathcock	c24cdc66ed	Clean up from clean up	2016-09-26 11:03:15 +01:00
Adam Hathcock	efa6f7a82e	Huge Resharper clean up. Fixed up test project.json	2016-09-26 10:55:52 +01:00
Natalia Portillo	ddbbc3b847	Adds support for Apple Data Compression. (#168 )	2016-09-12 17:41:31 +01:00
Adam Hathcock	7037161c07	Update README	2016-08-12 12:15:45 +01:00
Adam Hathcock	b0b62fcf91	Try to fix frameworks again by matching JSON.NET	2016-08-12 12:14:22 +01:00
Adam Hathcock	bd8ba7b854	Test with ForwardOnlyStream. RewindableStream shouldn't corrupt a ForwardOnlyStream (#161 )	2016-08-12 11:56:49 +01:00
Adam Hathcock	3a52c68270	0.12.3	2016-07-22 16:50:33 +01:00
Adam Hathcock	89fd778bd8	Make all framework assemblies be build targets as a fix https://github.com/NuGet/Home/issues/3103	2016-07-22 16:47:59 +01:00
Tobias Käs	6e3e8343a8	Ignore unofficial extension of file attributes. (#153 ) The high bits may contain posix file attributes when the archive was written by certain third party 7z implementations. These must be removed before we can interpret the attributes as windows (or .NET) file attributes.	2016-07-21 11:06:42 +01:00
Tobias Käs	9224237a99	Fix for issue #73 (#154 ) 7z archives may require alternating reads from multiple substreams so it is important to seek before reading from the underlying stream. To keep performance at an acceptable level it is necessary to perform buffering because seeking on every single one-byte-read will destroy performance.	2016-07-21 11:06:25 +01:00