Update docker build

.circleci/config.yml

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

.github/workflows/dotnetcore.yml

@@ -1,17 +0,0 @@
-name: SharpCompress
-on: [push]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [windows-latest, ubuntu-latest]
-
-    steps:
-    - uses: actions/checkout@v1
-    - uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 3.1.100
-    - name: Run the Cake script
-      uses: ecampidoglio/cake-action@master

README.md

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

appveyor.yml

@@ -1,5 +1,5 @@
 version: '{build}'
-image: Visual Studio 2019
+image: Visual Studio 2017
 
 pull_requests:
   do_not_increment_build_number: true

build.cake

@@ -11,32 +11,23 @@ Task("Build")
   .IsDependentOn("Restore")
   .Does(() =>
 {
+    var settings = new DotNetCoreBuildSettings
+    {
+        Framework = "netstandard1.4",
+        Configuration = "Release",
+        NoRestore = true
+    };
+
+    DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
+
     if (IsRunningOnWindows())
     {
-        MSBuild("./sharpcompress.sln", c => 
-        { 
-            c.SetConfiguration("Release")
-            .SetVerbosity(Verbosity.Minimal)
-            .UseToolVersion(MSBuildToolVersion.VS2019);
-        });
-    }
-    else 
-    {
-        var settings = new DotNetCoreBuildSettings
-        {
-            Framework = "netstandard1.3",
-            Configuration = "Release",
-            NoRestore = true
-        };
-
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
-
-        settings.Framework = "netstandard2.0";
-        DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
-
-        settings.Framework = "netstandard2.1";
+        settings.Framework = "net46";
         DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
     }
+
+    settings.Framework = "netstandard2.0";
+    DotNetCoreBuild("./src/SharpCompress/SharpCompress.csproj", settings);
 });
 
 Task("Test")
@@ -49,7 +40,7 @@ Task("Test")
         var settings = new DotNetCoreTestSettings
         {
             Configuration = "Release",
-            Framework = "netcoreapp3.1"
+            Framework = "netcoreapp2.2"
         };
         DotNetCoreTest(file.ToString(), settings);
     }
@@ -58,16 +49,17 @@ Task("Test")
 Task("Pack")
     .IsDependentOn("Build")
     .Does(() => 
-{
+{ 
     if (IsRunningOnWindows())
     {
-        MSBuild("src/SharpCompress/SharpCompress.csproj", c => c
-            .SetConfiguration("Release")
-            .SetVerbosity(Verbosity.Minimal)
-            .UseToolVersion(MSBuildToolVersion.VS2019)
-            .WithProperty("NoBuild", "true")
-            .WithTarget("Pack"));
-    } 
+        var settings = new DotNetCorePackSettings
+        {
+            Configuration = "Release",
+            NoBuild = true
+        };
+
+        DotNetCorePack("src/SharpCompress/SharpCompress.csproj", settings);
+    }
     else 
     {
         Information("Skipping Pack as this is not Windows");

src/SharpCompress/Archives/AbstractArchive.cs

@@ -23,7 +23,7 @@ namespace SharpCompress.Archives
         protected ReaderOptions ReaderOptions { get; }
 
         private bool disposed;
-
+        
         internal AbstractArchive(ArchiveType type, FileInfo fileInfo, ReaderOptions readerOptions)
         {
             Type = type;
@@ -140,12 +140,12 @@ namespace SharpCompress.Archives
 
         /// <summary>
         /// Use this method to extract all entries in an archive in order.
-        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be
+        /// This is primarily for SOLID Rar Archives or 7Zip Archives as they need to be 
         /// extracted sequentially for the best performance.
-        ///
+        /// 
         /// This method will load all entry information from the archive.
-        ///
-        /// WARNING: this will reuse the underlying stream for the archive.  Errors may
+        /// 
+        /// WARNING: this will reuse the underlying stream for the archive.  Errors may 
         /// occur if this is used at the same time as other extraction methods on this instance.
         /// </summary>
         /// <returns></returns>
@@ -174,4 +174,4 @@ namespace SharpCompress.Archives
             }
         }
     }
-}
+}

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -142,4 +142,4 @@ namespace SharpCompress.Archives
             modifiedEntries.Cast<Entry>().ForEach(x => x.Close());
         }
     }
-}
+}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -135,7 +135,7 @@ namespace SharpCompress.Archives.SevenZip
         {
             BinaryReader reader = new BinaryReader(stream);
             byte[] signatureBytes = reader.ReadBytes(6);
-            return signatureBytes.SequenceEqual(SIGNATURE);
+            return signatureBytes.BinaryEquals(SIGNATURE);
         }
 
         protected override IReader CreateReaderForSolidExtraction()
@@ -201,7 +201,7 @@ namespace SharpCompress.Archives.SevenZip
                 return CreateEntryStream(new ReadOnlySubStream(currentStream, currentItem.Size));
             }
         }
-
+        
         private class PasswordProvider : IPasswordProvider
         {
             private readonly string _password;
@@ -209,6 +209,7 @@ namespace SharpCompress.Archives.SevenZip
             public PasswordProvider(string password)
             {
                 _password = password;
+
             }
 
             public string CryptoGetTextPassword()

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -138,7 +138,7 @@ namespace SharpCompress.Archives.Tar
 
                             using (var entryStream = entry.OpenEntryStream())
                             {
-                                using (var memoryStream = new MemoryStream())
+                                using (var memoryStream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream())
                                 {
                                     entryStream.TransferTo(memoryStream);
                                     memoryStream.Position = 0;

src/SharpCompress/AssemblyInfo.cs

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

src/SharpCompress/Common/ArchiveEncoding.cs

@@ -67,4 +67,4 @@ namespace SharpCompress.Common
             return CustomDecoder ?? ((bytes, index, count) => GetEncoding().GetString(bytes, index, count));
         }
     }
-}
+}

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -1,10 +1,11 @@
 using System;
-using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
+using SharpCompress.Converters;
+using System.Text;
 
 namespace SharpCompress.Common.GZip
 {
@@ -59,7 +60,7 @@ namespace SharpCompress.Common.GZip
                 throw new ZlibException("Bad GZIP header.");
             }
 
-            int timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
+            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
             DateModified = TarHeader.EPOCH.AddSeconds(timet);
             if ((header[3] & 0x04) == 0x04)
             {
@@ -68,7 +69,7 @@ namespace SharpCompress.Common.GZip
 
                 Int16 extraLength = (Int16)(header[0] + header[1] * 256);
                 byte[] extra = new byte[extraLength];
-
+                
                 if (!stream.ReadFully(extra))
                 {
                     throw new ZlibException("Unexpected end-of-file reading GZIP header.");
@@ -116,4 +117,4 @@ namespace SharpCompress.Common.GZip
             return ArchiveEncoding.Decode(buffer);
         }
     }
-}
+}

src/SharpCompress/Common/Rar/RarCryptoWrapper.cs

@@ -50,10 +50,10 @@ namespace SharpCompress.Common.Rar
             if (sizeToRead > 0)
             {
                 int alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
-                byte[] cipherText = new byte[RarRijndael.CRYPTO_BLOCK_SIZE];
                 for (int i = 0; i < alignedSize / 16; i++)
                 {
                     //long ax = System.currentTimeMillis();
+                    byte[] cipherText = new byte[RarRijndael.CRYPTO_BLOCK_SIZE];
                     _actualStream.Read(cipherText, 0, RarRijndael.CRYPTO_BLOCK_SIZE);
 
                     var readBytes = _rijndael.ProcessBlock(cipherText);
@@ -93,4 +93,4 @@ namespace SharpCompress.Common.Rar
             base.Dispose(disposing);
         }
     }
-}
+}

src/SharpCompress/Common/Rar/RarRijndael.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Security.Cryptography;
 using System.Text;
 using SharpCompress.Crypto;
@@ -88,20 +89,19 @@ namespace SharpCompress.Common.Rar
         public byte[] ProcessBlock(byte[] cipherText)
         {
             var plainText = new byte[CRYPTO_BLOCK_SIZE];
-            byte[] decryptedBytes = new byte[CRYPTO_BLOCK_SIZE];
+            var decryptedBytes = new List<byte>();
             _rijndael.ProcessBlock(cipherText, 0, plainText, 0);
 
-            for (int j = 0; j < CRYPTO_BLOCK_SIZE; j++)
+            for (int j = 0; j < plainText.Length; j++)
             {
-                decryptedBytes[j] = (byte)(plainText[j] ^ _aesInitializationVector[j % 16]); //32:114, 33:101
+                decryptedBytes.Add((byte) (plainText[j] ^ _aesInitializationVector[j%16])); //32:114, 33:101
             }
 
             for (int j = 0; j < _aesInitializationVector.Length; j++)
             {
                 _aesInitializationVector[j] = cipherText[j];
             }
-
-            return decryptedBytes;
+            return decryptedBytes.ToArray();
         }
 
         public void Dispose()

src/SharpCompress/Common/SevenZip/ArchiveDatabase.cs

@@ -22,7 +22,7 @@ namespace SharpCompress.Common.SevenZip
         internal List<long> _packStreamStartPositions = new List<long>();
         internal List<int> _folderStartFileIndex = new List<int>();
         internal List<int> _fileIndexToFolderIndexMap = new List<int>();
-
+        
         internal IPasswordProvider PasswordProvider { get; }
 
         public ArchiveDatabase(IPasswordProvider passwordProvider)
@@ -152,14 +152,13 @@ namespace SharpCompress.Common.SevenZip
         {
             int packStreamIndex = folder._firstPackStreamId;
             long folderStartPackPos = GetFolderStreamPos(folder, 0);
-            int count = folder._packStreams.Count;
-            long[] packSizes = new long[count];
-            for (int j = 0; j < count; j++)
+            List<long> packSizes = new List<long>();
+            for (int j = 0; j < folder._packStreams.Count; j++)
             {
-                packSizes[j] = _packSizes[packStreamIndex + j];
+                packSizes.Add(_packSizes[packStreamIndex + j]);
             }
 
-            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes, folder, pw);
+            return DecoderStreamHelper.CreateDecoderStream(stream, folderStartPackPos, packSizes.ToArray(), folder, pw);
         }
 
         private long GetFolderPackStreamSize(int folderIndex, int streamIndex)
@@ -180,4 +179,4 @@ namespace SharpCompress.Common.SevenZip
             return 0;
         }
     }
-}
+}

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -1396,7 +1396,7 @@ namespace SharpCompress.Common.SevenZip
                 }
                 else
                 {
-                    _stream = new MemoryStream();
+                    _stream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream();
                 }
                 _rem = _db._files[index].Size;
             }
@@ -1449,14 +1449,13 @@ namespace SharpCompress.Common.SevenZip
                 CFolder folderInfo = db._folders[folderIndex];
                 int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                 long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
-                var count = folderInfo._packStreams.Count;
-                long[] packSizes = new long[count];
-                for (int j = 0; j < count; j++)
+                List<long> packSizes = new List<long>();
+                for (int j = 0; j < folderInfo._packStreams.Count; j++)
                 {
-                    packSizes[j] = db._packSizes[packStreamIndex + j];
+                    packSizes.Add(db._packSizes[packStreamIndex + j]);
                 }
 
-                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes, folderInfo,
+                s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(), folderInfo,
                                                             db.PasswordProvider);
                 _cachedStreams.Add(folderIndex, s);
             }
@@ -1554,16 +1553,15 @@ namespace SharpCompress.Common.SevenZip
                 int packStreamIndex = db._folders[folderIndex]._firstPackStreamId;
                 long folderStartPackPos = db.GetFolderStreamPos(folderInfo, 0);
 
-                var count = folderInfo._packStreams.Count;
-                long[] packSizes = new long[count];
-                for (int j = 0; j < count; j++)
+                List<long> packSizes = new List<long>();
+                for (int j = 0; j < folderInfo._packStreams.Count; j++)
                 {
-                    packSizes[j] = db._packSizes[packStreamIndex + j];
+                    packSizes.Add(db._packSizes[packStreamIndex + j]);
                 }
 
                 // TODO: If the decoding fails the last file may be extracted incompletely. Delete it?
 
-                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes,
+                Stream s = DecoderStreamHelper.CreateDecoderStream(_stream, folderStartPackPos, packSizes.ToArray(),
                                                                    folderInfo, db.PasswordProvider);
                 byte[] buffer = new byte[4 << 10];
                 for (;;)

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

@@ -1,7 +1,7 @@
 using System;
-using System.Buffers.Binary;
 using System.IO;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Tar.Headers
 {
@@ -49,7 +49,7 @@ namespace SharpCompress.Common.Tar.Headers
             }
             else
             {
-                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 100);
+                WriteStringBytes(ArchiveEncoding.Encode(Name), buffer, 0, 100);
                 WriteOctalBytes(Size, buffer, 124, 12);
                 var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
                 WriteOctalBytes(time, buffer, 136, 12);
@@ -57,10 +57,11 @@ namespace SharpCompress.Common.Tar.Headers
 
                 if (Size >= 0x1FFFFFFFF)
                 {
-                    Span<byte> bytes12 = stackalloc byte[12];
-                    BinaryPrimitives.WriteInt64BigEndian(bytes12.Slice(4), Size);
+                    byte[] bytes = DataConverter.BigEndian.GetBytes(Size);
+                    var bytes12 = new byte[12];
+                    bytes.CopyTo(bytes12, 12 - bytes.Length);
                     bytes12[0] |= 0x80;
-                    bytes12.CopyTo(buffer.AsSpan(124));
+                    bytes12.CopyTo(buffer, 124);
                 }
             }
 
@@ -175,9 +176,8 @@ namespace SharpCompress.Common.Tar.Headers
         {
             if ((buffer[124] & 0x80) == 0x80) // if size in binary
             {
-                return BinaryPrimitives.ReadInt64BigEndian(buffer.AsSpan(0x80));
+                return DataConverter.BigEndian.GetInt64(buffer, 0x80);
             }
-
             return ReadAsciiInt64Base8(buffer, 124, 11);
         }
 
@@ -192,11 +192,15 @@ namespace SharpCompress.Common.Tar.Headers
             return buffer;
         }
 
-        private static void WriteStringBytes(ReadOnlySpan<byte> name, Span<byte> buffer, int length)
+        private static void WriteStringBytes(byte[] name, byte[] buffer, int offset, int length)
         {
-            name.CopyTo(buffer);
             int i = Math.Min(length, name.Length);
-            buffer.Slice(i, length - i).Fill(0);
+            Buffer.BlockCopy(name, 0, buffer, offset, i);
+            // if Span<byte>.Fill can be used, it is more efficient
+            for (; i < length; ++i)
+            {
+                buffer[offset + i] = 0;
+            }
         }
 
         private static void WriteStringBytes(string name, byte[] buffer, int offset, int length)

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

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -76,34 +76,34 @@ namespace SharpCompress.Common.Zip.Headers
             switch (DataBytes.Length)
             {
                 case 4:
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 0);
                     return;
                 case 8:
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
                     return;
                 case 12:
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(8));
+                    RelativeOffsetOfEntryHeader = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 8);
                     return;
                 case 16:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
+                     UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                     CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
                     return;
                 case 20:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(16));
+                    UncompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 0);
+                    CompressedSize = (long)DataConverter.LittleEndian.GetUInt64(DataBytes, 8);
+                    VolumeNumber = DataConverter.LittleEndian.GetUInt32(DataBytes, 16);
                     return;
                 case 24:
-                    UncompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
+                    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 = BinaryPrimitives.ReadInt64LittleEndian(DataBytes);
-                    CompressedSize = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(8));
-                    RelativeOffsetOfEntryHeader = BinaryPrimitives.ReadInt64LittleEndian(DataBytes.AsSpan(16));
-                    VolumeNumber = BinaryPrimitives.ReadUInt32LittleEndian(DataBytes.AsSpan(24));
+                    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");
@@ -132,7 +132,7 @@ namespace SharpCompress.Common.Zip.Headers
                 case ExtraDataType.Zip64ExtendedInformationExtraField:
                     return new Zip64ExtendedInformationExtraField
                             (
-                                type,
+                                type, 
                                 length,
                                 extraData
                            );
@@ -146,4 +146,4 @@ namespace SharpCompress.Common.Zip.Headers
             }
         }
     }
-}
+}

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

@@ -1,7 +1,8 @@
 using System;
-using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
+using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip.Headers
 {
@@ -29,7 +30,7 @@ namespace SharpCompress.Common.Zip.Headers
                        && Name.EndsWith("\\");
             }
         }
-
+        
         internal Stream PackedStream { get; set; }
 
         internal ArchiveEncoding ArchiveEncoding { get; }
@@ -64,7 +65,7 @@ namespace SharpCompress.Common.Zip.Headers
 
             return encryptionData;
         }
-
+        
         internal WinzipAesEncryptionData WinzipAesEncryptionData { get; set; }
 
         internal ushort LastModifiedDate { get; set; }
@@ -77,13 +78,13 @@ namespace SharpCompress.Common.Zip.Headers
         {
             for (int i = 0; i < extra.Length - 4;)
             {
-                ExtraDataType type = (ExtraDataType)BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i));
+                ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
                 if (!Enum.IsDefined(typeof(ExtraDataType), type))
                 {
                     type = ExtraDataType.NotImplementedExtraData;
                 }
 
-                ushort length = BinaryPrimitives.ReadUInt16LittleEndian(extra.AsSpan(i + 2));
+                ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
 
                 // 7zip has this same kind of check to ignore extras blocks that don't conform to the standard 2-byte ID, 2-byte length, N-byte value.
                 // CPP/7Zip/Zip/ZipIn.cpp: CInArchive::ReadExtra

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -54,30 +54,14 @@ namespace SharpCompress.Common.Zip
                 //entry could be zero bytes so we need to know that.
                 if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
                 {
-                    var local_header = ((LocalEntryHeader)header);
-
-                    // If we have CompressedSize, there is data to be read
-                    if( local_header.CompressedSize > 0 )
+                    bool isRecording = rewindableStream.IsRecording;
+                    if (!isRecording)
                     {
-                        header.HasData = true;
-                    } // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
-                    else if( local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor) )
-                    {
-                        bool isRecording = rewindableStream.IsRecording;
-                        if (!isRecording)
-                        {
-                            rewindableStream.StartRecording();
-                        }
-                        uint nextHeaderBytes = reader.ReadUInt32();
-
-                        // Check if next data is PostDataDescriptor, streamed file with 0 length
-                        header.HasData = !IsHeader(nextHeaderBytes);
-                        rewindableStream.Rewind(!isRecording);
-                    }
-                    else // We are not streaming and compressed size is 0, we have no data
-                    {
-                        header.HasData = false;
+                        rewindableStream.StartRecording();
                     }
+                    uint nextHeaderBytes = reader.ReadUInt32();
+                    header.HasData = !IsHeader(nextHeaderBytes);
+                    rewindableStream.Rewind(!isRecording);
                 }
                 yield return header;
             }

src/SharpCompress/Common/Zip/WinzipAesCryptoStream.cs

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

src/SharpCompress/Common/Zip/WinzipAesEncryptionData.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Security.Cryptography;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Common.Zip
 {
@@ -62,10 +62,10 @@ namespace SharpCompress.Common.Zip
             IvBytes = rfc2898.GetBytes(KeySizeInBytes);
             _generatedVerifyValue = rfc2898.GetBytes(2);
 
-            short verify = BinaryPrimitives.ReadInt16LittleEndian(_passwordVerifyValue);
+            short verify = DataConverter.LittleEndian.GetInt16(_passwordVerifyValue, 0);
             if (_password != null)
             {
-                short generated = BinaryPrimitives.ReadInt16LittleEndian(_generatedVerifyValue);
+                short generated = DataConverter.LittleEndian.GetInt16(_generatedVerifyValue, 0);
                 if (verify != generated)
                 {
                     throw new InvalidFormatException("bad password");

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
 using SharpCompress.Common.Zip.Headers;
@@ -9,6 +8,7 @@ using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.Deflate64;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.PPMd;
+using SharpCompress.Converters;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Zip
@@ -108,19 +108,19 @@ namespace SharpCompress.Common.Zip
                     {
                         throw new InvalidFormatException("Winzip data length is not 7.");
                     }
-                    ushort compressedMethod = BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes);
+                    ushort compressedMethod = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 0);
 
                     if (compressedMethod != 0x01 && compressedMethod != 0x02)
                     {
                         throw new InvalidFormatException("Unexpected vendor version number for WinZip AES metadata");
                     }
 
-                    ushort vendorId = BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(2));
+                    ushort vendorId = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 2);
                     if (vendorId != 0x4541)
                     {
                         throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
                     }
-                    return CreateDecompressionStream(stream, (ZipCompressionMethod)BinaryPrimitives.ReadUInt16LittleEndian(data.DataBytes.AsSpan(5)));
+                    return CreateDecompressionStream(stream, (ZipCompressionMethod)DataConverter.LittleEndian.GetUInt16(data.DataBytes, 5));
                 }
                 default:
                 {
@@ -142,7 +142,7 @@ namespace SharpCompress.Common.Zip
                 && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor))
                 || Header.IsZip64)
             {
-                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close
+                plainStream = new NonDisposingStream(plainStream); //make sure AES doesn't close    
             }
             else
             {
@@ -182,4 +182,4 @@ namespace SharpCompress.Common.Zip
             return plainStream;
         }
     }
-}
+}

src/SharpCompress/Compressors/ADC/ADCBase.cs

@@ -65,16 +65,16 @@ namespace SharpCompress.Compressors.ADC
             }
         }
 
-        private static int GetOffset(ReadOnlySpan<byte> chunk)
+        private static int GetOffset(byte[] chunk, int position)
         {
-            switch (GetChunkType(chunk[0]))
+            switch (GetChunkType(chunk[position]))
             {
                 case PLAIN:
                     return 0;
                 case TWO_BYTE:
-                    return ((chunk[0] & 0x03) << 8) + chunk[1];
+                    return ((chunk[position] & 0x03) << 8) + chunk[position + 1];
                 case THREE_BYTE:
-                    return (chunk[1] << 8) + chunk[2];
+                    return (chunk[position + 1] << 8) + chunk[position + 2];
                 default:
                     return -1;
             }
@@ -116,7 +116,7 @@ namespace SharpCompress.Compressors.ADC
             byte[] buffer = new byte[bufferSize];
             int outPosition = 0;
             bool full = false;
-            Span<byte> temp = stackalloc byte[3];
+            MemoryStream tempMs;
 
             while (position < input.Length)
             {
@@ -142,10 +142,11 @@ namespace SharpCompress.Compressors.ADC
                         position += chunkSize + 1;
                         break;
                     case TWO_BYTE:
+                        tempMs = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream();
                         chunkSize = GetChunkSize((byte)readByte);
-                        temp[0] = (byte)readByte;
-                        temp[1] = (byte)input.ReadByte();
-                        offset = GetOffset(temp);
+                        tempMs.WriteByte((byte)readByte);
+                        tempMs.WriteByte((byte)input.ReadByte());
+                        offset = GetOffset(tempMs.ToArray(), 0);
                         if (outPosition + chunkSize > bufferSize)
                         {
                             full = true;
@@ -172,11 +173,12 @@ namespace SharpCompress.Compressors.ADC
                         }
                         break;
                     case THREE_BYTE:
+                        tempMs = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream();
                         chunkSize = GetChunkSize((byte)readByte);
-                        temp[0] = (byte)readByte;
-                        temp[1] = (byte)input.ReadByte();
-                        temp[2] = (byte)input.ReadByte();
-                        offset = GetOffset(temp);
+                        tempMs.WriteByte((byte)readByte);
+                        tempMs.WriteByte((byte)input.ReadByte());
+                        tempMs.WriteByte((byte)input.ReadByte());
+                        offset = GetOffset(tempMs.ToArray(), 0);
                         if (outPosition + chunkSize > bufferSize)
                         {
                             full = true;
@@ -215,4 +217,4 @@ namespace SharpCompress.Compressors.ADC
             return position - start;
         }
     }
-}
+}

src/SharpCompress/Compressors/Deflate/GZipStream.cs

@@ -27,8 +27,9 @@
 // ------------------------------------------------------------------
 
 using System;
-using System.Buffers.Binary;
 using System.IO;
+using SharpCompress.Common;
+using SharpCompress.Converters;
 using System.Text;
 
 namespace SharpCompress.Compressors.Deflate
@@ -441,7 +442,7 @@ namespace SharpCompress.Compressors.Deflate
             }
             TimeSpan delta = LastModified.Value - UNIX_EPOCH;
             var timet = (Int32)delta.TotalSeconds;
-            BinaryPrimitives.WriteInt32LittleEndian(header.AsSpan(i), timet);
+            DataConverter.LittleEndian.PutBytes(header, i, timet);
             i += 4;
 
             // xflg
@@ -475,4 +476,4 @@ namespace SharpCompress.Compressors.Deflate
             return header.Length; // bytes written
         }
     }
-}
+}

src/SharpCompress/Compressors/Deflate/ZlibBaseStream.cs

@@ -25,10 +25,11 @@
 // ------------------------------------------------------------------
 
 using System;
-using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
+using SharpCompress.Common;
 using SharpCompress.Common.Tar.Headers;
+using SharpCompress.Converters;
 using System.Text;
 
 namespace SharpCompress.Compressors.Deflate
@@ -243,12 +244,10 @@ namespace SharpCompress.Compressors.Deflate
                     if (_wantCompress)
                     {
                         // Emit the GZIP trailer: CRC32 and  size mod 2^32
-                        byte[] intBuf = new byte[4];
-                        BinaryPrimitives.WriteInt32LittleEndian(intBuf, crc.Crc32Result);
-                        _stream.Write(intBuf, 0, 4);
+                        int c1 = crc.Crc32Result;
+                        _stream.Write(DataConverter.LittleEndian.GetBytes(c1), 0, 4);
                         int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
-                        BinaryPrimitives.WriteInt32LittleEndian(intBuf, c2);
-                        _stream.Write(intBuf, 0, 4);
+                        _stream.Write(DataConverter.LittleEndian.GetBytes(c2), 0, 4);
                     }
                     else
                     {
@@ -294,9 +293,9 @@ namespace SharpCompress.Compressors.Deflate
                             Array.Copy(_z.InputBuffer, _z.NextIn, trailer, 0, trailer.Length);
                         }
 
-                        Int32 crc32_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer);
+                        Int32 crc32_expected = DataConverter.LittleEndian.GetInt32(trailer, 0);
                         Int32 crc32_actual = crc.Crc32Result;
-                        Int32 isize_expected = BinaryPrimitives.ReadInt32LittleEndian(trailer.AsSpan(4));
+                        Int32 isize_expected = DataConverter.LittleEndian.GetInt32(trailer, 4);
                         Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
 
                         if (crc32_actual != crc32_expected)
@@ -447,7 +446,7 @@ namespace SharpCompress.Compressors.Deflate
                 throw new ZlibException("Bad GZIP header.");
             }
 
-            Int32 timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan(4));
+            Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
             _GzipMtime = TarHeader.EPOCH.AddSeconds(timet);
             totalBytesRead += n;
             if ((header[3] & 0x04) == 0x04)
@@ -648,4 +647,4 @@ namespace SharpCompress.Compressors.Deflate
             Undefined
         }
     }
-}
+}

src/SharpCompress/Compressors/LZMA/AesDecoderStream.cs

@@ -193,7 +193,7 @@ namespace SharpCompress.Compressors.LZMA
             }
             else
             {
-#if NETSTANDARD1_3 || NETSTANDARD2_0
+#if NETSTANDARD1_4 || NETSTANDARD2_0
                 using (IncrementalHash sha = IncrementalHash.CreateHash(HashAlgorithmName.SHA256))
                 {
                     byte[] counter = new byte[8];

src/SharpCompress/Compressors/LZMA/LZipStream.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.IO;
+using SharpCompress.Converters;
 using SharpCompress.Crypto;
 using SharpCompress.IO;
 
@@ -58,17 +58,16 @@ namespace SharpCompress.Compressors.LZMA
                     crc32Stream.WrappedStream.Dispose();
                     crc32Stream.Dispose();
                     var compressedCount = _countingWritableSubStream.Count;
+                    
+                    var bytes = DataConverter.LittleEndian.GetBytes(crc32Stream.Crc);
+                    _countingWritableSubStream.Write(bytes, 0, bytes.Length);
 
-                    byte[] intBuf = new byte[8];
-                    BinaryPrimitives.WriteUInt32LittleEndian(intBuf, crc32Stream.Crc);
-                    _countingWritableSubStream.Write(intBuf, 0, 4);
-
-                    BinaryPrimitives.WriteInt64LittleEndian(intBuf, _writeCount);
-                    _countingWritableSubStream.Write(intBuf, 0, 8);
+                    bytes = DataConverter.LittleEndian.GetBytes(_writeCount);
+                    _countingWritableSubStream.Write(bytes, 0, bytes.Length);
 
                     //total with headers
-                    BinaryPrimitives.WriteUInt64LittleEndian(intBuf, compressedCount + 6 + 20);
-                    _countingWritableSubStream.Write(intBuf, 0, 8);
+                    bytes = DataConverter.LittleEndian.GetBytes(compressedCount + 6 + 20);
+                    _countingWritableSubStream.Write(bytes, 0, bytes.Length);
                 }
                 _finished = true;
             }
@@ -102,7 +101,7 @@ namespace SharpCompress.Compressors.LZMA
         {
             _stream.Flush();
         }
-
+    
         // TODO: Both Length and Position are sometimes feasible, but would require
         // reading the output length when we initialize.
         public override long Length => throw new NotImplementedException();

src/SharpCompress/Compressors/LZMA/LzmaEncoder.cs

@@ -996,7 +996,7 @@ namespace SharpCompress.Compressors.LZMA
                     }
                 }
 
-                UInt32 startLen = 2; // speed optimization
+                UInt32 startLen = 2; // speed optimization 
 
                 for (UInt32 repIndex = 0; repIndex < Base.K_NUM_REP_DISTANCES; repIndex++)
                 {
@@ -1571,17 +1571,12 @@ namespace SharpCompress.Compressors.LZMA
 
         public void WriteCoderProperties(Stream outStream)
         {
-            WriteCoderProperties(_properties);
-            outStream.Write(_properties, 0, K_PROP_SIZE);
-        }
-
-        public void WriteCoderProperties(Span<byte> span)
-        {
-            span[0] = (byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
+            _properties[0] = (Byte)((_posStateBits * 5 + _numLiteralPosStateBits) * 9 + _numLiteralContextBits);
             for (int i = 0; i < 4; i++)
             {
-                span[1 + i] = (byte)((_dictionarySize >> (8 * i)) & 0xFF);
+                _properties[1 + i] = (Byte)((_dictionarySize >> (8 * i)) & 0xFF);
             }
+            outStream.Write(_properties, 0, K_PROP_SIZE);
         }
 
         private readonly UInt32[] _tempPrices = new UInt32[Base.K_NUM_FULL_DISTANCES];
@@ -1799,4 +1794,4 @@ namespace SharpCompress.Compressors.LZMA
             _trainSize = trainSize;
         }
     }
-}
+}

src/SharpCompress/Compressors/LZMA/LzmaStream.cs

@@ -1,7 +1,7 @@
 using System;
-using System.Buffers.Binary;
 using System.IO;
 using SharpCompress.Compressors.LZMA.LZ;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.LZMA
 {
@@ -56,7 +56,7 @@ namespace SharpCompress.Compressors.LZMA
 
             if (!isLzma2)
             {
-                _dictionarySize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
+                _dictionarySize = DataConverter.LittleEndian.GetInt32(properties, 1);
                 _outWindow.Create(_dictionarySize);
                 if (presetDictionary != null)
                 {
@@ -107,9 +107,9 @@ namespace SharpCompress.Compressors.LZMA
 
             _encoder = new Encoder();
             _encoder.SetCoderProperties(properties._propIDs, properties._properties);
-            byte[] prop = new byte[5];
-            _encoder.WriteCoderProperties(prop);
-            Properties = prop;
+            MemoryStream propStream = new MemoryStream(5);
+            _encoder.WriteCoderProperties(propStream);
+            Properties = propStream.ToArray();
 
             _encoder.SetStreams(null, outputStream, -1, -1);
             if (presetDictionary != null)
@@ -315,4 +315,4 @@ namespace SharpCompress.Compressors.LZMA
 
         public byte[] Properties { get; } = new byte[5];
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/FreqData.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -19,11 +19,7 @@ namespace SharpCompress.Compressors.PPMd.H
         {
         }
 
-        internal int SummFreq
-        {
-            get => BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address)) & 0xffff;
-            set => BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address), (short)value);
-        }
+        internal int SummFreq { get => DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff; set => DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value); }
 
         internal FreqData Initialize(byte[] mem)
         {
@@ -32,12 +28,14 @@ namespace SharpCompress.Compressors.PPMd.H
 
         internal void IncrementSummFreq(int dSummFreq)
         {
-            SummFreq += (short)dSummFreq;
+            short summFreq = DataConverter.LittleEndian.GetInt16(Memory, Address);
+            summFreq += (short)dSummFreq;
+            DataConverter.LittleEndian.PutBytes(Memory, Address, summFreq);
         }
 
         internal int GetStats()
         {
-            return BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 2));
+            return DataConverter.LittleEndian.GetInt32(Memory, Address + 2);
         }
 
         internal virtual void SetStats(State state)
@@ -47,7 +45,7 @@ namespace SharpCompress.Compressors.PPMd.H
 
         internal void SetStats(int state)
         {
-            BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 2), state);
+            DataConverter.LittleEndian.PutBytes(Memory, Address + 2, state);
         }
 
         public override String ToString()
@@ -66,4 +64,4 @@ namespace SharpCompress.Compressors.PPMd.H
             return buffer.ToString();
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/ModelPPM.cs

@@ -137,7 +137,7 @@ namespace SharpCompress.Compressors.PPMd.H
 
         private void RestartModelRare()
         {
-            new Span<int>(_charMask).Fill(0);
+            Utility.Fill(_charMask, 0);
             SubAlloc.InitSubAllocator();
             _initRl = -(_maxOrder < 12 ? _maxOrder : 12) - 1;
             int addr = SubAlloc.AllocContext();
@@ -228,7 +228,7 @@ namespace SharpCompress.Compressors.PPMd.H
         private void ClearMask()
         {
             _escCount = 1;
-            new Span<int>(_charMask).Fill(0);
+            Utility.Fill(_charMask, 0);
         }
 
         internal bool DecodeInit(IRarUnpack unpackRead, int escChar)
@@ -912,4 +912,4 @@ namespace SharpCompress.Compressors.PPMd.H
             }
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/PPMContext.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -22,7 +22,7 @@ namespace SharpCompress.Compressors.PPMd.H
             {
                 if (Memory != null)
                 {
-                    _numStats = BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address)) & 0xffff;
+                    _numStats = DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff;
                 }
                 return _numStats;
             }
@@ -32,7 +32,7 @@ namespace SharpCompress.Compressors.PPMd.H
                 _numStats = value & 0xffff;
                 if (Memory != null)
                 {
-                    BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address), (short)value);
+                    DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value);
                 }
             }
         }
@@ -109,7 +109,7 @@ namespace SharpCompress.Compressors.PPMd.H
         {
             if (Memory != null)
             {
-                _suffix = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 8));
+                _suffix = DataConverter.LittleEndian.GetInt32(Memory, Address + 8);
             }
             return _suffix;
         }
@@ -124,7 +124,7 @@ namespace SharpCompress.Compressors.PPMd.H
             _suffix = suffix;
             if (Memory != null)
             {
-                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 8), suffix);
+                DataConverter.LittleEndian.PutBytes(Memory, Address + 8, suffix);
             }
         }
 
@@ -307,7 +307,7 @@ namespace SharpCompress.Compressors.PPMd.H
         //		byte[] bytes = model.getSubAlloc().getHeap();
         //		int p1 = state1.Address;
         //		int p2 = state2.Address;
-        //
+        //		
         //		for (int i = 0; i < StatePtr.size; i++) {
         //			byte temp = bytes[p1+i];
         //			bytes[p1+i] = bytes[p2+i];
@@ -564,4 +564,4 @@ namespace SharpCompress.Compressors.PPMd.H
             UNION_SIZE = Math.Max(FreqData.SIZE, State.SIZE);
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/RarMemBlock.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Buffers.Binary;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -22,7 +21,7 @@ namespace SharpCompress.Compressors.PPMd.H
             {
                 if (Memory != null)
                 {
-                    _stamp = BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address)) & 0xffff;
+                    _stamp = DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff;
                 }
                 return _stamp;
             }
@@ -32,7 +31,7 @@ namespace SharpCompress.Compressors.PPMd.H
                 _stamp = value;
                 if (Memory != null)
                 {
-                    BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address), (short)value);
+                    DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value);
                 }
             }
         }
@@ -64,7 +63,7 @@ namespace SharpCompress.Compressors.PPMd.H
         {
             if (Memory != null)
             {
-                _next = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 4));
+                _next = DataConverter.LittleEndian.GetInt32(Memory, Address + 4);
             }
             return _next;
         }
@@ -79,7 +78,7 @@ namespace SharpCompress.Compressors.PPMd.H
             _next = next;
             if (Memory != null)
             {
-                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 4), next);
+                DataConverter.LittleEndian.PutBytes(Memory, Address + 4, next);
             }
         }
 
@@ -87,7 +86,7 @@ namespace SharpCompress.Compressors.PPMd.H
         {
             if (Memory != null)
             {
-                _nu = BinaryPrimitives.ReadInt16LittleEndian(Memory.AsSpan(Address + 2)) & 0xffff;
+                _nu = DataConverter.LittleEndian.GetInt16(Memory, Address + 2) & 0xffff;
             }
             return _nu;
         }
@@ -97,7 +96,7 @@ namespace SharpCompress.Compressors.PPMd.H
             _nu = nu & 0xffff;
             if (Memory != null)
             {
-                BinaryPrimitives.WriteInt16LittleEndian(Memory.AsSpan(Address + 2), (short)nu);
+                DataConverter.LittleEndian.PutBytes(Memory, Address + 2, (short)nu);
             }
         }
 
@@ -105,7 +104,7 @@ namespace SharpCompress.Compressors.PPMd.H
         {
             if (Memory != null)
             {
-                _prev = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 8));
+                _prev = DataConverter.LittleEndian.GetInt32(Memory, Address + 8);
             }
             return _prev;
         }
@@ -120,8 +119,8 @@ namespace SharpCompress.Compressors.PPMd.H
             _prev = prev;
             if (Memory != null)
             {
-                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 8), prev);
+                DataConverter.LittleEndian.PutBytes(Memory, Address + 8, prev);
             }
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/RarNode.cs

@@ -1,6 +1,5 @@
-using System;
-using System.Buffers.Binary;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -19,7 +18,7 @@ namespace SharpCompress.Compressors.PPMd.H
         {
             if (Memory != null)
             {
-                _next = BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address));
+                _next = DataConverter.LittleEndian.GetInt32(Memory, Address);
             }
             return _next;
         }
@@ -34,7 +33,7 @@ namespace SharpCompress.Compressors.PPMd.H
             _next = next;
             if (Memory != null)
             {
-                BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address), next);
+                DataConverter.LittleEndian.PutBytes(Memory, Address, next);
             }
         }
 
@@ -52,4 +51,4 @@ namespace SharpCompress.Compressors.PPMd.H
             return buffer.ToString();
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/State.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Text;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.PPMd.H
 {
@@ -29,7 +29,7 @@ namespace SharpCompress.Compressors.PPMd.H
 
         internal int GetSuccessor()
         {
-            return BinaryPrimitives.ReadInt32LittleEndian(Memory.AsSpan(Address + 2));
+            return DataConverter.LittleEndian.GetInt32(Memory, Address + 2);
         }
 
         internal void SetSuccessor(PpmContext successor)
@@ -39,7 +39,7 @@ namespace SharpCompress.Compressors.PPMd.H
 
         internal void SetSuccessor(int successor)
         {
-            BinaryPrimitives.WriteInt32LittleEndian(Memory.AsSpan(Address + 2), successor);
+            DataConverter.LittleEndian.PutBytes(Memory, Address + 2, successor);
         }
 
         internal void SetValues(StateRef state)
@@ -95,4 +95,4 @@ namespace SharpCompress.Compressors.PPMd.H
             return buffer.ToString();
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/H/SubAllocator.cs

@@ -166,7 +166,7 @@ namespace SharpCompress.Compressors.PPMd.H
             _freeListPos = _heapStart + allocSize;
 
             //UPGRADE_ISSUE: The following fragment of code could not be parsed and was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1156'"
-            //assert(realAllocSize - tempMemBlockPos == RarMemBlock.size): realAllocSize
+            //assert(realAllocSize - tempMemBlockPos == RarMemBlock.size): realAllocSize 
             //+   + tempMemBlockPos +   + RarMemBlock.size;
 
             // Init freeList
@@ -360,7 +360,7 @@ namespace SharpCompress.Compressors.PPMd.H
         public virtual void InitSubAllocator()
         {
             int i, k;
-            new Span<byte>(_heap, _freeListPos, SizeOfFreeList()).Fill(0);
+            Utility.Fill(_heap, _freeListPos, _freeListPos + SizeOfFreeList(), (byte)0);
 
             _pText = _heapStart;
 
@@ -448,4 +448,4 @@ namespace SharpCompress.Compressors.PPMd.H
             UNIT_SIZE = Math.Max(PpmContext.SIZE, RarMemBlock.SIZE);
         }
     }
-}
+}

src/SharpCompress/Compressors/PPMd/PpmdProperties.cs

@@ -1,6 +1,5 @@
-using System;
-using System.Buffers.Binary;
-using SharpCompress.Compressors.PPMd.I1;
+using SharpCompress.Compressors.PPMd.I1;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.PPMd
 {
@@ -26,7 +25,7 @@ namespace SharpCompress.Compressors.PPMd
             ModelOrder = modelOrder;
             RestorationMethod = modelRestorationMethod;
         }
-
+        
         public int ModelOrder { get; }
         public PpmdVersion Version { get; } = PpmdVersion.I1;
         internal ModelRestorationMethod RestorationMethod { get; }
@@ -35,7 +34,7 @@ namespace SharpCompress.Compressors.PPMd
         {
             if (properties.Length == 2)
             {
-                ushort props = BinaryPrimitives.ReadUInt16LittleEndian(properties);
+                ushort props = DataConverter.LittleEndian.GetUInt16(properties, 0);
                 AllocatorSize = (((props >> 4) & 0xff) + 1) << 20;
                 ModelOrder = (props & 0x0f) + 1;
                 RestorationMethod = (ModelRestorationMethod)(props >> 12);
@@ -43,7 +42,7 @@ namespace SharpCompress.Compressors.PPMd
             else if (properties.Length == 5)
             {
                 Version = PpmdVersion.H7Z;
-                AllocatorSize = BinaryPrimitives.ReadInt32LittleEndian(properties.AsSpan(1));
+                AllocatorSize = DataConverter.LittleEndian.GetInt32(properties, 1);
                 ModelOrder = properties[0];
             }
         }
@@ -65,16 +64,8 @@ namespace SharpCompress.Compressors.PPMd
             }
         }
 
-        public byte[] Properties
-        {
-            get
-            {
-                byte[] bytes = new byte[2];
-                BinaryPrimitives.WriteUInt16LittleEndian(
-                    bytes,
-                    (ushort)((ModelOrder - 1) + (((AllocatorSize >> 20) - 1) << 4) + ((ushort)RestorationMethod << 12)));
-                return bytes;
-            }
-        }
+        public byte[] Properties => DataConverter.LittleEndian.GetBytes(
+                                                                        (ushort)
+                                                                        ((ModelOrder - 1) + (((AllocatorSize >> 20) - 1) << 4) + ((ushort)RestorationMethod << 12)));
     }
-}
+}

src/SharpCompress/Compressors/PPMd/PpmdStream.cs

@@ -78,7 +78,10 @@ namespace SharpCompress.Compressors.PPMd
             {
                 if (_compress)
                 {
-                    _model.EncodeBlock(_stream, new MemoryStream(), true);
+                    using (var stream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream())
+                    {
+                        _model.EncodeBlock(_stream, stream, true);
+                    }
                 }
             }
             base.Dispose(isDisposing);

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack.cs

@@ -32,9 +32,9 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             }
         }
 
-        public bool Suspended {
+        public bool Suspended { 
             get => suspended;
-            set => suspended = value;
+            set => suspended = value; 
         }
 
         public int Char
@@ -139,12 +139,12 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
                 case 36: // alternative hash
                     Unpack29(fileHeader.IsSolid);
                     break;
-
+                
                 case 50: // rar 5.x compression
                     Unpack5(fileHeader.IsSolid);
                     break;
 
-                default:
+                default: 
                     throw new InvalidFormatException("unknown rar compression version " + fileHeader.CompressionAlgorithm);
             }
         }
@@ -729,13 +729,13 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             if (!solid)
             {
                 tablesRead = false;
-                new Span<int>(oldDist).Fill(0); // memset(oldDist,0,sizeof(OldDist));
+                Utility.Fill(oldDist, 0); // memset(oldDist,0,sizeof(OldDist));
 
                 oldDistPtr = 0;
                 lastDist = 0;
                 lastLength = 0;
 
-                new Span<byte>(unpOldTable).Fill(0); // memset(UnpOldTable,0,sizeof(UnpOldTable));
+                Utility.Fill(unpOldTable, (byte)0); // memset(UnpOldTable,0,sizeof(UnpOldTable));
 
                 unpPtr = 0;
                 wrPtr = 0;
@@ -837,7 +837,7 @@ WriteBorder=Math.Min(MaxWinSize,UNPACK_MAX_WRITE)&MaxWinMask;
 
             if ((bitField & 0x4000) == 0)
             {
-                new Span<byte>(unpOldTable).Fill(0); // memset(UnpOldTable,0,sizeof(UnpOldTable));
+                Utility.Fill(unpOldTable, (byte)0); // memset(UnpOldTable,0,sizeof(UnpOldTable));
             }
             AddBits(2);
 
@@ -1109,7 +1109,7 @@ WriteBorder=Math.Min(MaxWinSize,UNPACK_MAX_WRITE)&MaxWinMask;
             oldFilterLengths[FiltPos] = StackFilter.BlockLength;
 
             // memset(StackFilter->Prg.InitR,0,sizeof(StackFilter->Prg.InitR));
-            new Span<int>(StackFilter.Program.InitR).Fill(0);
+            Utility.Fill(StackFilter.Program.InitR, 0);
             StackFilter.Program.InitR[3] = RarVM.VM_GLOBALMEMADDR; // StackFilter->Prg.InitR[3]=VM_GLOBALMEMADDR;
             StackFilter.Program.InitR[4] = StackFilter.BlockLength;
 
@@ -1267,4 +1267,4 @@ WriteBorder=Math.Min(MaxWinSize,UNPACK_MAX_WRITE)&MaxWinMask;
             }
         }
     }
-}
+}

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack15.cs

@@ -3,7 +3,7 @@
 * Original author: Edmund Wagner
 * Creation date: 21.06.2007
 *
-* the unrar licence applies to all junrar source and binary distributions
+* the unrar licence applies to all junrar source and binary distributions 
 * you are not allowed to use this source to re-create the RAR compression algorithm
 */
 
@@ -652,9 +652,9 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
                 ChSetC[I] = ((~I + 1) & 0xff) << 8;
             }
 
-            new Span<int>(NToPl).Fill(0); // memset(NToPl,0,sizeof(NToPl));
-            new Span<int>(NToPlB).Fill(0); // memset(NToPlB,0,sizeof(NToPlB));
-            new Span<int>(NToPlC).Fill(0); // memset(NToPlC,0,sizeof(NToPlC));
+            Utility.Fill(NToPl, 0); // memset(NToPl,0,sizeof(NToPl));
+            Utility.Fill(NToPlB, 0); // memset(NToPlB,0,sizeof(NToPlB));
+            Utility.Fill(NToPlC, 0); // memset(NToPlC,0,sizeof(NToPlC));
             corrHuff(ChSetB, NToPlB);
         }
 
@@ -670,7 +670,7 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
                     // & ~0xff) | I;
                 }
             }
-            new Span<int>(NumToPlace).Fill(0); // memset(NumToPlace,0,sizeof(NToPl));
+            Utility.Fill(NumToPlace, 0); // memset(NumToPlace,0,sizeof(NToPl));
             for (I = 6; I >= 0; I--)
             {
                 NumToPlace[I] = (7 - I) * 32;
@@ -717,4 +717,4 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             wrPtr = unpPtr;
         }
     }
-}
+}

src/SharpCompress/Compressors/Rar/UnpackV1/Unpack20.cs

@@ -3,7 +3,7 @@
 * Original author: Edmund Wagner
 * Creation date: 21.06.2007
 *
-* the unrar licence applies to all junrar source and binary distributions
+* the unrar licence applies to all junrar source and binary distributions 
 * you are not allowed to use this source to re-create the RAR compression algorithm
 */
 
@@ -263,7 +263,7 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             if (0 == (BitField & 0x4000))
             {
                 // memset(UnpOldTable20,0,sizeof(UnpOldTable20));
-                new Span<byte>(UnpOldTable20).Fill(0);
+                Utility.Fill(UnpOldTable20, (byte)0);
             }
             AddBits(2);
 
@@ -371,7 +371,7 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
                 AudV[3] = new AudioVariables();
 
                 // memset(UnpOldTable20,0,sizeof(UnpOldTable20));
-                new Span<byte>(UnpOldTable20).Fill(0);
+                Utility.Fill(UnpOldTable20, (byte)0);
             }
         }
 
@@ -521,4 +521,4 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             return ((byte)Ch);
         }
     }
-}
+}

src/SharpCompress/Compressors/Rar/UnpackV1/UnpackUtility.cs

@@ -1,5 +1,4 @@
-using System;
-using SharpCompress.Compressors.Rar.VM;
+using SharpCompress.Compressors.Rar.VM;
 
 namespace SharpCompress.Compressors.Rar.UnpackV1
 {
@@ -187,7 +186,9 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             int i;
             long M, N;
 
-            new Span<int>(dec.DecodeNum).Fill(0); // memset(Dec->DecodeNum,0,Size*sizeof(*Dec->DecodeNum));
+            Utility.Fill(lenCount, 0); // memset(LenCount,0,sizeof(LenCount));
+
+            Utility.Fill(dec.DecodeNum, 0); // memset(Dec->DecodeNum,0,Size*sizeof(*Dec->DecodeNum));
 
             for (i = 0; i < size; i++)
             {
@@ -216,4 +217,4 @@ namespace SharpCompress.Compressors.Rar.UnpackV1
             dec.MaxNum = size;
         }
     }
-}
+}

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack15_cpp.cs

@@ -1,5 +1,4 @@
-using System;
-using static SharpCompress.Compressors.Rar.UnpackV2017.Unpack.Unpack15Local;
+using static SharpCompress.Compressors.Rar.UnpackV2017.Unpack.Unpack15Local;
 
 namespace SharpCompress.Compressors.Rar.UnpackV2017
 {
@@ -462,9 +461,9 @@ internal static class Unpack15Local {
     ChSetA[I]=(ushort)I;
     ChSetC[I]=(ushort)(((~I+1) & 0xff)<<8);
   }
-  new Span<byte>(NToPl).Fill(0);
-  new Span<byte>(NToPlB).Fill(0);
-  new Span<byte>(NToPlC).Fill(0);
+  Utility.Memset(NToPl,0,NToPl.Length);
+  Utility.Memset(NToPlB,0,NToPlB.Length);
+  Utility.Memset(NToPlC,0,NToPlC.Length);
   CorrHuff(ChSetB,NToPlB);
 }
 
@@ -474,7 +473,7 @@ internal static class Unpack15Local {
   for (I=7;I>=0;I--)
     for (J=0;J<32;J++)
       CharSet[J]=(ushort)((CharSet[J] & ~0xff) | I);
-  new Span<byte>(NumToPlace, 0, NToPl.Length).Fill(0);
+  Utility.Memset(NumToPlace,0,NToPl.Length);
   for (I=6;I>=0;I--)
     NumToPlace[I]=(byte)((7-I)*32);
 }

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack20_cpp.cs

@@ -191,7 +191,7 @@ internal static class Unpack20Local {
   UnpAudioBlock=(BitField & 0x8000)!=0;
 
   if ((BitField & 0x4000) != 0)
-    new Span<byte>(UnpOldTable20).Fill(0);
+    Utility.Memset(UnpOldTable20,0,UnpOldTable20.Length);
   Inp.addbits(2);
 
   uint TableSize;
@@ -296,7 +296,7 @@ internal static class Unpack20Local {
 
     //memset(AudV,0,sizeof(AudV));
     AudV = new AudioVariables[4];
-    new Span<byte>(UnpOldTable20).Fill(0);
+    Utility.Memset(UnpOldTable20, 0, UnpOldTable20.Length);
     //memset(MD,0,sizeof(MD));
     MD = new DecodeTable[4];
   }

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack50_cpp.cs

@@ -30,7 +30,7 @@ namespace SharpCompress.Compressors.Rar.UnpackV2017
     // Check TablesRead5 to be sure that we read tables at least once
     // regardless of current block header TablePresent flag.
     // So we can safefly use these tables below.
-    if (!ReadBlockHeader(Inp,ref BlockHeader) ||
+    if (!ReadBlockHeader(Inp,ref BlockHeader) || 
         !ReadTables(Inp,ref BlockHeader, ref BlockTables) || !TablesRead5)
       return;
   }
@@ -45,8 +45,8 @@ namespace SharpCompress.Compressors.Rar.UnpackV2017
 
       // We use 'while', because for empty block containing only Huffman table,
       // we'll be on the block border once again just after reading the table.
-      while (Inp.InAddr>BlockHeader.BlockStart+BlockHeader.BlockSize-1 ||
-             Inp.InAddr==BlockHeader.BlockStart+BlockHeader.BlockSize-1 &&
+      while (Inp.InAddr>BlockHeader.BlockStart+BlockHeader.BlockSize-1 || 
+             Inp.InAddr==BlockHeader.BlockStart+BlockHeader.BlockSize-1 && 
              Inp.InBit>=BlockHeader.BlockBitSize)
       {
         if (BlockHeader.LastBlockInFile)
@@ -415,7 +415,7 @@ namespace SharpCompress.Compressors.Rar.UnpackV2017
 
   // Choose the nearest among WriteBorder and WrPtr actual written border.
   // If border is equal to UnpPtr, it means that we have MaxWinSize data ahead.
-  if (WriteBorder==UnpPtr ||
+  if (WriteBorder==UnpPtr || 
       WrPtr!=UnpPtr && ((WrPtr-UnpPtr)&MaxWinMask)<((WriteBorder-UnpPtr)&MaxWinMask))
     WriteBorder=WrPtr;
 }
@@ -563,11 +563,11 @@ namespace SharpCompress.Compressors.Rar.UnpackV2017
     if (!UnpReadBuf())
       return false;
   Inp.faddbits((uint)((8-Inp.InBit)&7));
-
+  
   byte BlockFlags=(byte)(Inp.fgetbits()>>8);
   Inp.faddbits(8);
   uint ByteCount=(uint)(((BlockFlags>>3)&3)+1); // Block size byte count.
-
+  
   if (ByteCount==4)
     return false;
 

src/SharpCompress/Compressors/Rar/UnpackV2017/Unpack.unpack_cpp.cs

@@ -196,7 +196,7 @@ public Unpack(/* ComprDataIO *DataIO */)
 {
   if (!Solid)
   {
-    new Span<uint>(OldDist).Fill(0);
+    Utility.Memset<uint>(OldDist, 0, OldDist.Length);
     OldDistPtr=0;
     LastDist=LastLength=0;
 //    memset(Window,0,MaxWinSize);
@@ -246,7 +246,7 @@ public Unpack(/* ComprDataIO *DataIO */)
 
   // Set the entire DecodeNum to zero.
   //memset(Dec->DecodeNum,0,Size*sizeof(*Dec->DecodeNum));
-  new Span<ushort>(Dec.DecodeNum).Fill(0);
+  Utility.FillFast<ushort>(Dec.DecodeNum, 0);
 
   // Initialize not really used entry for zero length code.
   Dec.DecodePos[0]=0;
@@ -272,7 +272,7 @@ public Unpack(/* ComprDataIO *DataIO */)
     Dec.DecodeLen[I]=(uint)LeftAligned;
 
     // Every item of this array contains the sum of all preceding items.
-    // So it contains the start position in code list for every bit length.
+    // So it contains the start position in code list for every bit length. 
     Dec.DecodePos[I]=Dec.DecodePos[I-1]+LengthCount[I-1];
   }
 
@@ -337,7 +337,7 @@ public Unpack(/* ComprDataIO *DataIO */)
     uint BitField=Code<<(int)(16-Dec.QuickBits);
 
     // Prepare the table for quick decoding of bit lengths.
-
+  
     // Find the upper limit for current bit field and adjust the bit length
     // accordingly if necessary.
     while (CurBitLength<Dec.DecodeLen.Length && BitField>=Dec.DecodeLen[CurBitLength])

src/SharpCompress/Compressors/Rar/VM/RarVM.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.Collections.Generic;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Compressors.Rar.VM
 {
@@ -72,9 +72,9 @@ namespace SharpCompress.Compressors.Rar.VM
             }
             if (IsVMMem(mem))
             {
-                return BinaryPrimitives.ReadInt32LittleEndian(mem.AsSpan(offset));
+                return DataConverter.LittleEndian.GetInt32(mem, offset);
             }
-            return BinaryPrimitives.ReadInt32BigEndian(mem.AsSpan(offset));
+            return DataConverter.BigEndian.GetInt32(mem, offset);
         }
 
         private void SetValue(bool byteMode, byte[] mem, int offset, int value)
@@ -94,11 +94,11 @@ namespace SharpCompress.Compressors.Rar.VM
             {
                 if (IsVMMem(mem))
                 {
-                    BinaryPrimitives.WriteInt32LittleEndian(mem.AsSpan(offset), value);
+                    DataConverter.LittleEndian.PutBytes(mem, offset, value);
                 }
                 else
                 {
-                    BinaryPrimitives.WriteInt32BigEndian(mem.AsSpan(offset), value);
+                    DataConverter.BigEndian.PutBytes(mem, offset, value);
                 }
             }
 
@@ -120,12 +120,12 @@ namespace SharpCompress.Compressors.Rar.VM
             if (cmdOp.Type == VMOpType.VM_OPREGMEM)
             {
                 int pos = (cmdOp.Offset + cmdOp.Base) & VM_MEMMASK;
-                ret = BinaryPrimitives.ReadInt32LittleEndian(Mem.AsSpan(pos));
+                ret = DataConverter.LittleEndian.GetInt32(Mem, pos);
             }
             else
             {
                 int pos = cmdOp.Offset;
-                ret = BinaryPrimitives.ReadInt32LittleEndian(Mem.AsSpan(pos));
+                ret = DataConverter.LittleEndian.GetInt32(Mem, pos);
             }
             return ret;
         }
@@ -190,12 +190,12 @@ namespace SharpCompress.Compressors.Rar.VM
             {
                 //prg.GlobalData.Clear();
                 // ->GlobalData.Add(dataSize+VM_FIXEDGLOBALSIZE);
-                prg.GlobalData.Capacity = dataSize + VM_FIXEDGLOBALSIZE;
+                prg.GlobalData.SetSize(dataSize + VM_FIXEDGLOBALSIZE);
                 for (int i = 0; i < dataSize + VM_FIXEDGLOBALSIZE; i++)
 
                     // memcpy(&Prg->GlobalData[0],&Mem[VM_GLOBALMEMADDR],DataSize+VM_FIXEDGLOBALSIZE);
                 {
-                    prg.GlobalData.Add(Mem[VM_GLOBALMEMADDR + i]);
+                    prg.GlobalData[i] = Mem[VM_GLOBALMEMADDR + i];
                 }
             }
         }
@@ -1449,4 +1449,4 @@ namespace SharpCompress.Compressors.Rar.VM
     }
 
     //
-}
+}

src/SharpCompress/IO/MarkingBinaryReader.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Buffers.Binary;
 using System.IO;
+using SharpCompress.Converters;
 
 namespace SharpCompress.IO
 {
@@ -81,17 +81,17 @@ namespace SharpCompress.IO
 
         public override short ReadInt16()
         {
-            return BinaryPrimitives.ReadInt16LittleEndian(ReadBytes(2));
+            return DataConverter.LittleEndian.GetInt16(ReadBytes(2), 0);
         }
 
         public override int ReadInt32()
         {
-            return BinaryPrimitives.ReadInt32LittleEndian(ReadBytes(4));
+            return DataConverter.LittleEndian.GetInt32(ReadBytes(4), 0);
         }
 
         public override long ReadInt64()
         {
-            return BinaryPrimitives.ReadInt64LittleEndian(ReadBytes(8));
+            return DataConverter.LittleEndian.GetInt64(ReadBytes(8), 0);
         }
 
         public override sbyte ReadSByte()
@@ -111,17 +111,17 @@ namespace SharpCompress.IO
 
         public override ushort ReadUInt16()
         {
-            return BinaryPrimitives.ReadUInt16LittleEndian(ReadBytes(2));
+            return DataConverter.LittleEndian.GetUInt16(ReadBytes(2), 0);
         }
 
         public override uint ReadUInt32()
         {
-            return BinaryPrimitives.ReadUInt32LittleEndian(ReadBytes(4));
+            return DataConverter.LittleEndian.GetUInt32(ReadBytes(4), 0);
         }
 
         public override ulong ReadUInt64()
         {
-            return BinaryPrimitives.ReadUInt64LittleEndian(ReadBytes(8));
+            return DataConverter.LittleEndian.GetUInt64(ReadBytes(8), 0);
         }
 
         // RAR5 style variable length encoded value
@@ -196,4 +196,4 @@ namespace SharpCompress.IO
             throw new FormatException("malformed vint");
         }
     }
-}
+}

src/SharpCompress/IO/RewindableStream.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using Microsoft.IO;
 using SharpCompress.Compressors.Filters;
 
 namespace SharpCompress.IO
@@ -7,7 +8,7 @@ namespace SharpCompress.IO
     internal class RewindableStream : Stream
     {
         private readonly Stream stream;
-        private MemoryStream bufferStream = new MemoryStream();
+        private MemoryStream bufferStream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream();
         private bool isRewound;
         private bool isDisposed;
 
@@ -29,6 +30,7 @@ namespace SharpCompress.IO
             if (disposing)
             {
                 stream.Dispose();
+                bufferStream.Dispose();
             }
         }
 
@@ -51,7 +53,8 @@ namespace SharpCompress.IO
                 bufferStream.TransferTo(buffer);
                 //create new memorystream to allow proper resizing as memorystream could be a user provided buffer
                 //https://github.com/adamhathcock/sharpcompress/issues/306
-                bufferStream = new MemoryStream();
+                bufferStream.Dispose();
+                bufferStream = Utility.RECYCLABLE_MEMORY_STREAM_MANAGER.GetStream();
                 buffer.Position = 0;
                 buffer.TransferTo(bufferStream);
                 bufferStream.Position = 0;

src/SharpCompress/LazyReadOnlyCollection.cs

@@ -148,4 +148,4 @@ namespace SharpCompress
 
         #endregion
     }
-}
+}

src/SharpCompress/SharpCompress.csproj

@@ -2,14 +2,13 @@
   <PropertyGroup>
     <AssemblyTitle>SharpCompress - Pure C# Decompression/Compression</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.25.0</VersionPrefix>
-    <AssemblyVersion>0.25.0</AssemblyVersion>
-    <FileVersion>0.25.0</FileVersion>
+    <VersionPrefix>0.24.0</VersionPrefix>
+    <AssemblyVersion>0.24.0</AssemblyVersion>
+    <FileVersion>0.24.0</FileVersion>
     <Authors>Adam Hathcock</Authors>
-    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">netstandard1.3;netstandard2.0;netstandard2.1;net46</TargetFrameworks>
-    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks Condition="'$(LibraryFrameworks)'==''">net46;netstandard1.4;netstandard2.0</TargetFrameworks>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
-    <AllowUnsafeBlocks>false</AllowUnsafeBlocks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AssemblyName>SharpCompress</AssemblyName>
     <AssemblyOriginatorKeyFile>../../SharpCompress.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
@@ -17,18 +16,15 @@
     <PackageId>SharpCompress</PackageId>
     <PackageTags>rar;unrar;zip;unzip;bzip2;gzip;tar;7zip;lzip;xz</PackageTags>
     <PackageProjectUrl>https://github.com/adamhathcock/sharpcompress</PackageProjectUrl>
-    <PackageLicenseUrl>https://github.com/adamhathcock/sharpcompress/blob/master/LICENSE.txt</PackageLicenseUrl>
+    <PackageLicense>https://github.com/adamhathcock/sharpcompress/blob/master/LICENSE.txt</PackageLicense>
     <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
     <Description>SharpCompress is a compression library for NET Standard 1.3/2.0 that can unrar, decompress 7zip, decompress xz, zip/unzip, tar/untar lzip/unlzip, bzip2/unbzip2 and gzip/ungzip with forward-only reading and file random access APIs. Write support for zip/tar/bzip2/gzip is implemented.</Description>
-    <LangVersion>latest</LangVersion>
   </PropertyGroup>
-
   <ItemGroup>
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.7.0" />
-  </ItemGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' != 'netstandard2.1' ">
-    <PackageReference Include="System.Memory" Version="4.5.4" />
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="4.6.0" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.6.0" />
+    <PackageReference Include="System.Buffers" Version="4.5.0" />
+    <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" Version="1.3.0" />
   </ItemGroup>
 </Project>

src/SharpCompress/Utility.cs

@@ -2,12 +2,15 @@ using System;
 using System.Buffers;
 using System.Collections.Generic;
 using System.IO;
+using System.Runtime.CompilerServices;
+using Microsoft.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress
 {
     internal static class Utility
     {
+        public static readonly RecyclableMemoryStreamManager RECYCLABLE_MEMORY_STREAM_MANAGER = new RecyclableMemoryStreamManager();
         public static ReadOnlyCollection<T> ToReadOnly<T>(this ICollection<T> items)
         {
             return new ReadOnlyCollection<T>(items);
@@ -43,12 +46,78 @@ namespace SharpCompress
             return (number >> bits) + (2L << ~bits);
         }
 
+        /// <summary>
+        /// Fills the array with an specific value from an specific index to an specific index.
+        /// </summary>
+        /// <param name="array">The array to be filled.</param>
+        /// <param name="fromindex">The first index to be filled.</param>
+        /// <param name="toindex">The last index to be filled.</param>
+        /// <param name="val">The value to fill the array with.</param>
+        public static void Fill<T>(T[] array, int fromindex, int toindex, T val) where T : struct
+        {
+            if (array.Length == 0)
+            {
+                throw new NullReferenceException();
+            }
+            if (fromindex > toindex)
+            {
+                throw new ArgumentException();
+            }
+            if ((fromindex < 0) || array.Length < toindex)
+            {
+                throw new IndexOutOfRangeException();
+            }
+            for (int index = (fromindex > 0) ? fromindex-- : fromindex; index < toindex; index++)
+            {
+                array[index] = val;
+            }
+        }
+        public static void Memset(byte[] array, byte what, int length)
+        {
+            ref byte ptr = ref array[0];
+            Unsafe.InitBlock(ref ptr, what, (uint)length);
+        }
+
+        public static void Memset<T>(T[] array, T what, int length)
+        {
+            for (var i = 0; i < length; i++)
+            {
+                array[i] = what;
+            }
+        }
+
+        public static void FillFast<T>(T[] array, T val) where T : struct
+        {
+            for (int i = 0; i < array.Length; i++)
+            {
+                array[i] = val;
+            }
+        }
+
+        public static void FillFast<T>(T[] array, int start, int length, T val) where T : struct
+        {
+            int toIndex = start + length;
+            for (int i = start; i < toIndex; i++)
+            {
+                array[i] = val;
+            }
+        }
+
+
+        /// <summary>
+        /// Fills the array with an specific value.
+        /// </summary>
+        /// <param name="array">The array to be filled.</param>
+        /// <param name="val">The value to fill the array with.</param>
+        public static void Fill<T>(T[] array, T val) where T : struct
+        {
+            Fill(array, 0, array.Length, val);
+        }
+
         public static void SetSize(this List<byte> list, int count)
         {
             if (count > list.Count)
             {
-                // Ensure the list only needs to grow once
-                list.Capacity = count;
                 for (int i = list.Count; i < count; i++)
                 {
                     list.Add(0x0);
@@ -56,7 +125,18 @@ namespace SharpCompress
             }
             else
             {
-                list.RemoveRange(count, list.Count - count);
+                byte[] temp = new byte[count];
+                list.CopyTo(temp, 0);
+                list.Clear();
+                list.AddRange(temp);
+            }
+        }
+
+        public static void AddRange<T>(this ICollection<T> destination, IEnumerable<T> source)
+        {
+            foreach (T item in source)
+            {
+                destination.Add(item);
             }
         }
 
@@ -294,5 +374,21 @@ namespace SharpCompress
         {
             return source.Replace('\0', ' ').Trim();
         }
+
+        public static bool BinaryEquals(this byte[] source, byte[] target)
+        {
+            if (source.Length != target.Length)
+            {
+                return false;
+            }
+            for (int i = 0; i < source.Length; ++i)
+            {
+                if (source[i] != target[i])
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
     }
 }

src/SharpCompress/Writers/Zip/ZipCentralDirectoryEntry.cs

@@ -1,10 +1,10 @@
 using System;
-using System.Buffers.Binary;
 using System.IO;
 using System.Text;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
+using SharpCompress.Converters;
 
 namespace SharpCompress.Writers.Zip
 {
@@ -67,60 +67,39 @@ namespace SharpCompress.Writers.Zip
             if (Decompressed == 0 && Compressed == 0)
                 usedCompression = ZipCompressionMethod.None;
 
-            byte[] intBuf = new byte[] { 80, 75, 1, 2, version, 0, version, 0 };
             //constant sig, then version made by, then version to extract
-            outputStream.Write(intBuf, 0, 8);
+            outputStream.Write(new byte[] { 80, 75, 1, 2, version, 0, version, 0 }, 0, 8);
 
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            outputStream.Write(intBuf, 0, 2);
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)usedCompression);
-            outputStream.Write(intBuf, 0, 2); // zipping method
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ModificationTime.DateTimeToDosTime());
-            outputStream.Write(intBuf, 0, 4);
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)flags), 0, 2);
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)usedCompression), 0, 2); // zipping method
+            outputStream.Write(DataConverter.LittleEndian.GetBytes(ModificationTime.DateTimeToDosTime()), 0, 4);
 
             // zipping date and time
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, Crc);
-            outputStream.Write(intBuf, 0, 4); // file CRC
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, compressedvalue);
-            outputStream.Write(intBuf, 0, 4); // compressed file size
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, decompressedvalue);
-            outputStream.Write(intBuf, 0, 4); // uncompressed file size
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedFilename.Length);
-            outputStream.Write(intBuf, 0, 2); // Filename in zip
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)extralength);
-            outputStream.Write(intBuf, 0, 2); // extra length
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedComment.Length);
-            outputStream.Write(intBuf, 0, 2);
+            outputStream.Write(DataConverter.LittleEndian.GetBytes(Crc), 0, 4); // file CRC
+            outputStream.Write(DataConverter.LittleEndian.GetBytes(compressedvalue), 0, 4); // compressed file size
+            outputStream.Write(DataConverter.LittleEndian.GetBytes(decompressedvalue), 0, 4); // uncompressed file size
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedFilename.Length), 0, 2); // Filename in zip
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)extralength), 0, 2); // extra length
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedComment.Length), 0, 2);
 
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0);
-            outputStream.Write(intBuf, 0, 2); // disk=0
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            outputStream.Write(intBuf, 0, 2); // file type: binary
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            outputStream.Write(intBuf, 0, 2); // Internal file attributes
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x8100);
-            outputStream.Write(intBuf, 0, 2);
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // disk=0
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // file type: binary
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // Internal file attributes
+            outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x8100), 0, 2);
 
             // External file attributes (normal/readable)
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, headeroffsetvalue);
-            outputStream.Write(intBuf, 0, 4); // Offset of header
+            outputStream.Write(DataConverter.LittleEndian.GetBytes(headeroffsetvalue), 0, 4); // Offset of header
 
             outputStream.Write(encodedFilename, 0, encodedFilename.Length);
             if (zip64)
             {
-                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x0001);
-                outputStream.Write(intBuf, 0, 2);
-                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)(extralength - 4));
-                outputStream.Write(intBuf, 0, 2);
+                outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
+                outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(extralength - 4)), 0, 2);
 
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, Decompressed);
-                outputStream.Write(intBuf, 0, 8);
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, Compressed);
-                outputStream.Write(intBuf, 0, 8);
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, HeaderOffset);
-                outputStream.Write(intBuf, 0, 8);
-                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                outputStream.Write(intBuf, 0, 4); // VolumeNumber = 0
+                outputStream.Write(DataConverter.LittleEndian.GetBytes(Decompressed), 0, 8);
+                outputStream.Write(DataConverter.LittleEndian.GetBytes(Compressed), 0, 8);
+                outputStream.Write(DataConverter.LittleEndian.GetBytes(HeaderOffset), 0, 8);
+                outputStream.Write(DataConverter.LittleEndian.GetBytes(0), 0, 4); // VolumeNumber = 0
             }
 
             outputStream.Write(encodedComment, 0, encodedComment.Length);
@@ -129,4 +108,4 @@ namespace SharpCompress.Writers.Zip
                                     + 2 + 2 + 2 + 2 + 4 + encodedFilename.Length + extralength + encodedComment.Length);
         }
     }
-}
+}

src/SharpCompress/Writers/Zip/ZipWriter.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
@@ -11,6 +10,7 @@ using SharpCompress.Compressors.BZip2;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.Compressors.PPMd;
+using SharpCompress.Converters;
 using SharpCompress.IO;
 
 namespace SharpCompress.Writers.Zip
@@ -37,7 +37,7 @@ namespace SharpCompress.Writers.Zip
 
             compressionType = zipWriterOptions.CompressionType;
             compressionLevel = zipWriterOptions.DeflateCompressionLevel;
-
+            
             if (WriterOptions.LeaveStreamOpen)
             {
                 destination = new NonDisposingStream(destination);
@@ -162,10 +162,7 @@ namespace SharpCompress.Writers.Zip
             var explicitZipCompressionInfo = ToZipCompressionMethod(zipWriterEntryOptions.CompressionType ?? compressionType);
             byte[] encodedFilename = WriterOptions.ArchiveEncoding.Encode(filename);
 
-            // TODO: Use stackalloc when we exclusively support netstandard2.1 or higher
-            byte[] intBuf = new byte[4];
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ZipHeaderFactory.ENTRY_HEADER_BYTES);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
             if (explicitZipCompressionInfo == ZipCompressionMethod.Deflate)
             {
                 if (OutputStream.CanSeek && useZip64)
@@ -187,27 +184,21 @@ namespace SharpCompress.Writers.Zip
                     flags |= HeaderFlags.Bit1; // eos marker
                 }
             }
-
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)flags);
-            OutputStream.Write(intBuf, 0, 2);
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)explicitZipCompressionInfo);
-            OutputStream.Write(intBuf, 0, 2); // zipping method
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime());
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)flags), 0, 2);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo), 0, 2); // zipping method
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes(zipWriterEntryOptions.ModificationDateTime.DateTimeToDosTime()), 0, 4);
 
             // zipping date and time
             OutputStream.Write(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 0, 12);
 
             // unused CRC, un/compressed size, updated later
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedFilename.Length);
-            OutputStream.Write(intBuf, 0, 2); // filename length
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedFilename.Length), 0, 2); // filename length
 
             var extralength = 0;
             if (OutputStream.CanSeek && useZip64)
                 extralength = 2 + 2 + 8 + 8;
 
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)extralength);
-            OutputStream.Write(intBuf, 0, 2); // extra length
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)extralength), 0, 2); // extra length
             OutputStream.Write(encodedFilename, 0, encodedFilename.Length);
 
             if (extralength != 0)
@@ -221,60 +212,44 @@ namespace SharpCompress.Writers.Zip
 
         private void WriteFooter(uint crc, uint compressed, uint uncompressed)
         {
-            byte[] intBuf = new byte[4];
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, crc);
-            OutputStream.Write(intBuf, 0, 4);
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, compressed);
-            OutputStream.Write(intBuf, 0, 4);
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, uncompressed);
-            OutputStream.Write(intBuf, 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes(crc), 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes(compressed), 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes(uncompressed), 0, 4);
         }
 
         private void WriteEndRecord(ulong size)
         {
-
+            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
             var zip64 = isZip64 || entries.Count > ushort.MaxValue || streamPosition >= uint.MaxValue || size >= uint.MaxValue;
 
             var sizevalue = size >= uint.MaxValue ? uint.MaxValue : (uint)size;
             var streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streamPosition;
 
-            byte[] intBuf = new byte[8];
             if (zip64)
             {
                 var recordlen = 2 + 2 + 4 + 4 + 8 + 8 + 8 + 8;
 
                 // Write zip64 end of central directory record
                 OutputStream.Write(new byte[] { 80, 75, 6, 6 }, 0, 4);
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)recordlen), 0, 8); // Size of zip64 end of central directory record
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0), 0, 2); // Made by
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)45), 0, 2); // Version needed
 
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)recordlen);
-                OutputStream.Write(intBuf, 0, 8); // Size of zip64 end of central directory record
-                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 2); // Made by
-                BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 45);
-                OutputStream.Write(intBuf, 0, 2); // Version needed
-
-                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 4); // Disk number
-                OutputStream.Write(intBuf, 0, 4); // Central dir disk
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)0), 0, 4); // Disk number
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)0), 0, 4); // Central dir disk
 
                 // TODO: entries.Count is int, so max 2^31 files
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)entries.Count);
-                OutputStream.Write(intBuf, 0, 8); // Entries in this disk
-                OutputStream.Write(intBuf, 0, 8); // Total entries
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, size);
-                OutputStream.Write(intBuf, 0, 8); // Central Directory size
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)streamPosition);
-                OutputStream.Write(intBuf, 0, 8); // Disk offset
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)entries.Count), 0, 8); // Entries in this disk
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)entries.Count), 0, 8); // Total entries
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes(size), 0, 8); // Central Directory size
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)streamPosition), 0, 8); // Disk offset
 
                 // Write zip64 end of central directory locator
                 OutputStream.Write(new byte[] { 80, 75, 6, 7 }, 0, 4);
 
-                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 4); // Entry disk
-                BinaryPrimitives.WriteUInt64LittleEndian(intBuf, (ulong)streamPosition + size);
-                OutputStream.Write(intBuf, 0, 8); // Offset to the zip64 central directory
-                BinaryPrimitives.WriteUInt32LittleEndian(intBuf, 0);
-                OutputStream.Write(intBuf, 0, 4); // Number of disks
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes(0uL), 0, 4); // Entry disk
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes((ulong)streamPosition + size), 0, 8); // Offset to the zip64 central directory
+                OutputStream.Write(DataConverter.LittleEndian.GetBytes(0u), 0, 4); // Number of disks
 
                 streamPosition += recordlen + (4 + 4 + 8 + 4);
                 streampositionvalue = streamPosition >= uint.MaxValue ? uint.MaxValue : (uint)streampositionvalue;
@@ -282,16 +257,11 @@ namespace SharpCompress.Writers.Zip
 
             // Write normal end of central directory record
             OutputStream.Write(new byte[] { 80, 75, 5, 6, 0, 0, 0, 0 }, 0, 8);
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)entries.Count);
-            OutputStream.Write(intBuf, 0, 2);
-            OutputStream.Write(intBuf, 0, 2);
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, sizevalue);
-            OutputStream.Write(intBuf, 0, 4);
-            BinaryPrimitives.WriteUInt32LittleEndian(intBuf, streampositionvalue);
-            OutputStream.Write(intBuf, 0, 4);
-            byte[] encodedComment = WriterOptions.ArchiveEncoding.Encode(zipComment);
-            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, (ushort)encodedComment.Length);
-            OutputStream.Write(intBuf, 0, 2);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)entries.Count), 0, 2);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes(sizevalue), 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint)streampositionvalue), 0, 4);
+            OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)encodedComment.Length), 0, 2);
             OutputStream.Write(encodedComment, 0, encodedComment.Length);
         }
 
@@ -435,16 +405,11 @@ namespace SharpCompress.Writers.Zip
                         if (entry.Zip64HeaderOffset != 0)
                         {
                             originalStream.Position = (long)(entry.HeaderOffset + entry.Zip64HeaderOffset);
-                            byte[] intBuf = new byte[8];
-                            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 0x0001);
-                            originalStream.Write(intBuf, 0, 2);
-                            BinaryPrimitives.WriteUInt16LittleEndian(intBuf, 8 + 8);
-                            originalStream.Write(intBuf, 0, 2);
+                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)0x0001), 0, 2);
+                            originalStream.Write(DataConverter.LittleEndian.GetBytes((ushort)(8 + 8)), 0, 2);
 
-                            BinaryPrimitives.WriteUInt64LittleEndian(intBuf, entry.Decompressed);
-                            originalStream.Write(intBuf, 0, 8);
-                            BinaryPrimitives.WriteUInt64LittleEndian(intBuf, entry.Compressed);
-                            originalStream.Write(intBuf, 0, 8);
+                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Decompressed), 0, 8);
+                            originalStream.Write(DataConverter.LittleEndian.GetBytes(entry.Compressed), 0, 8);
                         }
 
                         originalStream.Position = writer.streamPosition + (long)entry.Compressed;
@@ -461,12 +426,10 @@ namespace SharpCompress.Writers.Zip
                         if (zip64)
                             throw new NotSupportedException("Streams larger than 4GiB are not supported for non-seekable streams");
 
-                        byte[] intBuf = new byte[4];
-                        BinaryPrimitives.WriteUInt32LittleEndian(intBuf, ZipHeaderFactory.POST_DATA_DESCRIPTOR);
-                        originalStream.Write(intBuf, 0, 4);
+                        originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
                         writer.WriteFooter(entry.Crc,
-                                           compressedvalue,
-                                           decompressedvalue);
+                                           (uint)compressedvalue,
+                                           (uint)decompressedvalue);
                         writer.streamPosition += (long)entry.Compressed + 16;
                     }
                     writer.entries.Add(entry);
@@ -526,4 +489,4 @@ namespace SharpCompress.Writers.Zip
 
         #endregion Nested type: ZipWritingStream
     }
-}
+}

tests/SharpCompress.Test/SharpCompress.Test.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFrameworks>netcoreapp2.2</TargetFrameworks>
     <AssemblyName>SharpCompress.Test</AssemblyName>
     <AssemblyOriginatorKeyFile>../../SharpCompress.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
@@ -12,7 +12,7 @@
     <ProjectReference Include="..\..\src\SharpCompress\SharpCompress.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.3.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="Xunit.SkippableFact" Version="1.3.12" />

tests/SharpCompress.Test/Zip/ZipReaderTests.cs

@@ -315,30 +315,5 @@ namespace SharpCompress.Test.Zip
                 }
             }
         }
-
-        [Fact]
-        public void Zip_None_Issue86_Streamed_Read()
-        {
-            var keys = new string[] { "Empty1", "Empty2", "Dir1/", "Dir2/", "Fake1", "Fake2", "Internal.zip" };
-
-            using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.none.issue86.zip")))
-            using (var reader = ZipReader.Open(stream))
-            {
-                foreach( var key in keys )
-                {
-                    reader.MoveToNextEntry();
-
-                    Assert.Equal( reader.Entry.Key, key );
-
-                    if (!reader.Entry.IsDirectory)
-                    {
-                        Assert.Equal(CompressionType.None, reader.Entry.CompressionType);
-                    }
-                }
-
-                Assert.False(reader.MoveToNextEntry());
-            }
-        }
-
     }
 }