Some clean up post-async merging

src/SharpCompress/Archives/GZip/GZipWritableArchiveEntry.cs

@@ -58,7 +58,7 @@ public override Stream OpenEntryStream()
     {
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return new NonDisposingStream(stream);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Archives/IArchiveEntryExtensions.cs

@@ -46,7 +46,13 @@ public async ValueTask WriteToAsync(
                 throw new ExtractionException("Entry is a file directory and cannot be extracted.");
             }
 
+#if LEGACY_DOTNET
             using var entryStream = await archiveEntry.OpenEntryStreamAsync(cancellationToken);
+#else
+            await using var entryStream = await archiveEntry.OpenEntryStreamAsync(
+                cancellationToken
+            );
+#endif
             var sourceStream = WrapWithProgress(entryStream, archiveEntry, progress);
             await sourceStream
                 .CopyToAsync(streamToWriteTo, Constants.BufferSize, cancellationToken)

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -153,12 +153,12 @@ protected override IEnumerable<SevenZipEntry> GetEntries(Stream stream)
             }
         }
 
-        protected override EntryStream GetEntryStream(bool useSyncOverAsyncDispose)
+        protected override EntryStream GetEntryStream()
         {
             var entry = _currentEntry.NotNull("currentEntry is not null");
             if (entry.IsDirectory)
             {
-                return CreateEntryStream(Stream.Null, false);
+                return CreateEntryStream(Stream.Null);
             }
 
             var folder = entry.FilePart.Folder;
@@ -186,8 +186,7 @@ protected override EntryStream GetEntryStream(bool useSyncOverAsyncDispose)
             return CreateEntryStream(
                 new SyncOnlyStream(
                     new ReadOnlySubStream(_currentFolderStream, entry.Size, leaveOpen: true)
-                ),
-                useSyncOverAsyncDispose
+                )
             );
         }
 

src/SharpCompress/Archives/Tar/TarArchive.Factory.cs

@@ -176,7 +176,11 @@ public static async ValueTask<bool> IsTarFileAsync(
         try
         {
             var tarHeader = new TarHeader(new ArchiveEncoding());
-            var reader = new AsyncBinaryReader(stream, false);
+#if NET8_0_OR_GREATER
+            await using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
+#else
+            using var reader = new AsyncBinaryReader(stream, leaveOpen: true);
+#endif
             var readSucceeded = await tarHeader.ReadAsync(reader);
             var isEmptyArchive =
                 tarHeader.Name?.Length == 0

src/SharpCompress/Archives/Tar/TarArchiveEntry.cs

@@ -14,8 +14,9 @@ internal TarArchiveEntry(TarArchive archive, TarFilePart? part, CompressionType
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public ValueTask<Stream> OpenEntryStreamAsync(CancellationToken cancellationToken = default) =>
-        new(OpenEntryStream());
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => (await Parts.Single().GetCompressedStreamAsync(cancellationToken)).NotNull();
 
     #region IArchiveEntry Members
 

src/SharpCompress/Archives/Tar/TarWritableArchiveEntry.cs

@@ -79,7 +79,7 @@ public override Stream OpenEntryStream()
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return new NonDisposingStream(stream);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Archives/Zip/ZipWritableArchiveEntry.cs

@@ -80,7 +80,7 @@ public override Stream OpenEntryStream()
         }
         //ensure new stream is at the start, this could be reset
         stream.Seek(0, SeekOrigin.Begin);
-        return new NonDisposingStream(stream);
+        return SharpCompressStream.CreateNonDisposing(stream);
     }
 
     internal override void Close()

src/SharpCompress/Common/Ace/AceCrc.cs

@@ -4,62 +4,61 @@
 using System.Text;
 using System.Threading.Tasks;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceCrc
 {
-    public class AceCrc
+    // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected)
+    private static readonly uint[] Crc32Table = GenerateTable();
+
+    private static uint[] GenerateTable()
     {
-        // CRC-32 lookup table (standard polynomial 0xEDB88320, reflected)
-        private static readonly uint[] Crc32Table = GenerateTable();
+        var table = new uint[256];
 
-        private static uint[] GenerateTable()
+        for (int i = 0; i < 256; i++)
         {
-            var table = new uint[256];
+            uint crc = (uint)i;
 
-            for (int i = 0; i < 256; i++)
+            for (int j = 0; j < 8; j++)
             {
-                uint crc = (uint)i;
-
-                for (int j = 0; j < 8; j++)
+                if ((crc & 1) != 0)
                 {
-                    if ((crc & 1) != 0)
-                    {
-                        crc = (crc >> 1) ^ 0xEDB88320u;
-                    }
-                    else
-                    {
-                        crc >>= 1;
-                    }
+                    crc = (crc >> 1) ^ 0xEDB88320u;
+                }
+                else
+                {
+                    crc >>= 1;
                 }
-
-                table[i] = crc;
             }
 
-            return table;
+            table[i] = crc;
         }
 
-        /// <summary>
-        /// Calculate ACE CRC-32 checksum.
-        /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected)
-        /// with init=0xFFFFFFFF but NO final XOR.
-        /// </summary>
-        public static uint AceCrc32(ReadOnlySpan<byte> data)
-        {
-            uint crc = 0xFFFFFFFFu;
-
-            foreach (byte b in data)
-            {
-                crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
-            }
+        return table;
+    }
 
-            return crc; // No final XOR for ACE
-        }
+    /// <summary>
+    /// Calculate ACE CRC-32 checksum.
+    /// ACE CRC-32 uses standard CRC-32 polynomial (0xEDB88320, reflected)
+    /// with init=0xFFFFFFFF but NO final XOR.
+    /// </summary>
+    public static uint AceCrc32(ReadOnlySpan<byte> data)
+    {
+        uint crc = 0xFFFFFFFFu;
 
-        /// <summary>
-        /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32.
-        /// </summary>
-        public static ushort AceCrc16(ReadOnlySpan<byte> data)
+        foreach (byte b in data)
         {
-            return (ushort)(AceCrc32(data) & 0xFFFF);
+            crc = (crc >> 8) ^ Crc32Table[(crc ^ b) & 0xFF];
         }
+
+        return crc; // No final XOR for ACE
+    }
+
+    /// <summary>
+    /// ACE CRC-16 is the lower 16 bits of the ACE CRC-32.
+    /// </summary>
+    public static ushort AceCrc16(ReadOnlySpan<byte> data)
+    {
+        return (ushort)(AceCrc32(data) & 0xFFFF);
     }
 }

src/SharpCompress/Common/Ace/AceEntry.cs

@@ -6,63 +6,62 @@
 using System.Threading.Tasks;
 using SharpCompress.Common.Ace.Headers;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceEntry : Entry
 {
-    public class AceEntry : Entry
-    {
-        private readonly AceFilePart _filePart;
+    private readonly AceFilePart _filePart;
 
-        internal AceEntry(AceFilePart filePart)
-        {
-            _filePart = filePart;
-        }
+    internal AceEntry(AceFilePart filePart)
+    {
+        _filePart = filePart;
+    }
 
-        public override long Crc
+    public override long Crc
+    {
+        get
         {
-            get
+            if (_filePart == null)
             {
-                if (_filePart == null)
-                {
-                    return 0;
-                }
-                return _filePart.Header.Crc32;
+                return 0;
             }
+            return _filePart.Header.Crc32;
         }
+    }
 
-        public override string? Key => _filePart?.Header.Filename;
+    public override string? Key => _filePart?.Header.Filename;
 
-        public override string? LinkTarget => null;
+    public override string? LinkTarget => null;
 
-        public override long CompressedSize => _filePart?.Header.PackedSize ?? 0;
+    public override long CompressedSize => _filePart?.Header.PackedSize ?? 0;
 
-        public override CompressionType CompressionType
+    public override CompressionType CompressionType
+    {
+        get
         {
-            get
+            if (_filePart.Header.CompressionType == Headers.CompressionType.Stored)
             {
-                if (_filePart.Header.CompressionType == Headers.CompressionType.Stored)
-                {
-                    return CompressionType.None;
-                }
-                return CompressionType.AceLZ77;
+                return CompressionType.None;
             }
+            return CompressionType.AceLZ77;
         }
+    }
 
-        public override long Size => _filePart?.Header.OriginalSize ?? 0;
+    public override long Size => _filePart?.Header.OriginalSize ?? 0;
 
-        public override DateTime? LastModifiedTime => _filePart.Header.DateTime;
+    public override DateTime? LastModifiedTime => _filePart.Header.DateTime;
 
-        public override DateTime? CreatedTime => null;
+    public override DateTime? CreatedTime => null;
 
-        public override DateTime? LastAccessedTime => null;
+    public override DateTime? LastAccessedTime => null;
 
-        public override DateTime? ArchivedTime => null;
+    public override DateTime? ArchivedTime => null;
 
-        public override bool IsEncrypted => _filePart.Header.IsFileEncrypted;
+    public override bool IsEncrypted => _filePart.Header.IsFileEncrypted;
 
-        public override bool IsDirectory => _filePart.Header.IsDirectory;
+    public override bool IsDirectory => _filePart.Header.IsDirectory;
 
-        public override bool IsSplitAfter => false;
+    public override bool IsSplitAfter => false;
 
-        internal override IEnumerable<FilePart> Parts => _filePart.Empty();
-    }
+    internal override IEnumerable<FilePart> Parts => _filePart.Empty();
 }

src/SharpCompress/Common/Ace/AceFilePart.cs

@@ -7,46 +7,45 @@
 using SharpCompress.Common.Ace.Headers;
 using SharpCompress.IO;
 
-namespace SharpCompress.Common.Ace
+namespace SharpCompress.Common.Ace;
+
+public class AceFilePart : FilePart
 {
-    public class AceFilePart : FilePart
-    {
-        private readonly Stream _stream;
-        internal AceFileHeader Header { get; set; }
+    private readonly Stream _stream;
+    internal AceFileHeader Header { get; set; }
 
-        internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream)
-            : base(localAceHeader.ArchiveEncoding)
-        {
-            _stream = seekableStream;
-            Header = localAceHeader;
-        }
+    internal AceFilePart(AceFileHeader localAceHeader, Stream seekableStream)
+        : base(localAceHeader.ArchiveEncoding)
+    {
+        _stream = seekableStream;
+        Header = localAceHeader;
+    }
 
-        internal override string? FilePartName => Header.Filename;
+    internal override string? FilePartName => Header.Filename;
 
-        internal override Stream GetCompressedStream()
+    internal override Stream GetCompressedStream()
+    {
+        if (_stream != null)
         {
-            if (_stream != null)
+            Stream compressedStream;
+            switch (Header.CompressionType)
             {
-                Stream compressedStream;
-                switch (Header.CompressionType)
-                {
-                    case Headers.CompressionType.Stored:
-                        compressedStream = new ReadOnlySubStream(
-                            _stream,
-                            Header.DataStartPosition,
-                            Header.PackedSize
-                        );
-                        break;
-                    default:
-                        throw new NotSupportedException(
-                            "CompressionMethod: " + Header.CompressionQuality
-                        );
-                }
-                return compressedStream;
+                case Headers.CompressionType.Stored:
+                    compressedStream = new ReadOnlySubStream(
+                        _stream,
+                        Header.DataStartPosition,
+                        Header.PackedSize
+                    );
+                    break;
+                default:
+                    throw new NotSupportedException(
+                        "CompressionMethod: " + Header.CompressionQuality
+                    );
             }
-            return _stream.NotNull();
+            return compressedStream;
         }
-
-        internal override Stream? GetRawStream() => _stream;
+        return _stream.NotNull();
     }
+
+    internal override Stream? GetRawStream() => _stream;
 }