Merge pull request #1132 from adamhathcock/adam/async-creation

Clean up for async creation

AGENTS.md

@@ -179,3 +179,58 @@ SharpCompress supports multiple archive and compression formats:
 3. **Stream disposal** - Always set `LeaveStreamOpen` explicitly when needed (default is to close)
 4. **Tar + non-seekable stream** - Must provide file size or it will throw
 6. **Format detection** - Use `ReaderFactory.Open()` for auto-detection, test with actual archive files
+
+### Async Struct-Copy Bug in LZMA RangeCoder
+
+When implementing async methods on mutable `struct` types (like `BitEncoder` and `BitDecoder` in the LZMA RangeCoder), be aware that the async state machine copies the struct when `await` is encountered. This means mutations to struct fields after the `await` point may not persist back to the original struct stored in arrays or fields.
+
+**The Bug:**
+```csharp
+// BAD: async method on mutable struct
+public async ValueTask<uint> DecodeAsync(Decoder decoder, CancellationToken cancellationToken = default)
+{
+    var newBound = (decoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
+    if (decoder._code < newBound)
+    {
+        decoder._range = newBound;
+        _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;  // Mutates _prob
+        await decoder.Normalize2Async(cancellationToken).ConfigureAwait(false);  // Struct gets copied here
+        return 0;  // Original _prob update may be lost
+    }
+    // ...
+}
+```
+
+**The Fix:**
+Refactor async methods on mutable structs to perform all struct mutations synchronously before any `await`, or use a helper method to separate the await from the struct mutation:
+
+```csharp
+// GOOD: struct mutations happen synchronously, await is conditional
+public ValueTask<uint> DecodeAsync(Decoder decoder, CancellationToken cancellationToken = default)
+{
+    var newBound = (decoder._range >> K_NUM_BIT_MODEL_TOTAL_BITS) * _prob;
+    if (decoder._code < newBound)
+    {
+        decoder._range = newBound;
+        _prob += (K_BIT_MODEL_TOTAL - _prob) >> K_NUM_MOVE_BITS;  // All mutations complete
+        return DecodeAsyncHelper(decoder.Normalize2Async(cancellationToken), 0);  // Await in helper
+    }
+    decoder._range -= newBound;
+    decoder._code -= newBound;
+    _prob -= (_prob) >> K_NUM_MOVE_BITS;  // All mutations complete
+    return DecodeAsyncHelper(decoder.Normalize2Async(cancellationToken), 1);  // Await in helper
+}
+
+private static async ValueTask<uint> DecodeAsyncHelper(ValueTask normalizeTask, uint result)
+{
+    await normalizeTask.ConfigureAwait(false);
+    return result;
+}
+```
+
+**Why This Matters:**
+In LZMA, the `BitEncoder` and `BitDecoder` structs maintain adaptive probability models in their `_prob` field. When these structs are stored in arrays (e.g., `_models[m]`), the async state machine copy breaks the adaptive model, causing incorrect bit decoding and eventually `DataErrorException` exceptions.
+
+**Related Files:**
+- `src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBit.Async.cs` - Fixed
+- `src/SharpCompress/Compressors/LZMA/RangeCoder/RangeCoderBitTree.Async.cs` - Uses readonly structs, so this pattern doesn't apply

src/SharpCompress/Algorithms/Adler32.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-#if !NETSTANDARD2_0 && !NETSTANDARD2_1 && !NETFRAMEWORK
+#if !LEGACY_DOTNET
 #define SUPPORTS_RUNTIME_INTRINSICS
 #define SUPPORTS_HOTPATH
 #endif

src/SharpCompress/Archives/AbstractArchive.Async.cs

@@ -0,0 +1,103 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+public abstract partial class AbstractArchive<TEntry, TVolume>
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
+{
+    #region Async Support
+
+    // Async properties
+    public virtual IAsyncEnumerable<TEntry> EntriesAsync => _lazyEntriesAsync;
+
+    public IAsyncEnumerable<TVolume> VolumesAsync => _lazyVolumesAsync;
+
+    protected virtual async IAsyncEnumerable<TEntry> LoadEntriesAsync(
+        IAsyncEnumerable<TVolume> volumes
+    )
+    {
+        foreach (var item in LoadEntries(await volumes.ToListAsync()))
+        {
+            yield return item;
+        }
+    }
+
+    public virtual async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            await foreach (var v in _lazyVolumesAsync)
+            {
+                v.Dispose();
+            }
+            foreach (var v in _lazyEntriesAsync.GetLoaded().Cast<Entry>())
+            {
+                v.Close();
+            }
+            _sourceStream?.Dispose();
+
+            _disposed = true;
+        }
+    }
+
+    private async ValueTask EnsureEntriesLoadedAsync()
+    {
+        await _lazyEntriesAsync.EnsureFullyLoaded();
+        await _lazyVolumesAsync.EnsureFullyLoaded();
+    }
+
+    private async IAsyncEnumerable<IArchiveEntry> EntriesAsyncCast()
+    {
+        await foreach (var entry in EntriesAsync)
+        {
+            yield return entry;
+        }
+    }
+
+    IAsyncEnumerable<IArchiveEntry> IAsyncArchive.EntriesAsync => EntriesAsyncCast();
+
+    IAsyncEnumerable<IVolume> IAsyncArchive.VolumesAsync => VolumesAsyncCast();
+
+    private async IAsyncEnumerable<IVolume> VolumesAsyncCast()
+    {
+        await foreach (var volume in _lazyVolumesAsync)
+        {
+            yield return volume;
+        }
+    }
+
+    public async ValueTask<IAsyncReader> ExtractAllEntriesAsync()
+    {
+        if (!await IsSolidAsync() && Type != ArchiveType.SevenZip)
+        {
+            throw new SharpCompressException(
+                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
+            );
+        }
+        await EnsureEntriesLoadedAsync();
+        return await CreateReaderForSolidExtractionAsync();
+    }
+
+    public virtual ValueTask<bool> IsSolidAsync() => new(false);
+
+    public async ValueTask<bool> IsCompleteAsync()
+    {
+        await EnsureEntriesLoadedAsync();
+        return await EntriesAsync.AllAsync(x => x.IsComplete);
+    }
+
+    public async ValueTask<long> TotalSizeAsync() =>
+        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
+
+    public async ValueTask<long> TotalUncompressedSizeAsync() =>
+        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.Size);
+
+    public ValueTask<bool> IsEncryptedAsync() => new(IsEncrypted);
+
+    #endregion
+}

src/SharpCompress/Archives/AbstractArchive.cs

@@ -7,7 +7,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
+public abstract partial class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     where TEntry : IArchiveEntry
     where TVolume : IVolume
 {
@@ -16,6 +16,10 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     private bool _disposed;
     private readonly SourceStream? _sourceStream;
 
+    // Async fields - kept in original file per refactoring rules
+    private readonly LazyAsyncReadOnlyCollection<TVolume> _lazyVolumesAsync;
+    private readonly LazyAsyncReadOnlyCollection<TEntry> _lazyEntriesAsync;
+
     protected ReaderOptions ReaderOptions { get; }
 
     internal AbstractArchive(ArchiveType type, SourceStream sourceStream)
@@ -77,16 +81,6 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
     protected virtual IAsyncEnumerable<TVolume> LoadVolumesAsync(SourceStream sourceStream) =>
         LoadVolumes(sourceStream).ToAsyncEnumerable();
 
-    protected virtual async IAsyncEnumerable<TEntry> LoadEntriesAsync(
-        IAsyncEnumerable<TVolume> volumes
-    )
-    {
-        foreach (var item in LoadEntries(await volumes.ToListAsync()))
-        {
-            yield return item;
-        }
-    }
-
     IEnumerable<IArchiveEntry> IArchive.Entries => Entries.Cast<IArchiveEntry>();
 
     IEnumerable<IVolume> IArchive.Volumes => _lazyVolumes.Cast<IVolume>();
@@ -156,87 +150,4 @@ public abstract class AbstractArchive<TEntry, TVolume> : IArchive, IAsyncArchive
             return Entries.All(x => x.IsComplete);
         }
     }
-
-    #region Async Support
-
-    private readonly LazyAsyncReadOnlyCollection<TVolume> _lazyVolumesAsync;
-    private readonly LazyAsyncReadOnlyCollection<TEntry> _lazyEntriesAsync;
-
-    public virtual async ValueTask DisposeAsync()
-    {
-        if (!_disposed)
-        {
-            await foreach (var v in _lazyVolumesAsync)
-            {
-                v.Dispose();
-            }
-            foreach (var v in _lazyEntriesAsync.GetLoaded().Cast<Entry>())
-            {
-                v.Close();
-            }
-            _sourceStream?.Dispose();
-
-            _disposed = true;
-        }
-    }
-
-    private async ValueTask EnsureEntriesLoadedAsync()
-    {
-        await _lazyEntriesAsync.EnsureFullyLoaded();
-        await _lazyVolumesAsync.EnsureFullyLoaded();
-    }
-
-    public virtual IAsyncEnumerable<TEntry> EntriesAsync => _lazyEntriesAsync;
-
-    private async IAsyncEnumerable<IArchiveEntry> EntriesAsyncCast()
-    {
-        await foreach (var entry in EntriesAsync)
-        {
-            yield return entry;
-        }
-    }
-
-    IAsyncEnumerable<IArchiveEntry> IAsyncArchive.EntriesAsync => EntriesAsyncCast();
-
-    IAsyncEnumerable<IVolume> IAsyncArchive.VolumesAsync => VolumesAsyncCast();
-
-    private async IAsyncEnumerable<IVolume> VolumesAsyncCast()
-    {
-        await foreach (var volume in _lazyVolumesAsync)
-        {
-            yield return volume;
-        }
-    }
-
-    public IAsyncEnumerable<TVolume> VolumesAsync => _lazyVolumesAsync;
-
-    public async ValueTask<IAsyncReader> ExtractAllEntriesAsync()
-    {
-        if (!await IsSolidAsync() && Type != ArchiveType.SevenZip)
-        {
-            throw new SharpCompressException(
-                "ExtractAllEntries can only be used on solid archives or 7Zip archives (which require random access)."
-            );
-        }
-        await EnsureEntriesLoadedAsync();
-        return await CreateReaderForSolidExtractionAsync();
-    }
-
-    public virtual ValueTask<bool> IsSolidAsync() => new(false);
-
-    public async ValueTask<bool> IsCompleteAsync()
-    {
-        await EnsureEntriesLoadedAsync();
-        return await EntriesAsync.AllAsync(x => x.IsComplete);
-    }
-
-    public async ValueTask<long> TotalSizeAsync() =>
-        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.CompressedSize);
-
-    public async ValueTask<long> TotalUncompressedSizeAsync() =>
-        await EntriesAsync.AggregateAsync(0L, (total, cf) => total + cf.Size);
-
-    public ValueTask<bool> IsEncryptedAsync() => new(IsEncrypted);
-
-    #endregion
 }

src/SharpCompress/Archives/AbstractWritableArchive.Async.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Writers;
+
+namespace SharpCompress.Archives;
+
+public abstract partial class AbstractWritableArchive<TEntry, TVolume>
+    where TEntry : IArchiveEntry
+    where TVolume : IVolume
+{
+    // Async property moved from main file
+    private IAsyncEnumerable<TEntry> OldEntriesAsync =>
+        base.EntriesAsync.Where(x => !removedEntries.Contains(x));
+
+    private async ValueTask RebuildModifiedCollectionAsync()
+    {
+        if (pauseRebuilding)
+        {
+            return;
+        }
+        hasModifications = true;
+        newEntries.RemoveAll(v => removedEntries.Contains(v));
+        modifiedEntries.Clear();
+        await foreach (var entry in OldEntriesAsync)
+        {
+            modifiedEntries.Add(entry);
+        }
+        modifiedEntries.AddRange(newEntries);
+    }
+
+    public async ValueTask RemoveEntryAsync(TEntry entry)
+    {
+        if (!removedEntries.Contains(entry))
+        {
+            removedEntries.Add(entry);
+            await RebuildModifiedCollectionAsync();
+        }
+    }
+
+    private async ValueTask<bool> DoesKeyMatchExistingAsync(
+        string key,
+        CancellationToken cancellationToken
+    )
+    {
+        await foreach (
+            var entry in EntriesAsync.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            var path = entry.Key;
+            if (path is null)
+            {
+                continue;
+            }
+            var p = path.Replace('/', '\\');
+            if (p.Length > 0 && p[0] == '\\')
+            {
+                p = p.Substring(1);
+            }
+            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+        }
+        return false;
+    }
+
+    public async ValueTask<TEntry> AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateEntry(key, source, size, modified, closeStream);
+        newEntries.Add(entry);
+        await RebuildModifiedCollectionAsync();
+        return entry;
+    }
+
+    public async ValueTask<TEntry> AddDirectoryEntryAsync(
+        string key,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateDirectoryEntry(key, modified);
+        newEntries.Add(entry);
+        await RebuildModifiedCollectionAsync();
+        return entry;
+    }
+
+    public async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        //reset streams of new entries
+        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
+        await SaveToAsync(stream, options, OldEntriesAsync, newEntries, cancellationToken)
+            .ConfigureAwait(false);
+    }
+}

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -10,7 +10,7 @@ using SharpCompress.Writers;
 
 namespace SharpCompress.Archives;
 
-public abstract class AbstractWritableArchive<TEntry, TVolume>
+public abstract partial class AbstractWritableArchive<TEntry, TVolume>
     : AbstractArchive<TEntry, TVolume>,
         IWritableArchive,
         IWritableAsyncArchive
@@ -73,25 +73,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         modifiedEntries.AddRange(OldEntries.Concat(newEntries));
     }
 
-    private async ValueTask RebuildModifiedCollectionAsync()
-    {
-        if (pauseRebuilding)
-        {
-            return;
-        }
-        hasModifications = true;
-        newEntries.RemoveAll(v => removedEntries.Contains(v));
-        modifiedEntries.Clear();
-        await foreach (var entry in OldEntriesAsync)
-        {
-            modifiedEntries.Add(entry);
-        }
-        modifiedEntries.AddRange(newEntries);
-    }
-
     private IEnumerable<TEntry> OldEntries => base.Entries.Where(x => !removedEntries.Contains(x));
-    private IAsyncEnumerable<TEntry> OldEntriesAsync =>
-        base.EntriesAsync.Where(x => !removedEntries.Contains(x));
 
     public void RemoveEntry(TEntry entry)
     {
@@ -102,20 +84,8 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         }
     }
 
-    public async ValueTask RemoveEntryAsync(TEntry entry)
-    {
-        if (!removedEntries.Contains(entry))
-        {
-            removedEntries.Add(entry);
-            await RebuildModifiedCollectionAsync();
-        }
-    }
-
     void IWritableArchive.RemoveEntry(IArchiveEntry entry) => RemoveEntry((TEntry)entry);
 
-    ValueTask IWritableAsyncArchive.RemoveEntryAsync(IArchiveEntry entry) =>
-        RemoveEntryAsync((TEntry)entry);
-
     public TEntry AddEntry(string key, Stream source, long size = 0, DateTime? modified = null) =>
         AddEntry(key, source, false, size, modified);
 
@@ -170,29 +140,8 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return false;
     }
 
-    private async ValueTask<bool> DoesKeyMatchExistingAsync(
-        string key,
-        CancellationToken cancellationToken
-    )
-    {
-        await foreach (
-            var entry in EntriesAsync.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            var path = entry.Key;
-            if (path is null)
-            {
-                continue;
-            }
-            var p = path.Replace('/', '\\');
-            if (p.Length > 0 && p[0] == '\\')
-            {
-                p = p.Substring(1);
-            }
-            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
-        }
-        return false;
-    }
+    ValueTask IWritableAsyncArchive.RemoveEntryAsync(IArchiveEntry entry) =>
+        RemoveEntryAsync((TEntry)entry);
 
     async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddEntryAsync(
         string key,
@@ -209,29 +158,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         CancellationToken cancellationToken
     ) => await AddDirectoryEntryAsync(key, modified, cancellationToken);
 
-    public async ValueTask<TEntry> AddEntryAsync(
-        string key,
-        Stream source,
-        bool closeStream,
-        long size = 0,
-        DateTime? modified = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateEntry(key, source, size, modified, closeStream);
-        newEntries.Add(entry);
-        await RebuildModifiedCollectionAsync();
-        return entry;
-    }
-
     public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
     {
         if (key.Length > 0 && key[0] is '/' or '\\')
@@ -248,26 +174,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return entry;
     }
 
-    public async ValueTask<TEntry> AddDirectoryEntryAsync(
-        string key,
-        DateTime? modified = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (key.Length > 0 && key[0] is '/' or '\\')
-        {
-            key = key.Substring(1);
-        }
-        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
-        {
-            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
-        }
-        var entry = CreateDirectoryEntry(key, modified);
-        newEntries.Add(entry);
-        await RebuildModifiedCollectionAsync();
-        return entry;
-    }
-
     public void SaveTo(Stream stream, WriterOptions options)
     {
         //reset streams of new entries
@@ -275,18 +181,6 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         SaveTo(stream, options, OldEntries, newEntries);
     }
 
-    public async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        CancellationToken cancellationToken = default
-    )
-    {
-        //reset streams of new entries
-        newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-        await SaveToAsync(stream, options, OldEntriesAsync, newEntries, cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     protected TEntry CreateEntry(
         string key,
         Stream source,

src/SharpCompress/Archives/ArchiveFactory.Async.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Factories;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives;
+
+public static partial class ArchiveFactory
+{
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        readerOptions ??= new ReaderOptions();
+        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken);
+        return factory.OpenAsyncArchive(stream, readerOptions);
+    }
+
+    public static ValueTask<IAsyncArchive> OpenAsyncArchive(
+        string filePath,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenAsyncArchive(new FileInfo(filePath), options, cancellationToken);
+    }
+
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        FileInfo fileInfo,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken);
+        return factory.OpenAsyncArchive(fileInfo, options);
+    }
+
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        IEnumerable<FileInfo> fileInfos,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        fileInfos.NotNull(nameof(fileInfos));
+        var filesArray = fileInfos.ToArray();
+        if (filesArray.Length == 0)
+        {
+            throw new InvalidOperationException("No files to open");
+        }
+
+        var fileInfo = filesArray[0];
+        if (filesArray.Length == 1)
+        {
+            return await OpenAsyncArchive(fileInfo, options, cancellationToken);
+        }
+
+        fileInfo.NotNull(nameof(fileInfo));
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken);
+        return factory.OpenAsyncArchive(filesArray, options, cancellationToken);
+    }
+
+    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
+        IEnumerable<Stream> streams,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        streams.NotNull(nameof(streams));
+        var streamsArray = streams.ToArray();
+        if (streamsArray.Length == 0)
+        {
+            throw new InvalidOperationException("No streams");
+        }
+
+        var firstStream = streamsArray[0];
+        if (streamsArray.Length == 1)
+        {
+            return await OpenAsyncArchive(firstStream, options, cancellationToken);
+        }
+
+        firstStream.NotNull(nameof(firstStream));
+        options ??= new ReaderOptions();
+
+        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken);
+        return factory.OpenAsyncArchive(streamsArray, options);
+    }
+
+    public static ValueTask<T> FindFactoryAsync<T>(
+        string path,
+        CancellationToken cancellationToken = default
+    )
+        where T : IFactory
+    {
+        path.NotNullOrEmpty(nameof(path));
+        return FindFactoryAsync<T>(new FileInfo(path), cancellationToken);
+    }
+
+    private static async ValueTask<T> FindFactoryAsync<T>(
+        FileInfo finfo,
+        CancellationToken cancellationToken
+    )
+        where T : IFactory
+    {
+        finfo.NotNull(nameof(finfo));
+        using Stream stream = finfo.OpenRead();
+        return await FindFactoryAsync<T>(stream, cancellationToken);
+    }
+
+    private static async ValueTask<T> FindFactoryAsync<T>(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+        where T : IFactory
+    {
+        stream.NotNull(nameof(stream));
+        if (!stream.CanRead || !stream.CanSeek)
+        {
+            throw new ArgumentException("Stream should be readable and seekable");
+        }
+
+        var factories = Factory.Factories.OfType<T>();
+
+        var startPosition = stream.Position;
+
+        foreach (var factory in factories)
+        {
+            stream.Seek(startPosition, SeekOrigin.Begin);
+
+            if (await factory.IsArchiveAsync(stream, cancellationToken: cancellationToken))
+            {
+                stream.Seek(startPosition, SeekOrigin.Begin);
+
+                return factory;
+            }
+        }
+
+        var extensions = string.Join(", ", factories.Select(item => item.Name));
+
+        throw new InvalidOperationException(
+            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
+        );
+    }
+}

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -11,7 +11,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives;
 
-public static class ArchiveFactory
+public static partial class ArchiveFactory
 {
     public static IArchive OpenArchive(Stream stream, ReaderOptions? readerOptions = null)
     {
@@ -20,18 +20,6 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(stream).OpenArchive(stream, readerOptions);
     }
 
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        Stream stream,
-        ReaderOptions? readerOptions = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        readerOptions ??= new ReaderOptions();
-        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
-        var factory = await FindFactoryAsync<IArchiveFactory>(stream, cancellationToken);
-        return factory.OpenAsyncArchive(stream, readerOptions);
-    }
-
     public static IWritableArchive CreateArchive(ArchiveType type)
     {
         var factory = Factory
@@ -52,16 +40,6 @@ public static class ArchiveFactory
         return OpenArchive(new FileInfo(filePath), options);
     }
 
-    public static ValueTask<IAsyncArchive> OpenAsyncArchive(
-        string filePath,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenAsyncArchive(new FileInfo(filePath), options, cancellationToken);
-    }
-
     public static IArchive OpenArchive(FileInfo fileInfo, ReaderOptions? options = null)
     {
         options ??= new ReaderOptions { LeaveStreamOpen = false };
@@ -69,18 +47,6 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(fileInfo).OpenArchive(fileInfo, options);
     }
 
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        FileInfo fileInfo,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        var factory = await FindFactoryAsync<IArchiveFactory>(fileInfo, cancellationToken);
-        return factory.OpenAsyncArchive(fileInfo, options);
-    }
-
     public static IArchive OpenArchive(
         IEnumerable<FileInfo> fileInfos,
         ReaderOptions? options = null
@@ -105,32 +71,6 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(fileInfo).OpenArchive(filesArray, options);
     }
 
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        IEnumerable<FileInfo> fileInfos,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        fileInfos.NotNull(nameof(fileInfos));
-        var filesArray = fileInfos.ToArray();
-        if (filesArray.Length == 0)
-        {
-            throw new InvalidOperationException("No files to open");
-        }
-
-        var fileInfo = filesArray[0];
-        if (filesArray.Length == 1)
-        {
-            return await OpenAsyncArchive(fileInfo, options, cancellationToken);
-        }
-
-        fileInfo.NotNull(nameof(fileInfo));
-        options ??= new ReaderOptions { LeaveStreamOpen = false };
-
-        var factory = await FindFactoryAsync<IMultiArchiveFactory>(fileInfo, cancellationToken);
-        return factory.OpenAsyncArchive(filesArray, options, cancellationToken);
-    }
-
     public static IArchive OpenArchive(IEnumerable<Stream> streams, ReaderOptions? options = null)
     {
         streams.NotNull(nameof(streams));
@@ -152,33 +92,6 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(firstStream).OpenArchive(streamsArray, options);
     }
 
-    public static async ValueTask<IAsyncArchive> OpenAsyncArchive(
-        IEnumerable<Stream> streams,
-        ReaderOptions? options = null,
-        CancellationToken cancellationToken = default
-    )
-    {
-        cancellationToken.ThrowIfCancellationRequested();
-        streams.NotNull(nameof(streams));
-        var streamsArray = streams.ToArray();
-        if (streamsArray.Length == 0)
-        {
-            throw new InvalidOperationException("No streams");
-        }
-
-        var firstStream = streamsArray[0];
-        if (streamsArray.Length == 1)
-        {
-            return await OpenAsyncArchive(firstStream, options, cancellationToken);
-        }
-
-        firstStream.NotNull(nameof(firstStream));
-        options ??= new ReaderOptions();
-
-        var factory = await FindFactoryAsync<IMultiArchiveFactory>(firstStream, cancellationToken);
-        return factory.OpenAsyncArchive(streamsArray, options);
-    }
-
     public static void WriteToDirectory(
         string sourceArchive,
         string destinationDirectory,
@@ -197,16 +110,6 @@ public static class ArchiveFactory
         return FindFactory<T>(stream);
     }
 
-    public static ValueTask<T> FindFactoryAsync<T>(
-        string path,
-        CancellationToken cancellationToken = default
-    )
-        where T : IFactory
-    {
-        path.NotNullOrEmpty(nameof(path));
-        return FindFactoryAsync<T>(new FileInfo(path), cancellationToken);
-    }
-
     public static T FindFactory<T>(FileInfo finfo)
         where T : IFactory
     {
@@ -247,51 +150,7 @@ public static class ArchiveFactory
         );
     }
 
-    private static async ValueTask<T> FindFactoryAsync<T>(
-        FileInfo finfo,
-        CancellationToken cancellationToken
-    )
-        where T : IFactory
-    {
-        finfo.NotNull(nameof(finfo));
-        using Stream stream = finfo.OpenRead();
-        return await FindFactoryAsync<T>(stream, cancellationToken);
-    }
-
-    private static async ValueTask<T> FindFactoryAsync<T>(
-        Stream stream,
-        CancellationToken cancellationToken
-    )
-        where T : IFactory
-    {
-        stream.NotNull(nameof(stream));
-        if (!stream.CanRead || !stream.CanSeek)
-        {
-            throw new ArgumentException("Stream should be readable and seekable");
-        }
-
-        var factories = Factory.Factories.OfType<T>();
-
-        var startPosition = stream.Position;
-
-        foreach (var factory in factories)
-        {
-            stream.Seek(startPosition, SeekOrigin.Begin);
-
-            if (await factory.IsArchiveAsync(stream, cancellationToken: cancellationToken))
-            {
-                stream.Seek(startPosition, SeekOrigin.Begin);
-
-                return factory;
-            }
-        }
-
-        var extensions = string.Join(", ", factories.Select(item => item.Name));
-
-        throw new InvalidOperationException(
-            $"Cannot determine compressed stream type. Supported Archive Formats: {extensions}"
-        );
-    }
+    // Async methods moved to ArchiveFactory.Async.cs
 
     public static bool IsArchive(
         string filePath,

src/SharpCompress/Archives/ArchiveVolumeFactory.cs

@@ -13,6 +13,7 @@ internal abstract class ArchiveVolumeFactory
         //split 001, 002 ...
         var m = Regex.Match(part1.Name, @"^(.*\.)([0-9]+)$", RegexOptions.IgnoreCase);
         if (m.Success)
+        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -22,9 +23,13 @@ internal abstract class ArchiveVolumeFactory
                     )
                 )
             );
+        }
 
         if (item != null && item.Exists)
+        {
             return item;
+        }
+
         return null;
     }
 }

src/SharpCompress/Archives/GZip/GZipArchive.Async.cs

@@ -0,0 +1,86 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.GZip;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.GZip;
+using SharpCompress.Writers;
+using SharpCompress.Writers.GZip;
+
+namespace SharpCompress.Archives.GZip;
+
+public partial class GZipArchive
+{
+    public ValueTask SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
+        SaveToAsync(new FileInfo(filePath), cancellationToken);
+
+    public async ValueTask SaveToAsync(
+        FileInfo fileInfo,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    protected override async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IAsyncEnumerable<GZipArchiveEntry> oldEntries,
+        IEnumerable<GZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (Entries.Count > 1)
+        {
+            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
+        }
+        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+        await foreach (
+            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            if (!entry.IsDirectory)
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+        foreach (var entry in newEntries.Where(x => !x.IsDirectory))
+        {
+            using var entryStream = entry.OpenEntryStream();
+            await writer
+                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
+    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return new((IAsyncReader)GZipReader.OpenReader(stream));
+    }
+
+    protected override async IAsyncEnumerable<GZipArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<GZipVolume> volumes
+    )
+    {
+        var stream = (await volumes.SingleAsync()).Stream;
+        yield return new GZipArchiveEntry(
+            this,
+            await GZipFilePart.CreateAsync(stream, ReaderOptions.ArchiveEncoding)
+        );
+    }
+}

src/SharpCompress/Archives/GZip/GZipArchive.Factory.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -180,18 +181,21 @@ public partial class GZipArchive
         CancellationToken cancellationToken = default
     )
     {
-        byte[] header = new byte[10];
-
-        if (!await stream.ReadFullyAsync(header, cancellationToken).ConfigureAwait(false))
+        var header = ArrayPool<byte>.Shared.Rent(10);
+        try
         {
-            return false;
-        }
+            await stream.ReadFullyAsync(header, 0, 10, cancellationToken).ConfigureAwait(false);
 
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+            {
+                return false;
+            }
+
+            return true;
+        }
+        finally
         {
-            return false;
+            ArrayPool<byte>.Shared.Return(header);
         }
-
-        return true;
     }
 }

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -36,19 +36,6 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         SaveTo(stream, new WriterOptions(CompressionType.GZip));
     }
 
-    public ValueTask SaveToAsync(string filePath, CancellationToken cancellationToken = default) =>
-        SaveToAsync(new FileInfo(filePath), cancellationToken);
-
-    public async ValueTask SaveToAsync(
-        FileInfo fileInfo,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
-        await SaveToAsync(stream, new WriterOptions(CompressionType.GZip), cancellationToken)
-            .ConfigureAwait(false);
-    }
-
     protected override GZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -92,44 +79,6 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         }
     }
 
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<GZipArchiveEntry> oldEntries,
-        IEnumerable<GZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (Entries.Count > 1)
-        {
-            throw new InvalidFormatException("Only one entry is allowed in a GZip Archive");
-        }
-        using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
-        await foreach (
-            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            if (!entry.IsDirectory)
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-        foreach (var entry in newEntries.Where(x => !x.IsDirectory))
-        {
-            using var entryStream = entry.OpenEntryStream();
-            await writer
-                .WriteAsync(entry.Key.NotNull("Entry Key is null"), entryStream, cancellationToken)
-                .ConfigureAwait(false);
-        }
-    }
-
     protected override IEnumerable<GZipArchiveEntry> LoadEntries(IEnumerable<GZipVolume> volumes)
     {
         var stream = volumes.Single().Stream;
@@ -139,28 +88,10 @@ public partial class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZi
         );
     }
 
-    protected override async IAsyncEnumerable<GZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<GZipVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        yield return new GZipArchiveEntry(
-            this,
-            await GZipFilePart.CreateAsync(stream, ReaderOptions.ArchiveEncoding)
-        );
-    }
-
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
         return GZipReader.OpenReader(stream);
     }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)GZipReader.OpenReader(stream));
-    }
 }

src/SharpCompress/Archives/IAsyncArchiveExtensions.cs

@@ -20,7 +20,7 @@ public static class IAsyncArchiveExtensions
         /// <param name="options">Extraction options.</param>
         /// <param name="progress">Optional progress reporter for tracking extraction progress.</param>
         /// <param name="cancellationToken">Optional cancellation token.</param>
-        public async Task WriteToDirectoryAsync(
+        public async ValueTask WriteToDirectoryAsync(
             string destinationDirectory,
             ExtractionOptions? options = null,
             IProgress<ProgressReport>? progress = null,
@@ -47,7 +47,7 @@ public static class IAsyncArchiveExtensions
             }
         }
 
-        private async Task WriteToDirectoryAsyncInternal(
+        private async ValueTask WriteToDirectoryAsyncInternal(
             string destinationDirectory,
             ExtractionOptions? options,
             IProgress<ProgressReport>? progress,

src/SharpCompress/Archives/Rar/RarArchive.Async.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Archives.Rar;
+using SharpCompress.Common;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Rar;
+
+namespace SharpCompress.Archives.Rar;
+
+public partial class RarArchive
+{
+    public override async ValueTask DisposeAsync()
+    {
+        if (!_disposed)
+        {
+            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
+            {
+                unpackV1.Dispose();
+            }
+
+            _disposed = true;
+            await base.DisposeAsync();
+        }
+    }
+
+    protected override async ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
+    {
+        if (await this.IsMultipartVolumeAsync())
+        {
+            var streams = await VolumesAsync
+                .Select(volume =>
+                {
+                    volume.Stream.Position = 0;
+                    return volume.Stream;
+                })
+                .ToListAsync();
+            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
+        }
+
+        var stream = (await VolumesAsync.FirstAsync()).Stream;
+        stream.Position = 0;
+        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
+    }
+
+    public override async ValueTask<bool> IsSolidAsync() =>
+        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsSolidArchiveAsync();
+}

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -24,7 +24,10 @@ public interface IRarArchive : IArchive, IRarArchiveCommon { }
 
 public interface IRarAsyncArchive : IAsyncArchive, IRarArchiveCommon { }
 
-public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, IRarArchive, IRarAsyncArchive
+public partial class RarArchive
+    : AbstractArchive<RarArchiveEntry, RarVolume>,
+        IRarArchive,
+        IRarAsyncArchive
 {
     private bool _disposed;
     internal Lazy<IRarUnpack> UnpackV2017 { get; } =
@@ -48,24 +51,13 @@ public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, I
         }
     }
 
-    public override async ValueTask DisposeAsync()
-    {
-        if (!_disposed)
-        {
-            if (UnpackV1.IsValueCreated && UnpackV1.Value is IDisposable unpackV1)
-            {
-                unpackV1.Dispose();
-            }
-
-            _disposed = true;
-            await base.DisposeAsync();
-        }
-    }
-
     protected override IEnumerable<RarArchiveEntry> LoadEntries(IEnumerable<RarVolume> volumes) =>
         RarArchiveEntryFactory.GetEntries(this, volumes, ReaderOptions);
-    protected override IAsyncEnumerable<RarArchiveEntry> LoadEntriesAsync(IAsyncEnumerable<RarVolume> volumes) =>
-        RarArchiveEntryFactory.GetEntriesAsync(this, volumes, ReaderOptions);
+
+    // Simple async property - kept in original file
+    protected override IAsyncEnumerable<RarArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<RarVolume> volumes
+    ) => RarArchiveEntryFactory.GetEntriesAsync(this, volumes, ReaderOptions);
 
     protected override IEnumerable<RarVolume> LoadVolumes(SourceStream sourceStream)
     {
@@ -88,24 +80,6 @@ public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, I
         return new StreamRarArchiveVolume(sourceStream, ReaderOptions, i++).AsEnumerable();
     }
 
-
-    protected override async ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        if (await this.IsMultipartVolumeAsync())
-        {
-            var streams = await VolumesAsync.Select(volume =>
-            {
-                volume.Stream.Position = 0;
-                return volume.Stream;
-            }).ToListAsync();
-            return (RarReader)RarReader.OpenReader(streams, ReaderOptions);
-        }
-
-        var stream = (await VolumesAsync.FirstAsync()).Stream;
-        stream.Position = 0;
-        return (RarReader)RarReader.OpenReader(stream, ReaderOptions);
-    }
-
     protected override IReader CreateReaderForSolidExtraction()
     {
         if (this.IsMultipartVolume())
@@ -125,9 +99,6 @@ public partial class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>, I
 
     public override bool IsSolid => Volumes.First().IsSolidArchive;
 
-    public override async ValueTask<bool> IsSolidAsync() =>
-        await (await VolumesAsync.CastAsync<RarVolume>().FirstAsync()).IsSolidArchiveAsync();
-
     public override bool IsEncrypted => Entries.First(x => !x.IsDirectory).IsEncrypted;
 
     public virtual int MinVersion => Volumes.First().MinVersion;

src/SharpCompress/Archives/Rar/RarArchiveEntry.Async.cs

@@ -0,0 +1,43 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Rar;
+using SharpCompress.Common.Rar.Headers;
+using SharpCompress.Compressors.Rar;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.Rar;
+
+public partial class RarArchiveEntry
+{
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        RarStream stream;
+        if (IsRarV3)
+        {
+            stream = new RarStream(
+                archive.UnpackV1.Value,
+                FileHeader,
+                await MultiVolumeReadOnlyAsyncStream.Create(
+                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
+                )
+            );
+        }
+        else
+        {
+            stream = new RarStream(
+                archive.UnpackV2017.Value,
+                FileHeader,
+                await MultiVolumeReadOnlyAsyncStream.Create(
+                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
+                )
+            );
+        }
+
+        await stream.InitializeAsync(cancellationToken);
+        return stream;
+    }
+}

src/SharpCompress/Archives/Rar/RarArchiveEntry.cs

@@ -12,7 +12,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Archives.Rar;
 
-public class RarArchiveEntry : RarEntry, IArchiveEntry
+public partial class RarArchiveEntry : RarEntry, IArchiveEntry
 {
     private readonly ICollection<RarFilePart> parts;
     private readonly RarArchive archive;
@@ -92,36 +92,6 @@ public class RarArchiveEntry : RarEntry, IArchiveEntry
         return stream;
     }
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        RarStream stream;
-        if (IsRarV3)
-        {
-            stream = new RarStream(
-                archive.UnpackV1.Value,
-                FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
-            );
-        }
-        else
-        {
-            stream = new RarStream(
-                archive.UnpackV2017.Value,
-                FileHeader,
-                await MultiVolumeReadOnlyAsyncStream.Create(
-                    Parts.ToAsyncEnumerable().CastAsync<RarFilePart>()
-                )
-            );
-        }
-
-        await stream.InitializeAsync(cancellationToken);
-        return stream;
-    }
-
     public bool IsComplete
     {
         get

src/SharpCompress/Archives/Rar/RarArchiveEntryFactory.cs

@@ -17,7 +17,9 @@ internal static class RarArchiveEntryFactory
         }
     }
 
-    private static async IAsyncEnumerable<RarFilePart> GetFilePartsAsync(IAsyncEnumerable<RarVolume> parts)
+    private static async IAsyncEnumerable<RarFilePart> GetFilePartsAsync(
+        IAsyncEnumerable<RarVolume> parts
+    )
     {
         await foreach (var rarPart in parts)
         {

src/SharpCompress/Archives/Rar/RarArchiveVolumeFactory.cs

@@ -13,6 +13,7 @@ internal static class RarArchiveVolumeFactory
         //new style rar - ..part1 | /part01 | part001 ....
         var m = Regex.Match(part1.Name, @"^(.*\.part)([0-9]+)(\.rar)$", RegexOptions.IgnoreCase);
         if (m.Success)
+        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -23,11 +24,13 @@ internal static class RarArchiveVolumeFactory
                     )
                 )
             );
+        }
         else
         {
             //old style - ...rar, .r00, .r01 ...
             m = Regex.Match(part1.Name, @"^(.*\.)([r-z{])(ar|[0-9]+)$", RegexOptions.IgnoreCase);
             if (m.Success)
+            {
                 item = new FileInfo(
                     Path.Combine(
                         part1.DirectoryName!,
@@ -40,12 +43,17 @@ internal static class RarArchiveVolumeFactory
                         )
                     )
                 );
+            }
             else //split .001, .002 ....
+            {
                 return ArchiveVolumeFactory.GetFilePart(index, part1);
+            }
         }
 
         if (item != null && item.Exists)
+        {
             return item;
+        }
 
         return null; //no more items
     }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.Async.cs

@@ -0,0 +1,73 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.SevenZip;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Archives.SevenZip;
+
+public partial class SevenZipArchive
+{
+    private async ValueTask LoadFactoryAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_database is null)
+        {
+            stream.Position = 0;
+            var reader = new ArchiveReader();
+            await reader.OpenAsync(
+                stream,
+                lookForHeader: ReaderOptions.LookForHeader,
+                cancellationToken
+            );
+            _database = await reader.ReadDatabaseAsync(
+                new PasswordProvider(ReaderOptions.Password),
+                cancellationToken
+            );
+        }
+    }
+
+    protected override async IAsyncEnumerable<SevenZipArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<SevenZipVolume> volumes
+    )
+    {
+        var stream = (await volumes.SingleAsync()).Stream;
+        await LoadFactoryAsync(stream);
+        if (_database is null)
+        {
+            yield break;
+        }
+        var entries = new SevenZipArchiveEntry[_database._files.Count];
+        for (var i = 0; i < _database._files.Count; i++)
+        {
+            var file = _database._files[i];
+            entries[i] = new SevenZipArchiveEntry(
+                this,
+                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
+            );
+        }
+        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
+        {
+            var isSolid = false;
+            foreach (var entry in group)
+            {
+                entry.IsSolid = isSolid;
+                isSolid = true;
+            }
+        }
+
+        foreach (var entry in entries)
+        {
+            yield return entry;
+        }
+    }
+
+    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync() =>
+        new(new SevenZipReader(ReaderOptions, this));
+}

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -73,41 +73,6 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         }
     }
 
-    protected override async IAsyncEnumerable<SevenZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<SevenZipVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        await LoadFactoryAsync(stream);
-        if (_database is null)
-        {
-            yield break;
-        }
-        var entries = new SevenZipArchiveEntry[_database._files.Count];
-        for (var i = 0; i < _database._files.Count; i++)
-        {
-            var file = _database._files[i];
-            entries[i] = new SevenZipArchiveEntry(
-                this,
-                new SevenZipFilePart(stream, _database, i, file, ReaderOptions.ArchiveEncoding)
-            );
-        }
-        foreach (var group in entries.Where(x => !x.IsDirectory).GroupBy(x => x.FilePart.Folder))
-        {
-            var isSolid = false;
-            foreach (var entry in group)
-            {
-                entry.IsSolid = isSolid;
-                isSolid = true;
-            }
-        }
-
-        foreach (var entry in entries)
-        {
-            yield return entry;
-        }
-    }
-
     private void LoadFactory(Stream stream)
     {
         if (_database is null)
@@ -119,33 +84,9 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
         }
     }
 
-    private async Task LoadFactoryAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (_database is null)
-        {
-            stream.Position = 0;
-            var reader = new ArchiveReader();
-            await reader.OpenAsync(
-                stream,
-                lookForHeader: ReaderOptions.LookForHeader,
-                cancellationToken
-            );
-            _database = await reader.ReadDatabaseAsync(
-                new PasswordProvider(ReaderOptions.Password),
-                cancellationToken
-            );
-        }
-    }
-
     protected override IReader CreateReaderForSolidExtraction() =>
         new SevenZipReader(ReaderOptions, this);
 
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync() =>
-        new(new SevenZipReader(ReaderOptions, this));
-
     public override bool IsSolid =>
         Entries
             .Where(x => !x.IsDirectory)
@@ -253,7 +194,7 @@ public partial class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, Sev
             return Task.CompletedTask;
         }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
+#if !LEGACY_DOTNET
         public override ValueTask<int> ReadAsync(
             Memory<byte> buffer,
             CancellationToken cancellationToken = default

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

@@ -0,0 +1,161 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Tar;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Readers.Tar;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Tar;
+
+namespace SharpCompress.Archives.Tar;
+
+public partial class TarArchive
+{
+    protected override async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IAsyncEnumerable<TarArchiveEntry> oldEntries,
+        IEnumerable<TarArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new TarWriter(stream, new TarWriterOptions(options));
+        await foreach (
+            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        entry.LastModifiedTime,
+                        entry.Size,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+        foreach (var entry in newEntries)
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        entry.LastModifiedTime,
+                        entry.Size,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
+    {
+        var stream = Volumes.Single().Stream;
+        stream.Position = 0;
+        return new((IAsyncReader)TarReader.OpenReader(stream));
+    }
+
+    protected override async IAsyncEnumerable<TarArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<TarVolume> volumes
+    )
+    {
+        var stream = (await volumes.SingleAsync()).Stream;
+        if (stream.CanSeek)
+        {
+            stream.Position = 0;
+        }
+
+        // Always use async header reading in LoadEntriesAsync for consistency
+        {
+            // Use async header reading for async-only streams
+            TarHeader? previousHeader = null;
+            await foreach (
+                var header in TarHeaderFactory.ReadHeaderAsync(
+                    StreamingMode.Seekable,
+                    stream,
+                    ReaderOptions.ArchiveEncoding
+                )
+            )
+            {
+                if (header != null)
+                {
+                    if (header.EntryType == EntryType.LongName)
+                    {
+                        previousHeader = header;
+                    }
+                    else
+                    {
+                        if (previousHeader != null)
+                        {
+                            var entry = new TarArchiveEntry(
+                                this,
+                                new TarFilePart(previousHeader, stream),
+                                CompressionType.None
+                            );
+
+                            var oldStreamPos = stream.Position;
+
+                            using (var entryStream = entry.OpenEntryStream())
+                            {
+                                using var memoryStream = new MemoryStream();
+                                await entryStream.CopyToAsync(memoryStream);
+                                memoryStream.Position = 0;
+                                var bytes = memoryStream.ToArray();
+
+                                header.Name = ReaderOptions
+                                    .ArchiveEncoding.Decode(bytes)
+                                    .TrimNulls();
+                            }
+
+                            stream.Position = oldStreamPos;
+
+                            previousHeader = null;
+                        }
+                        yield return new TarArchiveEntry(
+                            this,
+                            new TarFilePart(header, stream),
+                            CompressionType.None
+                        );
+                    }
+                }
+                else
+                {
+                    throw new IncompleteArchiveException("Failed to read TAR header");
+                }
+            }
+        }
+    }
+}

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

@@ -21,7 +21,7 @@ public partial class TarArchive
     public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
     {
         filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+        return OpenArchive(new FileInfo(filePath), readerOptions);
     }
 
     public static IWritableArchive OpenArchive(
@@ -34,7 +34,7 @@ public partial class TarArchive
             new SourceStream(
                 fileInfo,
                 i => ArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
             )
         );
     }
@@ -50,7 +50,7 @@ public partial class TarArchive
             new SourceStream(
                 files[0],
                 i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
             )
         );
     }

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -91,77 +91,6 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
         }
     }
 
-    protected override async IAsyncEnumerable<TarArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<TarVolume> volumes
-    )
-    {
-        var stream = (await volumes.SingleAsync()).Stream;
-        if (stream.CanSeek)
-        {
-            stream.Position = 0;
-        }
-
-        // Always use async header reading in LoadEntriesAsync for consistency
-        {
-            // Use async header reading for async-only streams
-            TarHeader? previousHeader = null;
-            await foreach (
-                var header in TarHeaderFactory.ReadHeaderAsync(
-                    StreamingMode.Seekable,
-                    stream,
-                    ReaderOptions.ArchiveEncoding
-                )
-            )
-            {
-                if (header != null)
-                {
-                    if (header.EntryType == EntryType.LongName)
-                    {
-                        previousHeader = header;
-                    }
-                    else
-                    {
-                        if (previousHeader != null)
-                        {
-                            var entry = new TarArchiveEntry(
-                                this,
-                                new TarFilePart(previousHeader, stream),
-                                CompressionType.None
-                            );
-
-                            var oldStreamPos = stream.Position;
-
-                            using (var entryStream = entry.OpenEntryStream())
-                            {
-                                using var memoryStream = new MemoryStream();
-                                await entryStream.CopyToAsync(memoryStream);
-                                memoryStream.Position = 0;
-                                var bytes = memoryStream.ToArray();
-
-                                header.Name = ReaderOptions
-                                    .ArchiveEncoding.Decode(bytes)
-                                    .TrimNulls();
-                            }
-
-                            stream.Position = oldStreamPos;
-
-                            previousHeader = null;
-                        }
-                        yield return new TarArchiveEntry(
-                            this,
-                            new TarFilePart(header, stream),
-                            CompressionType.None
-                        );
-                    }
-                }
-                else
-                {
-                    throw new IncompleteArchiveException("Failed to read TAR header");
-                }
-            }
-        }
-    }
-
     protected override TarArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,
@@ -214,82 +143,10 @@ public partial class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVo
         }
     }
 
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<TarArchiveEntry> oldEntries,
-        IEnumerable<TarArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new TarWriter(stream, new TarWriterOptions(options));
-        await foreach (
-            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-        foreach (var entry in newEntries)
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        entry.LastModifiedTime,
-                        entry.Size,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     protected override IReader CreateReaderForSolidExtraction()
     {
         var stream = Volumes.Single().Stream;
         stream.Position = 0;
         return TarReader.OpenReader(stream);
     }
-
-    protected override ValueTask<IAsyncReader> CreateReaderForSolidExtractionAsync()
-    {
-        var stream = Volumes.Single().Stream;
-        stream.Position = 0;
-        return new((IAsyncReader)TarReader.OpenReader(stream));
-    }
 }

src/SharpCompress/Archives/Zip/ZipArchive.Async.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using SharpCompress.Common.Zip;
+using SharpCompress.Common.Zip.Headers;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+using SharpCompress.Writers;
+using SharpCompress.Writers.Zip;
+
+namespace SharpCompress.Archives.Zip;
+
+public partial class ZipArchive
+{
+    protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntriesAsync(
+        IAsyncEnumerable<ZipVolume> volumes
+    )
+    {
+        var vols = await volumes.ToListAsync();
+        var volsArray = vols.ToArray();
+
+        await foreach (
+            var h in headerFactory.NotNull().ReadSeekableHeaderAsync(volsArray.Last().Stream)
+        )
+        {
+            if (h != null)
+            {
+                switch (h.ZipHeaderType)
+                {
+                    case ZipHeaderType.DirectoryEntry:
+                        {
+                            var deh = (DirectoryEntryHeader)h;
+                            Stream s;
+                            if (
+                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
+                                > volsArray[deh.DiskNumberStart].Stream.Length
+                            )
+                            {
+                                var v = volsArray.Skip(deh.DiskNumberStart).ToArray();
+                                s = new SourceStream(
+                                    v[0].Stream,
+                                    i => i < v.Length ? v[i].Stream : null,
+                                    new ReaderOptions() { LeaveStreamOpen = true }
+                                );
+                            }
+                            else
+                            {
+                                s = volsArray[deh.DiskNumberStart].Stream;
+                            }
+
+                            yield return new ZipArchiveEntry(
+                                this,
+                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
+                            );
+                        }
+                        break;
+                    case ZipHeaderType.DirectoryEnd:
+                    {
+                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
+                        volsArray.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
+                        yield break;
+                    }
+                }
+            }
+        }
+    }
+
+    protected override async ValueTask SaveToAsync(
+        Stream stream,
+        WriterOptions options,
+        IAsyncEnumerable<ZipArchiveEntry> oldEntries,
+        IEnumerable<ZipArchiveEntry> newEntries,
+        CancellationToken cancellationToken = default
+    )
+    {
+        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
+        await foreach (
+            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+        foreach (var entry in newEntries)
+        {
+            if (entry.IsDirectory)
+            {
+                await writer
+                    .WriteDirectoryAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entry.LastModifiedTime,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+            else
+            {
+                using var entryStream = entry.OpenEntryStream();
+                await writer
+                    .WriteAsync(
+                        entry.Key.NotNull("Entry Key is null"),
+                        entryStream,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+}

src/SharpCompress/Archives/Zip/ZipArchive.Factory.cs

@@ -21,7 +21,7 @@ public partial class ZipArchive
     public static IWritableArchive OpenArchive(string filePath, ReaderOptions? readerOptions = null)
     {
         filePath.NotNullOrEmpty(nameof(filePath));
-        return OpenArchive(new FileInfo(filePath), readerOptions ?? new ReaderOptions());
+        return OpenArchive(new FileInfo(filePath), readerOptions);
     }
 
     public static IWritableArchive OpenArchive(
@@ -34,7 +34,7 @@ public partial class ZipArchive
             new SourceStream(
                 fileInfo,
                 i => ZipArchiveVolumeFactory.GetFilePart(i, fileInfo),
-                readerOptions ?? new ReaderOptions()
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
             )
         );
     }
@@ -50,7 +50,7 @@ public partial class ZipArchive
             new SourceStream(
                 files[0],
                 i => i < files.Length ? files[i] : null,
-                readerOptions ?? new ReaderOptions()
+                readerOptions ?? new ReaderOptions() { LeaveStreamOpen = false }
             )
         );
     }
@@ -210,7 +210,7 @@ public partial class ZipArchive
                 if (stream.CanSeek)
                 {
                     var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    var x = z.ReadSeekableHeader(stream, useSync: true).FirstOrDefault();
+                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
                     return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
                 }
                 else

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -41,9 +41,16 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         var idx = 0;
         if (streams.Count() > 1)
         {
-            streams[1].Position += 4;
-            var isZip = IsZipFile(streams[1], ReaderOptions.Password, ReaderOptions.BufferSize);
-            streams[1].Position -= 4;
+            //check if second stream is zip header without changing position
+            var headerProbeStream = streams[1];
+            var startPosition = headerProbeStream.Position;
+            headerProbeStream.Position = startPosition + 4;
+            var isZip = IsZipFile(
+                headerProbeStream,
+                ReaderOptions.Password,
+                ReaderOptions.BufferSize
+            );
+            headerProbeStream.Position = startPosition;
             if (isZip)
             {
                 stream.IsVolumes = true;
@@ -62,9 +69,7 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
     protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
     {
         var vols = volumes.ToArray();
-        foreach (
-            var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream, useSync: true)
-        )
+        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
         {
             if (h != null)
             {
@@ -108,59 +113,6 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         }
     }
 
-    protected override async IAsyncEnumerable<ZipArchiveEntry> LoadEntriesAsync(
-        IAsyncEnumerable<ZipVolume> volumes
-    )
-    {
-        var vols = await volumes.ToListAsync();
-        var volsArray = vols.ToArray();
-
-        await foreach (
-            var h in headerFactory.NotNull().ReadSeekableHeaderAsync(volsArray.Last().Stream)
-        )
-        {
-            if (h != null)
-            {
-                switch (h.ZipHeaderType)
-                {
-                    case ZipHeaderType.DirectoryEntry:
-                        {
-                            var deh = (DirectoryEntryHeader)h;
-                            Stream s;
-                            if (
-                                deh.RelativeOffsetOfEntryHeader + deh.CompressedSize
-                                > volsArray[deh.DiskNumberStart].Stream.Length
-                            )
-                            {
-                                var v = volsArray.Skip(deh.DiskNumberStart).ToArray();
-                                s = new SourceStream(
-                                    v[0].Stream,
-                                    i => i < v.Length ? v[i].Stream : null,
-                                    new ReaderOptions() { LeaveStreamOpen = true }
-                                );
-                            }
-                            else
-                            {
-                                s = volsArray[deh.DiskNumberStart].Stream;
-                            }
-
-                            yield return new ZipArchiveEntry(
-                                this,
-                                new SeekableZipFilePart(headerFactory.NotNull(), deh, s)
-                            );
-                        }
-                        break;
-                    case ZipHeaderType.DirectoryEnd:
-                    {
-                        var bytes = ((DirectoryEndHeader)h).Comment ?? Array.Empty<byte>();
-                        volsArray.Last().Comment = ReaderOptions.ArchiveEncoding.Decode(bytes);
-                        yield break;
-                    }
-                }
-            }
-        }
-    }
-
     public void SaveTo(Stream stream) => SaveTo(stream, new WriterOptions(CompressionType.Deflate));
 
     protected override void SaveTo(
@@ -192,67 +144,6 @@ public partial class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVo
         }
     }
 
-    protected override async ValueTask SaveToAsync(
-        Stream stream,
-        WriterOptions options,
-        IAsyncEnumerable<ZipArchiveEntry> oldEntries,
-        IEnumerable<ZipArchiveEntry> newEntries,
-        CancellationToken cancellationToken = default
-    )
-    {
-        using var writer = new ZipWriter(stream, new ZipWriterOptions(options));
-        await foreach (
-            var entry in oldEntries.WithCancellation(cancellationToken).ConfigureAwait(false)
-        )
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-        foreach (var entry in newEntries)
-        {
-            if (entry.IsDirectory)
-            {
-                await writer
-                    .WriteDirectoryAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entry.LastModifiedTime,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-            else
-            {
-                using var entryStream = entry.OpenEntryStream();
-                await writer
-                    .WriteAsync(
-                        entry.Key.NotNull("Entry Key is null"),
-                        entryStream,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     protected override ZipArchiveEntry CreateEntryInternal(
         string filePath,
         Stream source,

src/SharpCompress/Archives/Zip/ZipArchiveEntry.Async.cs

@@ -0,0 +1,22 @@
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Zip;
+
+namespace SharpCompress.Archives.Zip;
+
+public partial class ZipArchiveEntry
+{
+    public async ValueTask<Stream> OpenEntryStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        var part = Parts.Single();
+        if (part is SeekableZipFilePart seekablePart)
+        {
+            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
+        }
+        return OpenEntryStream();
+    }
+}

src/SharpCompress/Archives/Zip/ZipArchiveEntry.cs

@@ -6,25 +6,13 @@ using SharpCompress.Common.Zip;
 
 namespace SharpCompress.Archives.Zip;
 
-public class ZipArchiveEntry : ZipEntry, IArchiveEntry
+public partial class ZipArchiveEntry : ZipEntry, IArchiveEntry
 {
     internal ZipArchiveEntry(ZipArchive archive, SeekableZipFilePart? part)
         : base(part) => Archive = archive;
 
     public virtual Stream OpenEntryStream() => Parts.Single().GetCompressedStream().NotNull();
 
-    public async ValueTask<Stream> OpenEntryStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        var part = Parts.Single();
-        if (part is SeekableZipFilePart seekablePart)
-        {
-            return (await seekablePart.GetCompressedStreamAsync(cancellationToken)).NotNull();
-        }
-        return OpenEntryStream();
-    }
-
     #region IArchiveEntry Members
 
     public IArchive Archive { get; }

src/SharpCompress/Archives/Zip/ZipArchiveVolumeFactory.cs

@@ -14,6 +14,7 @@ internal static class ZipArchiveVolumeFactory
         //new style .zip, z01.. | .zipx, zx01 - if the numbers go beyond 99 then they use 100 ...1000 etc
         var m = Regex.Match(part1.Name, @"^(.*\.)(zipx?|zx?[0-9]+)$", RegexOptions.IgnoreCase);
         if (m.Success)
+        {
             item = new FileInfo(
                 Path.Combine(
                     part1.DirectoryName!,
@@ -24,11 +25,16 @@ internal static class ZipArchiveVolumeFactory
                     )
                 )
             );
+        }
         else //split - 001, 002 ...
+        {
             return ArchiveVolumeFactory.GetFilePart(index, part1);
+        }
 
         if (item != null && item.Exists)
+        {
             return item;
+        }
 
         return null; //no more items
     }

src/SharpCompress/Common/Ace/AceCrc.cs

@@ -22,9 +22,13 @@ namespace SharpCompress.Common.Ace
                 for (int j = 0; j < 8; j++)
                 {
                     if ((crc & 1) != 0)
+                    {
                         crc = (crc >> 1) ^ 0xEDB88320u;
+                    }
                     else
+                    {
                         crc >>= 1;
+                    }
                 }
 
                 table[i] = crc;

src/SharpCompress/Common/Ace/Headers/AceFileHeader.Async.cs

@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Arc;
+
+namespace SharpCompress.Common.Ace.Headers;
+
+public sealed partial class AceFileHeader
+{
+    /// <summary>
+    /// Asynchronously reads the next file entry header from the stream.
+    /// Returns null if no more entries or end of archive.
+    /// Supports both ACE 1.0 and ACE 2.0 formats.
+    /// </summary>
+    public override async ValueTask<AceHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var headerData = await ReadHeaderAsync(stream, cancellationToken);
+        if (headerData.Length == 0)
+        {
+            return null;
+        }
+        int offset = 0;
+
+        // Header type (1 byte)
+        HeaderType = headerData[offset++];
+
+        // Skip recovery record headers (ACE 2.0 feature)
+        if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
+        {
+            // Skip to next header
+            return null;
+        }
+
+        if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
+        {
+            // Unknown header type - skip
+            return null;
+        }
+
+        // Header flags (2 bytes)
+        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Packed size (4 bytes)
+        PackedSize = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // Original size (4 bytes)
+        OriginalSize = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // File date/time in DOS format (4 bytes)
+        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
+        DateTime = ConvertDosDateTime(dosDateTime);
+        offset += 4;
+
+        // File attributes (4 bytes)
+        Attributes = (int)BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // CRC32 (4 bytes)
+        Crc32 = BitConverter.ToUInt32(headerData, offset);
+        offset += 4;
+
+        // Compression type (1 byte)
+        byte compressionType = headerData[offset++];
+        CompressionType = GetCompressionType(compressionType);
+
+        // Compression quality/parameter (1 byte)
+        byte compressionQuality = headerData[offset++];
+        CompressionQuality = GetCompressionQuality(compressionQuality);
+
+        // Parameters (2 bytes)
+        Parameters = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Reserved (2 bytes) - skip
+        offset += 2;
+
+        // Filename length (2 bytes)
+        var filenameLength = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Filename
+        if (offset + filenameLength <= headerData.Length)
+        {
+            Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
+            offset += filenameLength;
+        }
+
+        // Handle comment if present
+        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
+        {
+            // Comment length (2 bytes)
+            if (offset + 2 <= headerData.Length)
+            {
+                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
+                offset += 2 + commentLength; // Skip comment
+            }
+        }
+
+        // Store the data start position
+        DataStartPosition = stream.Position;
+
+        return this;
+    }
+}

src/SharpCompress/Common/Ace/Headers/AceFileHeader.cs

@@ -12,7 +12,7 @@ namespace SharpCompress.Common.Ace.Headers
     /// <summary>
     /// ACE file entry header
     /// </summary>
-    public sealed class AceFileHeader : AceHeader
+    public sealed partial class AceFileHeader : AceHeader
     {
         public long DataStartPosition { get; private set; }
         public long PackedSize { get; set; }
@@ -149,106 +149,7 @@ namespace SharpCompress.Common.Ace.Headers
             return this;
         }
 
-        /// <summary>
-        /// Asynchronously reads the next file entry header from the stream.
-        /// Returns null if no more entries or end of archive.
-        /// Supports both ACE 1.0 and ACE 2.0 formats.
-        /// </summary>
-        public override async ValueTask<AceHeader?> ReadAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var headerData = await ReadHeaderAsync(stream, cancellationToken);
-            if (headerData.Length == 0)
-            {
-                return null;
-            }
-            int offset = 0;
-
-            // Header type (1 byte)
-            HeaderType = headerData[offset++];
-
-            // Skip recovery record headers (ACE 2.0 feature)
-            if (HeaderType == (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.RECOVERY32)
-            {
-                // Skip to next header
-                return null;
-            }
-
-            if (HeaderType != (byte)SharpCompress.Common.Ace.Headers.AceHeaderType.FILE)
-            {
-                // Unknown header type - skip
-                return null;
-            }
-
-            // Header flags (2 bytes)
-            HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Packed size (4 bytes)
-            PackedSize = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // Original size (4 bytes)
-            OriginalSize = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // File date/time in DOS format (4 bytes)
-            var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-            DateTime = ConvertDosDateTime(dosDateTime);
-            offset += 4;
-
-            // File attributes (4 bytes)
-            Attributes = (int)BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // CRC32 (4 bytes)
-            Crc32 = BitConverter.ToUInt32(headerData, offset);
-            offset += 4;
-
-            // Compression type (1 byte)
-            byte compressionType = headerData[offset++];
-            CompressionType = GetCompressionType(compressionType);
-
-            // Compression quality/parameter (1 byte)
-            byte compressionQuality = headerData[offset++];
-            CompressionQuality = GetCompressionQuality(compressionQuality);
-
-            // Parameters (2 bytes)
-            Parameters = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Reserved (2 bytes) - skip
-            offset += 2;
-
-            // Filename length (2 bytes)
-            var filenameLength = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Filename
-            if (offset + filenameLength <= headerData.Length)
-            {
-                Filename = ArchiveEncoding.Decode(headerData, offset, filenameLength);
-                offset += filenameLength;
-            }
-
-            // Handle comment if present
-            if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-            {
-                // Comment length (2 bytes)
-                if (offset + 2 <= headerData.Length)
-                {
-                    ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                    offset += 2 + commentLength; // Skip comment
-                }
-            }
-
-            // Store the data start position
-            DataStartPosition = stream.Position;
-
-            return this;
-        }
+        // ReadAsync moved to AceFileHeader.Async.cs
 
         public CompressionType GetCompressionType(byte value) =>
             value switch

src/SharpCompress/Common/Ace/Headers/AceHeader.Async.cs

@@ -0,0 +1,69 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Ace.Headers;
+
+public abstract partial class AceHeader
+{
+    public abstract ValueTask<AceHeader?> ReadAsync(
+        Stream reader,
+        CancellationToken cancellationToken = default
+    );
+
+    public async ValueTask<byte[]> ReadHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Read header CRC (2 bytes) and header size (2 bytes)
+        var headerBytes = new byte[4];
+        if (await stream.ReadAsync(headerBytes, 0, 4, cancellationToken) != 4)
+        {
+            return Array.Empty<byte>();
+        }
+
+        HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation
+        HeaderSize = BitConverter.ToUInt16(headerBytes, 2);
+        if (HeaderSize == 0)
+        {
+            return Array.Empty<byte>();
+        }
+
+        // Read the header data
+        var body = new byte[HeaderSize];
+        if (await stream.ReadAsync(body, 0, HeaderSize, cancellationToken) != HeaderSize)
+        {
+            return Array.Empty<byte>();
+        }
+
+        // Verify crc
+        var checksum = AceCrc.AceCrc16(body);
+        if (checksum != HeaderCrc)
+        {
+            throw new InvalidDataException("Header checksum is invalid");
+        }
+        return body;
+    }
+
+    /// <summary>
+    /// Asynchronously checks if the stream is an ACE archive
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>True if the stream is an ACE archive, false otherwise</returns>
+    public static async ValueTask<bool> IsArchiveAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var bytes = new byte[14];
+        if (await stream.ReadAsync(bytes, 0, 14, cancellationToken) != 14)
+        {
+            return false;
+        }
+
+        return CheckMagicBytes(bytes, 7);
+    }
+}

src/SharpCompress/Common/Ace/Headers/AceHeader.cs

@@ -19,7 +19,7 @@ namespace SharpCompress.Common.Ace.Headers
         RECOVERY64B = 4,
     }
 
-    public abstract class AceHeader
+    public abstract partial class AceHeader
     {
         // ACE signature: bytes at offset 7 should be "**ACE**"
         private static readonly byte[] AceSignature =
@@ -60,10 +60,7 @@ namespace SharpCompress.Common.Ace.Headers
 
         public abstract AceHeader? Read(Stream reader);
 
-        public abstract ValueTask<AceHeader?> ReadAsync(
-            Stream reader,
-            CancellationToken cancellationToken = default
-        );
+        // Async methods moved to AceHeader.Async.cs
 
         public byte[] ReadHeader(Stream stream)
         {
@@ -97,41 +94,6 @@ namespace SharpCompress.Common.Ace.Headers
             return body;
         }
 
-        public async ValueTask<byte[]> ReadHeaderAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            // Read header CRC (2 bytes) and header size (2 bytes)
-            var headerBytes = new byte[4];
-            if (await stream.ReadAsync(headerBytes, 0, 4, cancellationToken) != 4)
-            {
-                return Array.Empty<byte>();
-            }
-
-            HeaderCrc = BitConverter.ToUInt16(headerBytes, 0); // CRC for validation
-            HeaderSize = BitConverter.ToUInt16(headerBytes, 2);
-            if (HeaderSize == 0)
-            {
-                return Array.Empty<byte>();
-            }
-
-            // Read the header data
-            var body = new byte[HeaderSize];
-            if (await stream.ReadAsync(body, 0, HeaderSize, cancellationToken) != HeaderSize)
-            {
-                return Array.Empty<byte>();
-            }
-
-            // Verify crc
-            var checksum = AceCrc.AceCrc16(body);
-            if (checksum != HeaderCrc)
-            {
-                throw new InvalidDataException("Header checksum is invalid");
-            }
-            return body;
-        }
-
         public static bool IsArchive(Stream stream)
         {
             // ACE files have a specific signature
@@ -147,26 +109,6 @@ namespace SharpCompress.Common.Ace.Headers
             return CheckMagicBytes(bytes, 7);
         }
 
-        /// <summary>
-        /// Asynchronously checks if the stream is an ACE archive
-        /// </summary>
-        /// <param name="stream">The stream to read from</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <returns>True if the stream is an ACE archive, false otherwise</returns>
-        public static async ValueTask<bool> IsArchiveAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var bytes = new byte[14];
-            if (await stream.ReadAsync(bytes, 0, 14, cancellationToken) != 14)
-            {
-                return false;
-            }
-
-            return CheckMagicBytes(bytes, 7);
-        }
-
         protected static bool CheckMagicBytes(byte[] headerBytes, int offset)
         {
             // Check for "**ACE**" at specified offset

src/SharpCompress/Common/Ace/Headers/AceMainHeader.Async.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Ace.Headers;
+
+public sealed partial class AceMainHeader
+{
+    /// <summary>
+    /// Asynchronously reads the main archive header from the stream.
+    /// Returns header if this is a valid ACE archive.
+    /// Supports both ACE 1.0 and ACE 2.0 formats.
+    /// </summary>
+    public override async ValueTask<AceHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var headerData = await ReadHeaderAsync(stream, cancellationToken);
+        if (headerData.Length == 0)
+        {
+            return null;
+        }
+        int offset = 0;
+
+        // Header type should be 0 for main header
+        if (headerData[offset++] != HeaderType)
+        {
+            return null;
+        }
+
+        // Header flags (2 bytes)
+        HeaderFlags = BitConverter.ToUInt16(headerData, offset);
+        offset += 2;
+
+        // Skip signature "**ACE**" (7 bytes)
+        if (!CheckMagicBytes(headerData, offset))
+        {
+            throw new InvalidDataException("Invalid ACE archive signature.");
+        }
+        offset += 7;
+
+        // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0
+        AceVersion = headerData[offset++];
+        ExtractVersion = headerData[offset++];
+
+        // Host OS (1 byte)
+        if (offset < headerData.Length)
+        {
+            var hostOsByte = headerData[offset++];
+            HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
+        }
+        // Volume number (1 byte)
+        VolumeNumber = headerData[offset++];
+
+        // Creation date/time (4 bytes)
+        var dosDateTime = BitConverter.ToUInt32(headerData, offset);
+        DateTime = ConvertDosDateTime(dosDateTime);
+        offset += 4;
+
+        // Reserved fields (8 bytes)
+        if (offset + 8 <= headerData.Length)
+        {
+            offset += 8;
+        }
+
+        // Skip additional fields based on flags
+        // Handle comment if present
+        if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
+        {
+            if (offset + 2 <= headerData.Length)
+            {
+                ushort commentLength = BitConverter.ToUInt16(headerData, offset);
+                offset += 2 + commentLength;
+            }
+        }
+
+        return this;
+    }
+}

src/SharpCompress/Common/Ace/Headers/AceMainHeader.cs

@@ -13,7 +13,7 @@ namespace SharpCompress.Common.Ace.Headers
     /// <summary>
     /// ACE main archive header
     /// </summary>
-    public sealed class AceMainHeader : AceHeader
+    public sealed partial class AceMainHeader : AceHeader
     {
         public byte ExtractVersion { get; set; }
         public byte CreatorVersion { get; set; }
@@ -96,76 +96,6 @@ namespace SharpCompress.Common.Ace.Headers
             return this;
         }
 
-        /// <summary>
-        /// Asynchronously reads the main archive header from the stream.
-        /// Returns header if this is a valid ACE archive.
-        /// Supports both ACE 1.0 and ACE 2.0 formats.
-        /// </summary>
-        public override async ValueTask<AceHeader?> ReadAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var headerData = await ReadHeaderAsync(stream, cancellationToken);
-            if (headerData.Length == 0)
-            {
-                return null;
-            }
-            int offset = 0;
-
-            // Header type should be 0 for main header
-            if (headerData[offset++] != HeaderType)
-            {
-                return null;
-            }
-
-            // Header flags (2 bytes)
-            HeaderFlags = BitConverter.ToUInt16(headerData, offset);
-            offset += 2;
-
-            // Skip signature "**ACE**" (7 bytes)
-            if (!CheckMagicBytes(headerData, offset))
-            {
-                throw new InvalidDataException("Invalid ACE archive signature.");
-            }
-            offset += 7;
-
-            // ACE version (1 byte) - 10 for ACE 1.0, 20 for ACE 2.0
-            AceVersion = headerData[offset++];
-            ExtractVersion = headerData[offset++];
-
-            // Host OS (1 byte)
-            if (offset < headerData.Length)
-            {
-                var hostOsByte = headerData[offset++];
-                HostOS = hostOsByte <= 11 ? (HostOS)hostOsByte : HostOS.Unknown;
-            }
-            // Volume number (1 byte)
-            VolumeNumber = headerData[offset++];
-
-            // Creation date/time (4 bytes)
-            var dosDateTime = BitConverter.ToUInt32(headerData, offset);
-            DateTime = ConvertDosDateTime(dosDateTime);
-            offset += 4;
-
-            // Reserved fields (8 bytes)
-            if (offset + 8 <= headerData.Length)
-            {
-                offset += 8;
-            }
-
-            // Skip additional fields based on flags
-            // Handle comment if present
-            if ((HeaderFlags & SharpCompress.Common.Ace.Headers.HeaderFlags.COMMENT) != 0)
-            {
-                if (offset + 2 <= headerData.Length)
-                {
-                    ushort commentLength = BitConverter.ToUInt16(headerData, offset);
-                    offset += 2 + commentLength;
-                }
-            }
-
-            return this;
-        }
+        // ReadAsync moved to AceMainHeader.Async.cs
     }
 }

src/SharpCompress/Common/Arj/Headers/ArjHeader.Async.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Crypto;
+
+namespace SharpCompress.Common.Arj.Headers;
+
+public abstract partial class ArjHeader
+{
+    public abstract ValueTask<ArjHeader?> ReadAsync(
+        Stream reader,
+        CancellationToken cancellationToken = default
+    );
+
+    public async ValueTask<byte[]> ReadHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // check for magic bytes
+        var magic = new byte[2];
+        if (await stream.ReadAsync(magic, 0, 2, cancellationToken) != 2)
+        {
+            return Array.Empty<byte>();
+        }
+
+        if (!CheckMagicBytes(magic))
+        {
+            throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
+        }
+
+        // read header_size
+        byte[] headerBytes = new byte[2];
+        await stream.ReadAsync(headerBytes, 0, 2, cancellationToken);
+        var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
+        if (headerSize < 1)
+        {
+            return Array.Empty<byte>();
+        }
+
+        var body = new byte[headerSize];
+        var read = await stream.ReadAsync(body, 0, headerSize, cancellationToken);
+        if (read < headerSize)
+        {
+            return Array.Empty<byte>();
+        }
+
+        byte[] crc = new byte[4];
+        read = await stream.ReadAsync(crc, 0, 4, cancellationToken);
+        var checksum = Crc32Stream.Compute(body);
+        // Compute the hash value
+        if (checksum != BitConverter.ToUInt32(crc, 0))
+        {
+            throw new InvalidDataException("Header checksum is invalid");
+        }
+        return body;
+    }
+
+    protected async ValueTask<List<byte[]>> ReadExtendedHeadersAsync(
+        Stream reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        List<byte[]> extendedHeader = new List<byte[]>();
+        byte[] buffer = new byte[2];
+
+        while (true)
+        {
+            int bytesRead = await reader.ReadAsync(buffer, 0, 2, cancellationToken);
+            if (bytesRead < 2)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header size."
+                );
+            }
+
+            var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
+            if (extHeaderSize == 0)
+            {
+                return extendedHeader;
+            }
+
+            byte[] header = new byte[extHeaderSize];
+            bytesRead = await reader.ReadAsync(header, 0, extHeaderSize, cancellationToken);
+            if (bytesRead < extHeaderSize)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header data."
+                );
+            }
+
+            byte[] crcextended = new byte[4];
+            bytesRead = await reader.ReadAsync(crcextended, 0, 4, cancellationToken);
+            if (bytesRead < 4)
+            {
+                throw new EndOfStreamException(
+                    "Unexpected end of stream while reading extended header CRC."
+                );
+            }
+
+            var checksum = Crc32Stream.Compute(header);
+            if (checksum != BitConverter.ToUInt32(crcextended, 0))
+            {
+                throw new InvalidDataException("Extended header checksum is invalid");
+            }
+
+            extendedHeader.Add(header);
+        }
+    }
+
+    /// <summary>
+    /// Asynchronously checks if the stream is an ARJ archive
+    /// </summary>
+    /// <param name="stream">The stream to read from</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <returns>True if the stream is an ARJ archive, false otherwise</returns>
+    public static async ValueTask<bool> IsArchiveAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var bytes = new byte[2];
+        if (await stream.ReadAsync(bytes, 0, 2, cancellationToken) != 2)
+        {
+            return false;
+        }
+
+        return CheckMagicBytes(bytes);
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjHeader.cs

@@ -16,7 +16,7 @@ namespace SharpCompress.Common.Arj.Headers
         LocalHeader,
     }
 
-    public abstract class ArjHeader
+    public abstract partial class ArjHeader
     {
         private const int FIRST_HDR_SIZE = 34;
         private const ushort ARJ_MAGIC = 0xEA60;
@@ -32,10 +32,7 @@ namespace SharpCompress.Common.Arj.Headers
 
         public abstract ArjHeader? Read(Stream reader);
 
-        public abstract ValueTask<ArjHeader?> ReadAsync(
-            Stream reader,
-            CancellationToken cancellationToken = default
-        );
+        // Async methods moved to ArjHeader.Async.cs
 
         public byte[] ReadHeader(Stream stream)
         {
@@ -78,101 +75,7 @@ namespace SharpCompress.Common.Arj.Headers
             return body;
         }
 
-        public async ValueTask<byte[]> ReadHeaderAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            // check for magic bytes
-            var magic = new byte[2];
-            if (await stream.ReadAsync(magic, 0, 2, cancellationToken) != 2)
-            {
-                return Array.Empty<byte>();
-            }
-
-            if (!CheckMagicBytes(magic))
-            {
-                throw new InvalidDataException("Not an ARJ file (wrong magic bytes)");
-            }
-
-            // read header_size
-            byte[] headerBytes = new byte[2];
-            await stream.ReadAsync(headerBytes, 0, 2, cancellationToken);
-            var headerSize = (ushort)(headerBytes[0] | headerBytes[1] << 8);
-            if (headerSize < 1)
-            {
-                return Array.Empty<byte>();
-            }
-
-            var body = new byte[headerSize];
-            var read = await stream.ReadAsync(body, 0, headerSize, cancellationToken);
-            if (read < headerSize)
-            {
-                return Array.Empty<byte>();
-            }
-
-            byte[] crc = new byte[4];
-            read = await stream.ReadAsync(crc, 0, 4, cancellationToken);
-            var checksum = Crc32Stream.Compute(body);
-            // Compute the hash value
-            if (checksum != BitConverter.ToUInt32(crc, 0))
-            {
-                throw new InvalidDataException("Header checksum is invalid");
-            }
-            return body;
-        }
-
-        protected async ValueTask<List<byte[]>> ReadExtendedHeadersAsync(
-            Stream reader,
-            CancellationToken cancellationToken = default
-        )
-        {
-            List<byte[]> extendedHeader = new List<byte[]>();
-            byte[] buffer = new byte[2];
-
-            while (true)
-            {
-                int bytesRead = await reader.ReadAsync(buffer, 0, 2, cancellationToken);
-                if (bytesRead < 2)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header size."
-                    );
-                }
-
-                var extHeaderSize = (ushort)(buffer[0] | (buffer[1] << 8));
-                if (extHeaderSize == 0)
-                {
-                    return extendedHeader;
-                }
-
-                byte[] header = new byte[extHeaderSize];
-                bytesRead = await reader.ReadAsync(header, 0, extHeaderSize, cancellationToken);
-                if (bytesRead < extHeaderSize)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header data."
-                    );
-                }
-
-                byte[] crc = new byte[4];
-                bytesRead = await reader.ReadAsync(crc, 0, 4, cancellationToken);
-                if (bytesRead < 4)
-                {
-                    throw new EndOfStreamException(
-                        "Unexpected end of stream while reading extended header CRC."
-                    );
-                }
-
-                var checksum = Crc32Stream.Compute(header);
-                if (checksum != BitConverter.ToUInt32(crc, 0))
-                {
-                    throw new InvalidDataException("Extended header checksum is invalid");
-                }
-
-                extendedHeader.Add(header);
-            }
-        }
+        // ReadHeaderAsync moved to ArjHeader.Async.cs
 
         protected List<byte[]> ReadExtendedHeaders(Stream reader)
         {
@@ -251,26 +154,6 @@ namespace SharpCompress.Common.Arj.Headers
             return CheckMagicBytes(bytes);
         }
 
-        /// <summary>
-        /// Asynchronously checks if the stream is an ARJ archive
-        /// </summary>
-        /// <param name="stream">The stream to read from</param>
-        /// <param name="cancellationToken">Cancellation token</param>
-        /// <returns>True if the stream is an ARJ archive, false otherwise</returns>
-        public static async ValueTask<bool> IsArchiveAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var bytes = new byte[2];
-            if (await stream.ReadAsync(bytes, 0, 2, cancellationToken) != 2)
-            {
-                return false;
-            }
-
-            return CheckMagicBytes(bytes);
-        }
-
         protected static bool CheckMagicBytes(byte[] headerBytes)
         {
             var magicValue = (ushort)(headerBytes[0] | headerBytes[1] << 8);

src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.Async.cs

@@ -0,0 +1,24 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Arj.Headers;
+
+public partial class ArjLocalHeader
+{
+    public override async ValueTask<ArjHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var body = await ReadHeaderAsync(stream, cancellationToken);
+        if (body.Length > 0)
+        {
+            await ReadExtendedHeadersAsync(stream, cancellationToken);
+            var header = LoadFrom(body);
+            header.DataStartPosition = stream.Position;
+            return header;
+        }
+        return null;
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjLocalHeader.cs

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Arj.Headers
 {
-    public class ArjLocalHeader : ArjHeader
+    public partial class ArjLocalHeader : ArjHeader
     {
         public ArchiveEncoding ArchiveEncoding { get; }
         public long DataStartPosition { get; protected set; }
@@ -56,21 +56,7 @@ namespace SharpCompress.Common.Arj.Headers
             return null;
         }
 
-        public override async ValueTask<ArjHeader?> ReadAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var body = await ReadHeaderAsync(stream, cancellationToken);
-            if (body.Length > 0)
-            {
-                await ReadExtendedHeadersAsync(stream, cancellationToken);
-                var header = LoadFrom(body);
-                header.DataStartPosition = stream.Position;
-                return header;
-            }
-            return null;
-        }
+        // ReadAsync moved to ArjLocalHeader.Async.cs
 
         public ArjLocalHeader LoadFrom(byte[] headerBytes)
         {

src/SharpCompress/Common/Arj/Headers/ArjMainHeader.Async.cs

@@ -0,0 +1,18 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Arj.Headers;
+
+public partial class ArjMainHeader
+{
+    public override async ValueTask<ArjHeader?> ReadAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var body = await ReadHeaderAsync(stream, cancellationToken);
+        await ReadExtendedHeadersAsync(stream, cancellationToken);
+        return LoadFrom(body);
+    }
+}

src/SharpCompress/Common/Arj/Headers/ArjMainHeader.cs

@@ -8,7 +8,7 @@ using SharpCompress.Crypto;
 
 namespace SharpCompress.Common.Arj.Headers
 {
-    public class ArjMainHeader : ArjHeader
+    public partial class ArjMainHeader : ArjHeader
     {
         private const int FIRST_HDR_SIZE = 34;
         private const ushort ARJ_MAGIC = 0xEA60;
@@ -47,15 +47,7 @@ namespace SharpCompress.Common.Arj.Headers
             return LoadFrom(body);
         }
 
-        public override async ValueTask<ArjHeader?> ReadAsync(
-            Stream stream,
-            CancellationToken cancellationToken = default
-        )
-        {
-            var body = await ReadHeaderAsync(stream, cancellationToken);
-            await ReadExtendedHeadersAsync(stream, cancellationToken);
-            return LoadFrom(body);
-        }
+        // ReadAsync moved to ArjMainHeader.Async.cs
 
         public ArjMainHeader LoadFrom(byte[] headerBytes)
         {

src/SharpCompress/Common/AsyncBinaryReader.cs

@@ -16,6 +16,11 @@ namespace SharpCompress.Common
 
         public AsyncBinaryReader(Stream stream, bool leaveOpen = false, int bufferSize = 4096)
         {
+            if (!stream.CanRead)
+            {
+                throw new ArgumentException("Stream must be readable.");
+            }
+
             _originalStream = stream ?? throw new ArgumentNullException(nameof(stream));
             _leaveOpen = leaveOpen;
 
@@ -82,7 +87,7 @@ namespace SharpCompress.Common
             }
         }
 
-#if NET6_0_OR_GREATER
+#if NET8_0_OR_GREATER
         public async ValueTask DisposeAsync()
         {
             if (_disposed)

src/SharpCompress/Common/EntryStream.Async.cs

@@ -0,0 +1,84 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common;
+
+public partial class EntryStream
+{
+    /// <summary>
+    /// Asynchronously skip the rest of the entry stream.
+    /// </summary>
+    public async ValueTask SkipEntryAsync(CancellationToken cancellationToken = default)
+    {
+        await this.SkipAsync(cancellationToken).ConfigureAwait(false);
+        _completed = true;
+    }
+
+#if !LEGACY_DOTNET
+    public override async ValueTask DisposeAsync()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+        _isDisposed = true;
+        if (!(_completed || _reader.Cancelled))
+        {
+            await SkipEntryAsync().ConfigureAwait(false);
+        }
+
+        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
+        if (_stream is IStreamStack ss)
+        {
+            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
+            {
+                await deflateStream.FlushAsync().ConfigureAwait(false);
+            }
+            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
+            {
+                await lzmaStream.FlushAsync().ConfigureAwait(false);
+            }
+        }
+#if DEBUG_STREAMS
+        this.DebugDispose(typeof(EntryStream));
+#endif
+        await base.DisposeAsync().ConfigureAwait(false);
+        await _stream.DisposeAsync().ConfigureAwait(false);
+    }
+#endif
+
+    public override async Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var read = await _stream
+            .ReadAsync(buffer, offset, count, cancellationToken)
+            .ConfigureAwait(false);
+        if (read <= 0)
+        {
+            _completed = true;
+        }
+        return read;
+    }
+
+#if !LEGACY_DOTNET
+    public override async ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var read = await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
+        if (read <= 0)
+        {
+            _completed = true;
+        }
+        return read;
+    }
+#endif
+}

src/SharpCompress/Common/EntryStream.cs

@@ -8,7 +8,7 @@ using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
-public class EntryStream : Stream, IStreamStack
+public partial class EntryStream : Stream, IStreamStack
 {
 #if DEBUG_STREAMS
     long IStreamStack.InstanceId { get; set; }
@@ -53,15 +53,6 @@ public class EntryStream : Stream, IStreamStack
         _completed = true;
     }
 
-    /// <summary>
-    /// Asynchronously skip the rest of the entry stream.
-    /// </summary>
-    public async ValueTask SkipEntryAsync(CancellationToken cancellationToken = default)
-    {
-        await this.SkipAsync(cancellationToken).ConfigureAwait(false);
-        _completed = true;
-    }
-
     protected override void Dispose(bool disposing)
     {
         if (_isDisposed)
@@ -93,39 +84,6 @@ public class EntryStream : Stream, IStreamStack
         _stream.Dispose();
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask DisposeAsync()
-    {
-        if (_isDisposed)
-        {
-            return;
-        }
-        _isDisposed = true;
-        if (!(_completed || _reader.Cancelled))
-        {
-            await SkipEntryAsync().ConfigureAwait(false);
-        }
-
-        //Need a safe standard approach to this - it's okay for compression to overreads. Handling needs to be standardised
-        if (_stream is IStreamStack ss)
-        {
-            if (ss.BaseStream() is SharpCompress.Compressors.Deflate.DeflateStream deflateStream)
-            {
-                await deflateStream.FlushAsync().ConfigureAwait(false);
-            }
-            else if (ss.BaseStream() is SharpCompress.Compressors.LZMA.LzmaStream lzmaStream)
-            {
-                await lzmaStream.FlushAsync().ConfigureAwait(false);
-            }
-        }
-#if DEBUG_STREAMS
-        this.DebugDispose(typeof(EntryStream));
-#endif
-        await base.DisposeAsync().ConfigureAwait(false);
-        await _stream.DisposeAsync().ConfigureAwait(false);
-    }
-#endif
-
     public override bool CanRead => true;
 
     public override bool CanSeek => false;
@@ -154,38 +112,6 @@ public class EntryStream : Stream, IStreamStack
         return read;
     }
 
-    public override async Task<int> ReadAsync(
-        byte[] buffer,
-        int offset,
-        int count,
-        CancellationToken cancellationToken
-    )
-    {
-        var read = await _stream
-            .ReadAsync(buffer, offset, count, cancellationToken)
-            .ConfigureAwait(false);
-        if (read <= 0)
-        {
-            _completed = true;
-        }
-        return read;
-    }
-
-#if !NETFRAMEWORK && !NETSTANDARD2_0
-    public override async ValueTask<int> ReadAsync(
-        Memory<byte> buffer,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var read = await _stream.ReadAsync(buffer, cancellationToken).ConfigureAwait(false);
-        if (read <= 0)
-        {
-            _completed = true;
-        }
-        return read;
-    }
-#endif
-
     public override int ReadByte()
     {
         var value = _stream.ReadByte();

src/SharpCompress/Common/ExtractionMethods.Async.cs

@@ -0,0 +1,116 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common;
+
+internal static partial class ExtractionMethods
+{
+    public static async ValueTask WriteEntryToDirectoryAsync(
+        IEntry entry,
+        string destinationDirectory,
+        ExtractionOptions? options,
+        Func<string, ExtractionOptions?, CancellationToken, ValueTask> writeAsync,
+        CancellationToken cancellationToken = default
+    )
+    {
+        string destinationFileName;
+        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
+
+        //check for trailing slash.
+        if (
+            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
+            != Path.DirectorySeparatorChar
+        )
+        {
+            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
+        }
+
+        if (!Directory.Exists(fullDestinationDirectoryPath))
+        {
+            throw new ExtractionException(
+                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
+            );
+        }
+
+        options ??= new ExtractionOptions() { Overwrite = true };
+
+        var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
+        file = Utility.ReplaceInvalidFileNameChars(file);
+        if (options.ExtractFullPath)
+        {
+            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
+                .NotNull("Directory is null");
+            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
+
+            if (!Directory.Exists(destdir))
+            {
+                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
+                {
+                    throw new ExtractionException(
+                        "Entry is trying to create a directory outside of the destination directory."
+                    );
+                }
+
+                Directory.CreateDirectory(destdir);
+            }
+            destinationFileName = Path.Combine(destdir, file);
+        }
+        else
+        {
+            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
+        }
+
+        if (!entry.IsDirectory)
+        {
+            destinationFileName = Path.GetFullPath(destinationFileName);
+
+            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
+            {
+                throw new ExtractionException(
+                    "Entry is trying to write a file outside of the destination directory."
+                );
+            }
+            await writeAsync(destinationFileName, options, cancellationToken).ConfigureAwait(false);
+        }
+        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
+        {
+            Directory.CreateDirectory(destinationFileName);
+        }
+    }
+
+    public static async ValueTask WriteEntryToFileAsync(
+        IEntry entry,
+        string destinationFileName,
+        ExtractionOptions? options,
+        Func<string, FileMode, CancellationToken, ValueTask> openAndWriteAsync,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (entry.LinkTarget != null)
+        {
+            if (options?.WriteSymbolicLink is null)
+            {
+                throw new ExtractionException(
+                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
+                );
+            }
+            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
+        }
+        else
+        {
+            var fm = FileMode.Create;
+            options ??= new ExtractionOptions() { Overwrite = true };
+
+            if (!options.Overwrite)
+            {
+                fm = FileMode.CreateNew;
+            }
+
+            await openAndWriteAsync(destinationFileName, fm, cancellationToken)
+                .ConfigureAwait(false);
+            entry.PreserveExtractionOptions(destinationFileName, options);
+        }
+    }
+}

src/SharpCompress/Common/ExtractionMethods.cs

@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace SharpCompress.Common;
 
-internal static class ExtractionMethods
+internal static partial class ExtractionMethods
 {
     /// <summary>
     /// Gets the appropriate StringComparison for path checks based on the file system.
@@ -123,111 +123,4 @@ internal static class ExtractionMethods
             entry.PreserveExtractionOptions(destinationFileName, options);
         }
     }
-
-    public static async ValueTask WriteEntryToDirectoryAsync(
-        IEntry entry,
-        string destinationDirectory,
-        ExtractionOptions? options,
-        Func<string, ExtractionOptions?, CancellationToken, ValueTask> writeAsync,
-        CancellationToken cancellationToken = default
-    )
-    {
-        string destinationFileName;
-        var fullDestinationDirectoryPath = Path.GetFullPath(destinationDirectory);
-
-        //check for trailing slash.
-        if (
-            fullDestinationDirectoryPath[fullDestinationDirectoryPath.Length - 1]
-            != Path.DirectorySeparatorChar
-        )
-        {
-            fullDestinationDirectoryPath += Path.DirectorySeparatorChar;
-        }
-
-        if (!Directory.Exists(fullDestinationDirectoryPath))
-        {
-            throw new ExtractionException(
-                $"Directory does not exist to extract to: {fullDestinationDirectoryPath}"
-            );
-        }
-
-        options ??= new ExtractionOptions() { Overwrite = true };
-
-        var file = Path.GetFileName(entry.Key.NotNull("Entry Key is null")).NotNull("File is null");
-        file = Utility.ReplaceInvalidFileNameChars(file);
-        if (options.ExtractFullPath)
-        {
-            var folder = Path.GetDirectoryName(entry.Key.NotNull("Entry Key is null"))
-                .NotNull("Directory is null");
-            var destdir = Path.GetFullPath(Path.Combine(fullDestinationDirectoryPath, folder));
-
-            if (!Directory.Exists(destdir))
-            {
-                if (!destdir.StartsWith(fullDestinationDirectoryPath, PathComparison))
-                {
-                    throw new ExtractionException(
-                        "Entry is trying to create a directory outside of the destination directory."
-                    );
-                }
-
-                Directory.CreateDirectory(destdir);
-            }
-            destinationFileName = Path.Combine(destdir, file);
-        }
-        else
-        {
-            destinationFileName = Path.Combine(fullDestinationDirectoryPath, file);
-        }
-
-        if (!entry.IsDirectory)
-        {
-            destinationFileName = Path.GetFullPath(destinationFileName);
-
-            if (!destinationFileName.StartsWith(fullDestinationDirectoryPath, PathComparison))
-            {
-                throw new ExtractionException(
-                    "Entry is trying to write a file outside of the destination directory."
-                );
-            }
-            await writeAsync(destinationFileName, options, cancellationToken).ConfigureAwait(false);
-        }
-        else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
-        {
-            Directory.CreateDirectory(destinationFileName);
-        }
-    }
-
-    public static async ValueTask WriteEntryToFileAsync(
-        IEntry entry,
-        string destinationFileName,
-        ExtractionOptions? options,
-        Func<string, FileMode, CancellationToken, ValueTask> openAndWriteAsync,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (entry.LinkTarget != null)
-        {
-            if (options?.WriteSymbolicLink is null)
-            {
-                throw new ExtractionException(
-                    "Entry is a symbolic link but ExtractionOptions.WriteSymbolicLink delegate is null"
-                );
-            }
-            options.WriteSymbolicLink(destinationFileName, entry.LinkTarget);
-        }
-        else
-        {
-            var fm = FileMode.Create;
-            options ??= new ExtractionOptions() { Overwrite = true };
-
-            if (!options.Overwrite)
-            {
-                fm = FileMode.CreateNew;
-            }
-
-            await openAndWriteAsync(destinationFileName, fm, cancellationToken)
-                .ConfigureAwait(false);
-            entry.PreserveExtractionOptions(destinationFileName, options);
-        }
-    }
 }

src/SharpCompress/Common/GZip/GZipEntry.Async.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.IO;
+
+namespace SharpCompress.Common.GZip;
+
+public partial class GZipEntry
+{
+    internal static async IAsyncEnumerable<GZipEntry> GetEntriesAsync(
+        Stream stream,
+        OptionsBase options
+    )
+    {
+        yield return new GZipEntry(await GZipFilePart.CreateAsync(stream, options.ArchiveEncoding));
+    }
+}

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -4,7 +4,7 @@ using System.IO;
 
 namespace SharpCompress.Common.GZip;
 
-public class GZipEntry : Entry
+public partial class GZipEntry : Entry
 {
     private readonly GZipFilePart? _filePart;
 
@@ -42,4 +42,6 @@ public class GZipEntry : Entry
     {
         yield return new GZipEntry(GZipFilePart.Create(stream, options.ArchiveEncoding));
     }
+
+    // Async methods moved to GZipEntry.Async.cs
 }

src/SharpCompress/Common/GZip/GZipFilePart.Async.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.Compressors.Deflate;
+
+namespace SharpCompress.Common.GZip;
+
+internal sealed partial class GZipFilePart
+{
+    internal static async ValueTask<GZipFilePart> CreateAsync(
+        Stream stream,
+        IArchiveEncoding archiveEncoding,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var part = new GZipFilePart(stream, archiveEncoding);
+
+        await part.ReadAndValidateGzipHeaderAsync(cancellationToken);
+        if (stream.CanSeek)
+        {
+            var position = stream.Position;
+            stream.Position = stream.Length - 8;
+            await part.ReadTrailerAsync(cancellationToken);
+            stream.Position = position;
+            part.EntryStartPosition = position;
+        }
+        else
+        {
+            // For non-seekable streams, we can't read the trailer or track position.
+            // Set to 0 since the stream will be read sequentially from its current position.
+            part.EntryStartPosition = 0;
+        }
+        return part;
+    }
+
+    private async ValueTask ReadTrailerAsync(CancellationToken cancellationToken = default)
+    {
+        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
+        var trailer = new byte[8];
+        _ = await _stream.ReadFullyAsync(trailer, 0, 8, cancellationToken);
+
+        Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
+        UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.AsSpan().Slice(4));
+    }
+
+    private async ValueTask ReadAndValidateGzipHeaderAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        // read the header on the first read
+        var header = new byte[10];
+        var n = await _stream.ReadAsync(header, 0, 10, cancellationToken);
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (n == 0)
+        {
+            return;
+        }
+
+        if (n != 10)
+        {
+            throw new ZlibException("Not a valid GZIP stream.");
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            throw new ZlibException("Bad GZIP header.");
+        }
+
+        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan().Slice(4));
+        DateModified = TarHeader.EPOCH.AddSeconds(timet);
+        if ((header[3] & 0x04) == 0x04)
+        {
+            // read and discard extra field
+            var lengthField = new byte[2];
+            _ = await _stream.ReadAsync(lengthField, 0, 2, cancellationToken);
+
+            var extraLength = (short)(lengthField[0] + (lengthField[1] * 256));
+            var extra = new byte[extraLength];
+
+            if (!await _stream.ReadFullyAsync(extra, cancellationToken))
+            {
+                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
+            }
+        }
+        if ((header[3] & 0x08) == 0x08)
+        {
+            _name = await ReadZeroTerminatedStringAsync(_stream, cancellationToken);
+        }
+        if ((header[3] & 0x10) == 0x010)
+        {
+            await ReadZeroTerminatedStringAsync(_stream, cancellationToken);
+        }
+        if ((header[3] & 0x02) == 0x02)
+        {
+            var buf = new byte[1];
+            _ = await _stream.ReadAsync(buf, 0, 1, cancellationToken); // CRC16, ignore
+        }
+    }
+
+    private async ValueTask<string> ReadZeroTerminatedStringAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var buf1 = new byte[1];
+        var list = new List<byte>();
+        var done = false;
+        do
+        {
+            // workitem 7740
+            var n = await stream.ReadAsync(buf1, 0, 1, cancellationToken);
+            if (n != 1)
+            {
+                throw new ZlibException("Unexpected EOF reading GZIP header.");
+            }
+            if (buf1[0] == 0)
+            {
+                done = true;
+            }
+            else
+            {
+                list.Add(buf1[0]);
+            }
+        } while (!done);
+        var buffer = list.ToArray();
+        return ArchiveEncoding.Decode(buffer);
+    }
+}

src/SharpCompress/Common/GZip/GZipFilePart.cs

@@ -2,15 +2,13 @@ using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Tar.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 
 namespace SharpCompress.Common.GZip;
 
-internal sealed class GZipFilePart : FilePart
+internal sealed partial class GZipFilePart : FilePart
 {
     private string? _name;
     private readonly Stream _stream;
@@ -37,32 +35,6 @@ internal sealed class GZipFilePart : FilePart
         return part;
     }
 
-    internal static async ValueTask<GZipFilePart> CreateAsync(
-        Stream stream,
-        IArchiveEncoding archiveEncoding,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var part = new GZipFilePart(stream, archiveEncoding);
-
-        await part.ReadAndValidateGzipHeaderAsync(cancellationToken);
-        if (stream.CanSeek)
-        {
-            var position = stream.Position;
-            stream.Position = stream.Length - 8;
-            await part.ReadTrailerAsync(cancellationToken);
-            stream.Position = position;
-            part.EntryStartPosition = position;
-        }
-        else
-        {
-            // For non-seekable streams, we can't read the trailer or track position.
-            // Set to 0 since the stream will be read sequentially from its current position.
-            part.EntryStartPosition = 0;
-        }
-        return part;
-    }
-
     private GZipFilePart(Stream stream, IArchiveEncoding archiveEncoding)
         : base(archiveEncoding) => _stream = stream;
 
@@ -75,7 +47,12 @@ internal sealed class GZipFilePart : FilePart
     internal override string? FilePartName => _name;
 
     internal override Stream GetCompressedStream() =>
-        new DeflateStream(_stream, CompressionMode.Decompress, CompressionLevel.Default);
+        new DeflateStream(
+            _stream,
+            CompressionMode.Decompress,
+            CompressionLevel.Default,
+            leaveOpen: true
+        );
 
     internal override Stream GetRawStream() => _stream;
 
@@ -89,16 +66,6 @@ internal sealed class GZipFilePart : FilePart
         UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.Slice(4));
     }
 
-    private async ValueTask ReadTrailerAsync(CancellationToken cancellationToken = default)
-    {
-        // Read and potentially verify the GZIP trailer: CRC32 and  size mod 2^32
-        var trailer = new byte[8];
-        _ = await _stream.ReadFullyAsync(trailer, 0, 8, cancellationToken);
-
-        Crc = BinaryPrimitives.ReadUInt32LittleEndian(trailer);
-        UncompressedSize = BinaryPrimitives.ReadUInt32LittleEndian(trailer.AsSpan().Slice(4));
-    }
-
     private void ReadAndValidateGzipHeader()
     {
         // read the header on the first read
@@ -151,61 +118,6 @@ internal sealed class GZipFilePart : FilePart
         }
     }
 
-    private async ValueTask ReadAndValidateGzipHeaderAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        // read the header on the first read
-        var header = new byte[10];
-        var n = await _stream.ReadAsync(header, 0, 10, cancellationToken);
-
-        // workitem 8501: handle edge case (decompress empty stream)
-        if (n == 0)
-        {
-            return;
-        }
-
-        if (n != 10)
-        {
-            throw new ZlibException("Not a valid GZIP stream.");
-        }
-
-        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
-        {
-            throw new ZlibException("Bad GZIP header.");
-        }
-
-        var timet = BinaryPrimitives.ReadInt32LittleEndian(header.AsSpan().Slice(4));
-        DateModified = TarHeader.EPOCH.AddSeconds(timet);
-        if ((header[3] & 0x04) == 0x04)
-        {
-            // read and discard extra field
-            var lengthField = new byte[2];
-            _ = await _stream.ReadAsync(lengthField, 0, 2, cancellationToken);
-
-            var extraLength = (short)(lengthField[0] + (lengthField[1] * 256));
-            var extra = new byte[extraLength];
-
-            if (!await _stream.ReadFullyAsync(extra, cancellationToken))
-            {
-                throw new ZlibException("Unexpected end-of-file reading GZIP header.");
-            }
-        }
-        if ((header[3] & 0x08) == 0x08)
-        {
-            _name = await ReadZeroTerminatedStringAsync(_stream, cancellationToken);
-        }
-        if ((header[3] & 0x10) == 0x010)
-        {
-            await ReadZeroTerminatedStringAsync(_stream, cancellationToken);
-        }
-        if ((header[3] & 0x02) == 0x02)
-        {
-            var buf = new byte[1];
-            _ = await _stream.ReadAsync(buf, 0, 1, cancellationToken); // CRC16, ignore
-        }
-    }
-
     private string ReadZeroTerminatedString(Stream stream)
     {
         Span<byte> buf1 = stackalloc byte[1];
@@ -231,33 +143,4 @@ internal sealed class GZipFilePart : FilePart
         var buffer = list.ToArray();
         return ArchiveEncoding.Decode(buffer);
     }
-
-    private async ValueTask<string> ReadZeroTerminatedStringAsync(
-        Stream stream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var buf1 = new byte[1];
-        var list = new List<byte>();
-        var done = false;
-        do
-        {
-            // workitem 7740
-            var n = await stream.ReadAsync(buf1, 0, 1, cancellationToken);
-            if (n != 1)
-            {
-                throw new ZlibException("Unexpected EOF reading GZIP header.");
-            }
-            if (buf1[0] == 0)
-            {
-                done = true;
-            }
-            else
-            {
-                list.Add(buf1[0]);
-            }
-        } while (!done);
-        var buffer = list.ToArray();
-        return ArchiveEncoding.Decode(buffer);
-    }
 }

src/SharpCompress/Common/IVolume.cs

@@ -2,7 +2,7 @@ using System;
 
 namespace SharpCompress.Common;
 
-public interface IVolume : IDisposable
+public interface IVolume : IDisposable, IAsyncDisposable
 {
     int Index { get; }
 

src/SharpCompress/Common/Rar/AsyncMarkingBinaryReader.cs

@@ -41,25 +41,21 @@ internal class AsyncMarkingBinaryReader
     {
         CurrentReadByteCount += count;
         var bytes = new byte[count];
-        await _reader.ReadBytesAsync(bytes, 0, count,  cancellationToken).ConfigureAwait(false);
+        await _reader.ReadBytesAsync(bytes, 0, count, cancellationToken).ConfigureAwait(false);
         return bytes;
     }
 
-    public async ValueTask<ushort> ReadUInt16Async(
-        CancellationToken cancellationToken = default
-    )
+    public async ValueTask<ushort> ReadUInt16Async(CancellationToken cancellationToken = default)
     {
         CurrentReadByteCount += 2;
-        var bytes = await ReadBytesAsync( 2, cancellationToken).ConfigureAwait(false);
+        var bytes = await ReadBytesAsync(2, cancellationToken).ConfigureAwait(false);
         return BinaryPrimitives.ReadUInt16LittleEndian(bytes);
     }
 
-    public async ValueTask<uint> ReadUInt32Async(
-        CancellationToken cancellationToken = default
-    )
+    public async ValueTask<uint> ReadUInt32Async(CancellationToken cancellationToken = default)
     {
         CurrentReadByteCount += 4;
-        var bytes =  await ReadBytesAsync( 4, cancellationToken).ConfigureAwait(false);
+        var bytes = await ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
         return BinaryPrimitives.ReadUInt32LittleEndian(bytes);
     }
 
@@ -68,7 +64,7 @@ internal class AsyncMarkingBinaryReader
     )
     {
         CurrentReadByteCount += 8;
-        var bytes = await ReadBytesAsync( 8, cancellationToken).ConfigureAwait(false);
+        var bytes = await ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
         return BinaryPrimitives.ReadUInt64LittleEndian(bytes);
     }
 
@@ -86,7 +82,7 @@ internal class AsyncMarkingBinaryReader
     )
     {
         CurrentReadByteCount += 4;
-        var bytes =  await ReadBytesAsync( 4, cancellationToken).ConfigureAwait(false);
+        var bytes = await ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
         return BinaryPrimitives.ReadInt32LittleEndian(bytes);
     }
 
@@ -95,7 +91,7 @@ internal class AsyncMarkingBinaryReader
     )
     {
         CurrentReadByteCount += 8;
-        var bytes =  await ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
+        var bytes = await ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
         return BinaryPrimitives.ReadInt64LittleEndian(bytes);
     }
 
@@ -132,16 +128,35 @@ internal class AsyncMarkingBinaryReader
 
         throw new FormatException("malformed vint");
     }
-    public async ValueTask<uint> ReadRarVIntUInt32Async(int maxBytes = 5, CancellationToken cancellationToken = default) =>
+
+    public async ValueTask<uint> ReadRarVIntUInt32Async(
+        int maxBytes = 5,
+        CancellationToken cancellationToken = default
+    ) =>
         // hopefully this gets inlined
         await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false);
 
-    public async ValueTask<ushort> ReadRarVIntUInt16Async(int maxBytes = 3, CancellationToken cancellationToken = default) =>
+    public async ValueTask<ushort> ReadRarVIntUInt16Async(
+        int maxBytes = 3,
+        CancellationToken cancellationToken = default
+    ) =>
         // hopefully this gets inlined
-        checked((ushort)await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false));
-    public async ValueTask<byte> ReadRarVIntByteAsync(int maxBytes = 2, CancellationToken cancellationToken = default) =>
+        checked(
+            (ushort)
+                await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken)
+                    .ConfigureAwait(false)
+        );
+
+    public async ValueTask<byte> ReadRarVIntByteAsync(
+        int maxBytes = 2,
+        CancellationToken cancellationToken = default
+    ) =>
         // hopefully this gets inlined
-        checked((byte)await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken).ConfigureAwait(false));
+        checked(
+            (byte)
+                await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken)
+                    .ConfigureAwait(false)
+        );
 
     public async ValueTask SkipAsync(int count, CancellationToken cancellationToken = default)
     {
@@ -149,7 +164,10 @@ internal class AsyncMarkingBinaryReader
         await _reader.SkipAsync(count, cancellationToken).ConfigureAwait(false);
     }
 
-    private async ValueTask<uint> DoReadRarVIntUInt32Async(int maxShift, CancellationToken cancellationToken = default)
+    private async ValueTask<uint> DoReadRarVIntUInt32Async(
+        int maxShift,
+        CancellationToken cancellationToken = default
+    )
     {
         var shift = 0;
         uint result = 0;

src/SharpCompress/Common/Rar/AsyncRarCryptoBinaryReader.cs

@@ -15,11 +15,13 @@ internal sealed class AsyncRarCryptoBinaryReader : AsyncRarCrcBinaryReader
     private long _readCount;
 
     private AsyncRarCryptoBinaryReader(Stream stream)
-        : base(stream)
-    {
-    }
+        : base(stream) { }
 
-    public static async ValueTask<AsyncRarCryptoBinaryReader> Create(Stream stream, ICryptKey cryptKey, byte[]? salt = null)
+    public static async ValueTask<AsyncRarCryptoBinaryReader> Create(
+        Stream stream,
+        ICryptKey cryptKey,
+        byte[]? salt = null
+    )
     {
         var binary = new AsyncRarCryptoBinaryReader(stream);
         if (salt == null)
@@ -31,7 +33,6 @@ internal sealed class AsyncRarCryptoBinaryReader : AsyncRarCrcBinaryReader
         return binary;
     }
 
-
     public override long CurrentReadByteCount
     {
         get => _readCount;

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

@@ -0,0 +1,32 @@
+#nullable disable
+
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal sealed partial class ArchiveCryptHeader
+{
+    public static async ValueTask<ArchiveCryptHeader> CreateAsync(
+        RarHeader header,
+        AsyncRarCrcBinaryReader reader,
+        CancellationToken cancellationToken = default
+    ) =>
+        await CreateChildAsync<ArchiveCryptHeader>(
+                header,
+                reader,
+                HeaderType.Crypt,
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+
+    protected sealed override async ValueTask ReadFinishAsync(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        CryptInfo = await Rar5CryptoInfo.CreateAsync(reader, false);
+    }
+}

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

@@ -1,40 +1,17 @@
 #nullable disable
 
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-internal class ArchiveCryptHeader : RarHeader
+internal sealed partial class ArchiveCryptHeader : RarHeader
 {
     public static ArchiveCryptHeader Create(RarHeader header, RarCrcBinaryReader reader) =>
         CreateChild<ArchiveCryptHeader>(header, reader, HeaderType.Crypt);
 
-    public static async ValueTask<ArchiveCryptHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<ArchiveCryptHeader>(
-                header,
-                reader,
-                HeaderType.Crypt,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-
     public Rar5CryptoInfo CryptInfo = default!;
 
-    protected override void ReadFinish(MarkingBinaryReader reader) =>
+    protected sealed override void ReadFinish(MarkingBinaryReader reader) =>
         CryptInfo = Rar5CryptoInfo.Create(reader, false);
-
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        CryptInfo = await Rar5CryptoInfo.CreateAsync(reader, false);
-    }
 }

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

@@ -0,0 +1,53 @@
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal sealed partial class ArchiveHeader
+{
+    public static async ValueTask<ArchiveHeader> CreateAsync(
+        RarHeader header,
+        AsyncRarCrcBinaryReader reader,
+        CancellationToken cancellationToken = default
+    ) =>
+        await CreateChildAsync<ArchiveHeader>(header, reader, HeaderType.Archive, cancellationToken)
+            .ConfigureAwait(false);
+
+    protected sealed override async ValueTask ReadFinishAsync(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (IsRar5)
+        {
+            Flags = await reader
+                .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+            if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
+            {
+                VolumeNumber = (int)
+                    await reader
+                        .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
+                        .ConfigureAwait(false);
+            }
+            // later: we may have a locator record if we need it
+            //if (ExtraSize != 0) {
+            //    ReadLocator(reader);
+            //}
+        }
+        else
+        {
+            Flags = HeaderFlags;
+            HighPosAv = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
+            PosAv = await reader.ReadInt32Async(cancellationToken).ConfigureAwait(false);
+            if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
+            {
+                EncryptionVersion = await reader
+                    .ReadByteAsync(cancellationToken)
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+}

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

@@ -1,24 +1,14 @@
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-internal sealed class ArchiveHeader : RarHeader
+internal sealed partial class ArchiveHeader : RarHeader
 {
     public static ArchiveHeader Create(RarHeader header, RarCrcBinaryReader reader) =>
         CreateChild<ArchiveHeader>(header, reader, HeaderType.Archive);
 
-    public static async ValueTask<ArchiveHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<ArchiveHeader>(header, reader, HeaderType.Archive, cancellationToken)
-            .ConfigureAwait(false);
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    protected sealed override void ReadFinish(MarkingBinaryReader reader)
     {
         if (IsRar5)
         {
@@ -44,38 +34,6 @@ internal sealed class ArchiveHeader : RarHeader
         }
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        if (IsRar5)
-        {
-            Flags = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            if (HasFlag(ArchiveFlagsV5.HAS_VOLUME_NUMBER))
-            {
-                VolumeNumber = (int)
-                    await reader.ReadRarVIntUInt32Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            }
-            // later: we may have a locator record if we need it
-            //if (ExtraSize != 0) {
-            //    ReadLocator(reader);
-            //}
-        }
-        else
-        {
-            Flags = HeaderFlags;
-            HighPosAv = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-            PosAv = await reader.ReadInt32Async(cancellationToken).ConfigureAwait(false);
-            if (HasFlag(ArchiveFlagsV4.ENCRYPT_VER))
-            {
-                EncryptionVersion = await reader
-                    .ReadByteAsync(cancellationToken)
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     private ushort Flags { get; set; }
 
     private bool HasFlag(ushort flag) => (Flags & flag) == flag;

src/SharpCompress/Common/Rar/Headers/EndArchiveHeader.Async.cs

@@ -0,0 +1,47 @@
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal sealed partial class EndArchiveHeader
+{
+    public static async ValueTask<EndArchiveHeader> CreateAsync(
+        RarHeader header,
+        AsyncRarCrcBinaryReader reader,
+        CancellationToken cancellationToken = default
+    ) =>
+        await CreateChildAsync<EndArchiveHeader>(
+                header,
+                reader,
+                HeaderType.EndArchive,
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+
+    protected sealed override async ValueTask ReadFinishAsync(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (IsRar5)
+        {
+            Flags = await reader
+                .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+        }
+        else
+        {
+            Flags = HeaderFlags;
+            if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
+            {
+                ArchiveCrc = await reader.ReadInt32Async(cancellationToken).ConfigureAwait(false);
+            }
+            if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
+            {
+                VolumeNumber = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
+            }
+        }
+    }
+}

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

@@ -1,29 +1,14 @@
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-internal class EndArchiveHeader : RarHeader
+internal sealed partial class EndArchiveHeader : RarHeader
 {
     public static EndArchiveHeader Create(RarHeader header, RarCrcBinaryReader reader) =>
         CreateChild<EndArchiveHeader>(header, reader, HeaderType.EndArchive);
 
-    public static async ValueTask<EndArchiveHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<EndArchiveHeader>(
-                header,
-                reader,
-                HeaderType.EndArchive,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    protected sealed override void ReadFinish(MarkingBinaryReader reader)
     {
         if (IsRar5)
         {
@@ -43,29 +28,6 @@ internal class EndArchiveHeader : RarHeader
         }
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        if (IsRar5)
-        {
-            Flags = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            Flags = HeaderFlags;
-            if (HasFlag(EndArchiveFlagsV4.DATA_CRC))
-            {
-                ArchiveCrc = await reader.ReadInt32Async(cancellationToken).ConfigureAwait(false);
-            }
-            if (HasFlag(EndArchiveFlagsV4.VOLUME_NUMBER))
-            {
-                VolumeNumber = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-            }
-        }
-    }
-
     private ushort Flags { get; set; }
 
     private bool HasFlag(ushort flag) => (Flags & flag) == flag;

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

@@ -0,0 +1,441 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+#if !Rar2017_64bit
+using size_t = System.UInt32;
+#else
+using nint = System.Int64;
+using nuint = System.UInt64;
+using size_t = System.UInt64;
+#endif
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal partial class FileHeader
+{
+    public static async ValueTask<FileHeader> CreateAsync(
+        RarHeader header,
+        AsyncRarCrcBinaryReader reader,
+        HeaderType headerType,
+        CancellationToken cancellationToken = default
+    ) =>
+        await CreateChildAsync<FileHeader>(header, reader, headerType, cancellationToken)
+            .ConfigureAwait(false);
+
+    protected override async ValueTask ReadFinishAsync(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken
+    )
+    {
+        if (IsRar5)
+        {
+            await ReadFromReaderV5Async(reader, cancellationToken).ConfigureAwait(false);
+        }
+        else
+        {
+            await ReadFromReaderV4Async(reader, cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    private async ValueTask ReadFromReaderV5Async(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken
+    )
+    {
+        Flags = await reader
+            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+
+        var lvalue = checked(
+            (long)
+                await reader
+                    .ReadRarVIntAsync(cancellationToken: cancellationToken)
+                    .ConfigureAwait(false)
+        );
+
+        UncompressedSize = HasFlag(FileFlagsV5.UNPACKED_SIZE_UNKNOWN) ? long.MaxValue : lvalue;
+
+        FileAttributes = await reader
+            .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+
+        if (HasFlag(FileFlagsV5.HAS_MOD_TIME))
+        {
+            FileLastModifiedTime = Utility.UnixTimeToDateTime(
+                await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
+            );
+        }
+
+        if (HasFlag(FileFlagsV5.HAS_CRC32))
+        {
+            FileCrc = await reader.ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
+        }
+
+        var compressionInfo = await reader
+            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+
+        CompressionAlgorithm = (byte)((compressionInfo & 0x3f) + 50);
+        IsSolid = (compressionInfo & 0x40) == 0x40;
+        CompressionMethod = (byte)((compressionInfo >> 7) & 0x7);
+        WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo >> 10) & 0xf);
+
+        HostOs = await reader
+            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+
+        var nameSize = await reader
+            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+            .ConfigureAwait(false);
+
+        var b = await reader.ReadBytesAsync(nameSize, cancellationToken).ConfigureAwait(false);
+        FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
+
+        if (ExtraSize != (uint)RemainingHeaderBytesAsync(reader))
+        {
+            throw new InvalidFormatException("rar5 header size / extra size inconsistency");
+        }
+
+        const ushort FHEXTRA_CRYPT = 0x01;
+        const ushort FHEXTRA_HASH = 0x02;
+        const ushort FHEXTRA_HTIME = 0x03;
+        const ushort FHEXTRA_REDIR = 0x05;
+
+        while (reader.CurrentReadByteCount < HeaderSize)
+        {
+            var size = await reader
+                .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+            var n = HeaderSize - reader.CurrentReadByteCount;
+            var type = await reader
+                .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+            switch (type)
+            {
+                case FHEXTRA_CRYPT:
+                    {
+                        Rar5CryptoInfo = await Rar5CryptoInfo.CreateAsync(reader, true);
+                        if (Rar5CryptoInfo.PswCheck.All(singleByte => singleByte == 0))
+                        {
+                            Rar5CryptoInfo = null;
+                        }
+                    }
+                    break;
+                case FHEXTRA_HASH:
+                    {
+                        const uint FHEXTRA_HASH_BLAKE2 = 0x0;
+                        const int BLAKE2_DIGEST_SIZE = 0x20;
+                        if (
+                            await reader
+                                .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
+                                .ConfigureAwait(false) == FHEXTRA_HASH_BLAKE2
+                        )
+                        {
+                            _hash = await reader
+                                .ReadBytesAsync(BLAKE2_DIGEST_SIZE, cancellationToken)
+                                .ConfigureAwait(false);
+                        }
+                    }
+                    break;
+                case FHEXTRA_HTIME:
+                    {
+                        var flags = await reader
+                            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+                            .ConfigureAwait(false);
+                        var isWindowsTime = (flags & 1) == 0;
+                        if ((flags & 0x2) == 0x2)
+                        {
+                            FileLastModifiedTime = await ReadExtendedTimeV5Async(
+                                    reader,
+                                    isWindowsTime,
+                                    cancellationToken
+                                )
+                                .ConfigureAwait(false);
+                        }
+                        if ((flags & 0x4) == 0x4)
+                        {
+                            FileCreatedTime = await ReadExtendedTimeV5Async(
+                                    reader,
+                                    isWindowsTime,
+                                    cancellationToken
+                                )
+                                .ConfigureAwait(false);
+                        }
+                        if ((flags & 0x8) == 0x8)
+                        {
+                            FileLastAccessedTime = await ReadExtendedTimeV5Async(
+                                    reader,
+                                    isWindowsTime,
+                                    cancellationToken
+                                )
+                                .ConfigureAwait(false);
+                        }
+                    }
+                    break;
+                case FHEXTRA_REDIR:
+                    {
+                        RedirType = await reader
+                            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
+                            .ConfigureAwait(false);
+                        RedirFlags = await reader
+                            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
+                            .ConfigureAwait(false);
+                        var nn = await reader
+                            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
+                            .ConfigureAwait(false);
+                        var bb = await reader
+                            .ReadBytesAsync(nn, cancellationToken)
+                            .ConfigureAwait(false);
+                        RedirTargetName = ConvertPathV5(Encoding.UTF8.GetString(bb, 0, bb.Length));
+                    }
+                    break;
+                default:
+                    break;
+            }
+            var did = (int)(n - (HeaderSize - reader.CurrentReadByteCount));
+            var drain = size - did;
+            if (drain > 0)
+            {
+                await reader.ReadBytesAsync(drain, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        if (AdditionalDataSize != 0)
+        {
+            CompressedSize = AdditionalDataSize;
+        }
+    }
+
+    private async ValueTask ReadFromReaderV4Async(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken
+    )
+    {
+        Flags = HeaderFlags;
+        IsSolid = HasFlag(FileFlagsV4.SOLID);
+        WindowSize = IsDirectory
+            ? 0U
+            : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);
+
+        var lowUncompressedSize = await reader
+            .ReadUInt32Async(cancellationToken)
+            .ConfigureAwait(false);
+
+        HostOs = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
+
+        FileCrc = await reader.ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
+
+        FileLastModifiedTime = Utility.DosDateToDateTime(
+            await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
+        );
+
+        CompressionAlgorithm = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
+        CompressionMethod = (byte)(
+            (await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false)) - 0x30
+        );
+
+        var nameSize = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
+
+        FileAttributes = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
+
+        uint highCompressedSize = 0;
+        uint highUncompressedkSize = 0;
+        if (HasFlag(FileFlagsV4.LARGE))
+        {
+            highCompressedSize = await reader
+                .ReadUInt32Async(cancellationToken)
+                .ConfigureAwait(false);
+            highUncompressedkSize = await reader
+                .ReadUInt32Async(cancellationToken)
+                .ConfigureAwait(false);
+        }
+        else
+        {
+            if (lowUncompressedSize == 0xffffffff)
+            {
+                lowUncompressedSize = 0xffffffff;
+                highUncompressedkSize = int.MaxValue;
+            }
+        }
+        CompressedSize = UInt32To64(highCompressedSize, checked((uint)AdditionalDataSize));
+        UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
+
+        nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
+
+        var fileNameBytes = await reader
+            .ReadBytesAsync(nameSize, cancellationToken)
+            .ConfigureAwait(false);
+
+        const int newLhdSize = 32;
+
+        switch (HeaderCode)
+        {
+            case HeaderCodeV.RAR4_FILE_HEADER:
+                {
+                    if (HasFlag(FileFlagsV4.UNICODE))
+                    {
+                        var length = 0;
+                        while (length < fileNameBytes.Length && fileNameBytes[length] != 0)
+                        {
+                            length++;
+                        }
+                        if (length != nameSize)
+                        {
+                            length++;
+                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
+                        }
+                        else
+                        {
+                            FileName = ArchiveEncoding.Decode(fileNameBytes);
+                        }
+                    }
+                    else
+                    {
+                        FileName = ArchiveEncoding.Decode(fileNameBytes);
+                    }
+                    FileName = ConvertPathV4(FileName);
+                }
+                break;
+            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+                {
+                    var datasize = HeaderSize - newLhdSize - nameSize;
+                    if (HasFlag(FileFlagsV4.SALT))
+                    {
+                        datasize -= EncryptionConstV5.SIZE_SALT30;
+                    }
+                    if (datasize > 0)
+                    {
+                        SubData = await reader
+                            .ReadBytesAsync(datasize, cancellationToken)
+                            .ConfigureAwait(false);
+                    }
+
+                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes.Take(4).ToArray()))
+                    {
+                        if (SubData is null)
+                        {
+                            throw new InvalidFormatException();
+                        }
+                        RecoverySectors =
+                            SubData[8]
+                            + (SubData[9] << 8)
+                            + (SubData[10] << 16)
+                            + (SubData[11] << 24);
+                    }
+                }
+                break;
+        }
+
+        if (HasFlag(FileFlagsV4.SALT))
+        {
+            R4Salt = await reader.ReadBytesAsync(EncryptionConstV5.SIZE_SALT30, cancellationToken);
+        }
+        if (HasFlag(FileFlagsV4.EXT_TIME))
+        {
+            if (reader.CurrentReadByteCount >= 2)
+            {
+                var extendedFlags = await reader
+                    .ReadUInt16Async(cancellationToken)
+                    .ConfigureAwait(false);
+                if (FileLastModifiedTime is not null)
+                {
+                    FileLastModifiedTime = await ProcessExtendedTimeV4Async(
+                            extendedFlags,
+                            FileLastModifiedTime,
+                            reader,
+                            0,
+                            cancellationToken
+                        )
+                        .ConfigureAwait(false);
+                }
+
+                FileCreatedTime = await ProcessExtendedTimeV4Async(
+                        extendedFlags,
+                        null,
+                        reader,
+                        1,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+                FileLastAccessedTime = await ProcessExtendedTimeV4Async(
+                        extendedFlags,
+                        null,
+                        reader,
+                        2,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+                FileArchivedTime = await ProcessExtendedTimeV4Async(
+                        extendedFlags,
+                        null,
+                        reader,
+                        3,
+                        cancellationToken
+                    )
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    private static async ValueTask<DateTime> ReadExtendedTimeV5Async(
+        AsyncMarkingBinaryReader reader,
+        bool isWindowsTime,
+        CancellationToken cancellationToken
+    )
+    {
+        if (isWindowsTime)
+        {
+            return DateTime.FromFileTime(
+                await reader.ReadInt64Async(cancellationToken).ConfigureAwait(false)
+            );
+        }
+        else
+        {
+            return Utility.UnixTimeToDateTime(
+                await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
+            );
+        }
+    }
+
+    private static async ValueTask<DateTime?> ProcessExtendedTimeV4Async(
+        ushort extendedFlags,
+        DateTime? time,
+        AsyncMarkingBinaryReader reader,
+        int i,
+        CancellationToken cancellationToken
+    )
+    {
+        var rmode = (uint)extendedFlags >> ((3 - i) * 4);
+        if ((rmode & 8) == 0)
+        {
+            return null;
+        }
+        if (i != 0)
+        {
+            var dosTime = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
+            time = Utility.DosDateToDateTime(dosTime);
+        }
+        if ((rmode & 4) == 0 && time is not null)
+        {
+            time = time.Value.AddSeconds(1);
+        }
+        uint nanosecondHundreds = 0;
+        var count = (int)rmode & 3;
+        for (var j = 0; j < count; j++)
+        {
+            var b = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
+            nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
+        }
+
+        if (time is not null)
+        {
+            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
+        }
+        return null;
+    }
+}

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

@@ -16,7 +16,7 @@ using size_t = System.UInt64;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-internal class FileHeader : RarHeader
+internal partial class FileHeader : RarHeader
 {
     private byte[]? _hash;
 
@@ -26,15 +26,6 @@ internal class FileHeader : RarHeader
         HeaderType headerType
     ) => CreateChild<FileHeader>(header, reader, headerType);
 
-    public static async ValueTask<FileHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        HeaderType headerType,
-        CancellationToken cancellationToken = default
-    ) =>
-        await CreateChildAsync<FileHeader>(header, reader, headerType, cancellationToken)
-            .ConfigureAwait(false);
-
     protected override void ReadFinish(MarkingBinaryReader reader)
     {
         if (IsRar5)
@@ -47,21 +38,6 @@ internal class FileHeader : RarHeader
         }
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        if (IsRar5)
-        {
-            await ReadFromReaderV5Async(reader, cancellationToken).ConfigureAwait(false);
-        }
-        else
-        {
-            await ReadFromReaderV4Async(reader, cancellationToken).ConfigureAwait(false);
-        }
-    }
-
     private void ReadFromReaderV5(MarkingBinaryReader reader)
     {
         Flags = reader.ReadRarVIntUInt16();
@@ -106,23 +82,6 @@ internal class FileHeader : RarHeader
 
         var nameSize = reader.ReadRarVIntUInt16();
 
-        // Variable length field containing Name length bytes in UTF-8 format without trailing zero.
-        // For file header this is a name of archived file. Forward slash character is used as the path separator both for Unix and Windows names.
-        // Backslashes are treated as a part of name for Unix names and as invalid character for Windows file names. Type of name is defined by Host OS field.
-        //
-        // TODO: not sure if anything needs to be done to handle the following:
-        // If Unix file name contains any high ASCII characters which cannot be correctly converted to Unicode and UTF-8
-        // we map such characters to to 0xE080 - 0xE0FF private use Unicode area and insert 0xFFFE Unicode non-character
-        // to resulting string to indicate that it contains mapped characters, which need to be converted back when extracting.
-        // Concrete position of 0xFFFE is not defined, we need to search the entire string for it. Such mapped names are not
-        // portable and can be correctly unpacked only on the same system where they were created.
-        //
-        // For service header this field contains a name of service header. Now the following names are used:
-        // CMT	Archive comment
-        // QO	Archive quick open data
-        // ACL	NTFS file permissions
-        // STM	NTFS alternate data stream
-        // RR	Recovery record
         var b = reader.ReadBytes(nameSize);
         FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
 
@@ -149,7 +108,7 @@ internal class FileHeader : RarHeader
             {
                 case FHEXTRA_CRYPT: // file encryption
                     {
-                        Rar5CryptoInfo =  Rar5CryptoInfo.Create(reader, true);
+                        Rar5CryptoInfo = Rar5CryptoInfo.Create(reader, true);
 
                         if (Rar5CryptoInfo.PswCheck.All(singleByte => singleByte == 0))
                         {
@@ -160,14 +119,11 @@ internal class FileHeader : RarHeader
                 case FHEXTRA_HASH:
                     {
                         const uint FHEXTRA_HASH_BLAKE2 = 0x0;
-                        //                        const uint HASH_BLAKE2 = 0x03;
                         const int BLAKE2_DIGEST_SIZE = 0x20;
                         if ((uint)reader.ReadRarVInt() == FHEXTRA_HASH_BLAKE2)
                         {
-                            //                            var hash = HASH_BLAKE2;
                             _hash = reader.ReadBytes(BLAKE2_DIGEST_SIZE);
                         }
-                        // enum HASH_TYPE {HASH_NONE,HASH_RAR14,HASH_CRC32,HASH_BLAKE2};
                     }
                     break;
                 case FHEXTRA_HTIME: // file time
@@ -188,12 +144,6 @@ internal class FileHeader : RarHeader
                         }
                     }
                     break;
-                //TODO
-                //                    case FHEXTRA_VERSION: // file version
-                //                        {
-                //
-                //                        }
-                //                        break;
                 case FHEXTRA_REDIR: // file system redirection
                     {
                         RedirType = reader.ReadRarVIntByte();
@@ -203,21 +153,7 @@ internal class FileHeader : RarHeader
                         RedirTargetName = ConvertPathV5(Encoding.UTF8.GetString(bb, 0, bb.Length));
                     }
                     break;
-                //TODO
-                //                    case FHEXTRA_UOWNER: // unix owner
-                //                        {
-                //
-                //                        }
-                //                        break;
-                //                    case FHEXTRA_SUBDATA: // service data
-                //                        {
-                //
-                //                        }
-                //                        break;
-
                 default:
-                    // skip unknown record types to allow new record types to be added in the future
-                    //Console.WriteLine($"unhandled rar header field type {type}");
                     break;
             }
             // drain any trailing bytes of extra record
@@ -366,8 +302,6 @@ internal class FileHeader : RarHeader
         }
         if (HasFlag(FileFlagsV4.EXT_TIME))
         {
-            // verify that the end of the header hasn't been reached before reading the Extended Time.
-            //  some tools incorrectly omit Extended Time despite specifying FileFlags.EXTTIME, which most parsers tolerate.
             if (RemainingHeaderBytes(reader) >= 2)
             {
                 var extendedFlags = reader.ReadUInt16();
@@ -445,391 +379,6 @@ internal class FileHeader : RarHeader
         return path;
     }
 
-    private async ValueTask ReadFromReaderV5Async(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        Flags = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-
-        var lvalue = checked(
-            (long)await reader.ReadRarVIntAsync(cancellationToken: cancellationToken).ConfigureAwait(false)
-        );
-
-        UncompressedSize = HasFlag(FileFlagsV5.UNPACKED_SIZE_UNKNOWN) ? long.MaxValue : lvalue;
-
-        FileAttributes = await reader
-            .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
-            .ConfigureAwait(false);
-
-        if (HasFlag(FileFlagsV5.HAS_MOD_TIME))
-        {
-            FileLastModifiedTime = Utility.UnixTimeToDateTime(
-                await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
-            );
-        }
-
-        if (HasFlag(FileFlagsV5.HAS_CRC32))
-        {
-            FileCrc = await reader.ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
-        }
-
-        var compressionInfo = await reader
-            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
-            .ConfigureAwait(false);
-
-        CompressionAlgorithm = (byte)((compressionInfo & 0x3f) + 50);
-        IsSolid = (compressionInfo & 0x40) == 0x40;
-        CompressionMethod = (byte)((compressionInfo >> 7) & 0x7);
-        WindowSize = IsDirectory ? 0 : ((size_t)0x20000) << ((compressionInfo >> 10) & 0xf);
-
-        HostOs = await reader.ReadRarVIntByteAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-
-        var nameSize = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-
-        var b = await reader.ReadBytesAsync(nameSize, cancellationToken).ConfigureAwait(false);
-        FileName = ConvertPathV5(Encoding.UTF8.GetString(b, 0, b.Length));
-
-        if (ExtraSize != (uint)RemainingHeaderBytesAsync(reader))
-        {
-            throw new InvalidFormatException("rar5 header size / extra size inconsistency");
-        }
-
-        const ushort FHEXTRA_CRYPT = 0x01;
-        const ushort FHEXTRA_HASH = 0x02;
-        const ushort FHEXTRA_HTIME = 0x03;
-        const ushort FHEXTRA_REDIR = 0x05;
-
-        while (reader.CurrentReadByteCount < HeaderSize)
-        {
-            var size = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            var n = HeaderSize - reader.CurrentReadByteCount;
-            var type = await reader.ReadRarVIntUInt16Async(cancellationToken: cancellationToken).ConfigureAwait(false);
-            switch (type)
-            {
-                case FHEXTRA_CRYPT:
-                    {
-                        Rar5CryptoInfo = await Rar5CryptoInfo.CreateAsync(reader, true);
-                        if (Rar5CryptoInfo.PswCheck.All(singleByte => singleByte == 0))
-                        {
-                            Rar5CryptoInfo = null;
-                        }
-                    }
-                    break;
-                case FHEXTRA_HASH:
-                    {
-                        const uint FHEXTRA_HASH_BLAKE2 = 0x0;
-                        const int BLAKE2_DIGEST_SIZE = 0x20;
-                        if (
-
-                                await reader
-                                    .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
-                                    .ConfigureAwait(false) == FHEXTRA_HASH_BLAKE2
-                        )
-                        {
-                            _hash = await reader
-                                .ReadBytesAsync(BLAKE2_DIGEST_SIZE, cancellationToken)
-                                .ConfigureAwait(false);
-                        }
-                    }
-                    break;
-                case FHEXTRA_HTIME:
-                    {
-                        var flags = await reader
-                            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        var isWindowsTime = (flags & 1) == 0;
-                        if ((flags & 0x2) == 0x2)
-                        {
-                            FileLastModifiedTime = await ReadExtendedTimeV5Async(
-                                    reader,
-                                    isWindowsTime,
-                                    cancellationToken
-                                )
-                                .ConfigureAwait(false);
-                        }
-                        if ((flags & 0x4) == 0x4)
-                        {
-                            FileCreatedTime = await ReadExtendedTimeV5Async(
-                                    reader,
-                                    isWindowsTime,
-                                    cancellationToken
-                                )
-                                .ConfigureAwait(false);
-                        }
-                        if ((flags & 0x8) == 0x8)
-                        {
-                            FileLastAccessedTime = await ReadExtendedTimeV5Async(
-                                    reader,
-                                    isWindowsTime,
-                                    cancellationToken
-                                )
-                                .ConfigureAwait(false);
-                        }
-                    }
-                    break;
-                case FHEXTRA_REDIR:
-                    {
-                        RedirType = await reader
-                            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        RedirFlags = await reader
-                            .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        var nn = await reader
-                            .ReadRarVIntUInt16Async(cancellationToken: cancellationToken)
-                            .ConfigureAwait(false);
-                        var bb = await reader
-                            .ReadBytesAsync(nn, cancellationToken)
-                            .ConfigureAwait(false);
-                        RedirTargetName = ConvertPathV5(Encoding.UTF8.GetString(bb, 0, bb.Length));
-                    }
-                    break;
-                default:
-                    break;
-            }
-            var did = (int)(n - (HeaderSize - reader.CurrentReadByteCount));
-            var drain = size - did;
-            if (drain > 0)
-            {
-                await reader.ReadBytesAsync(drain, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        if (AdditionalDataSize != 0)
-        {
-            CompressedSize = AdditionalDataSize;
-        }
-    }
-
-    private async ValueTask ReadFromReaderV4Async(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        Flags = HeaderFlags;
-        IsSolid = HasFlag(FileFlagsV4.SOLID);
-        WindowSize = IsDirectory
-            ? 0U
-            : ((size_t)0x10000) << ((Flags & FileFlagsV4.WINDOW_MASK) >> 5);
-
-        var lowUncompressedSize = await reader
-            .ReadUInt32Async(cancellationToken)
-            .ConfigureAwait(false);
-
-        HostOs = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-
-        FileCrc = await reader.ReadBytesAsync(4, cancellationToken).ConfigureAwait(false);
-
-        FileLastModifiedTime = Utility.DosDateToDateTime(
-            await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
-        );
-
-        CompressionAlgorithm = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-        CompressionMethod = (byte)(
-            (await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false)) - 0x30
-        );
-
-        var nameSize = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-
-        FileAttributes = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-
-        uint highCompressedSize = 0;
-        uint highUncompressedkSize = 0;
-        if (HasFlag(FileFlagsV4.LARGE))
-        {
-            highCompressedSize = await reader
-                .ReadUInt32Async(cancellationToken)
-                .ConfigureAwait(false);
-            highUncompressedkSize = await reader
-                .ReadUInt32Async(cancellationToken)
-                .ConfigureAwait(false);
-        }
-        else
-        {
-            if (lowUncompressedSize == 0xffffffff)
-            {
-                lowUncompressedSize = 0xffffffff;
-                highUncompressedkSize = int.MaxValue;
-            }
-        }
-        CompressedSize = UInt32To64(highCompressedSize, checked((uint)AdditionalDataSize));
-        UncompressedSize = UInt32To64(highUncompressedkSize, lowUncompressedSize);
-
-        nameSize = nameSize > 4 * 1024 ? (short)(4 * 1024) : nameSize;
-
-        var fileNameBytes = await reader
-            .ReadBytesAsync(nameSize, cancellationToken)
-            .ConfigureAwait(false);
-
-        const int newLhdSize = 32;
-
-        switch (HeaderCode)
-        {
-            case HeaderCodeV.RAR4_FILE_HEADER:
-                {
-                    if (HasFlag(FileFlagsV4.UNICODE))
-                    {
-                        var length = 0;
-                        while (length < fileNameBytes.Length && fileNameBytes[length] != 0)
-                        {
-                            length++;
-                        }
-                        if (length != nameSize)
-                        {
-                            length++;
-                            FileName = FileNameDecoder.Decode(fileNameBytes, length);
-                        }
-                        else
-                        {
-                            FileName = ArchiveEncoding.Decode(fileNameBytes);
-                        }
-                    }
-                    else
-                    {
-                        FileName = ArchiveEncoding.Decode(fileNameBytes);
-                    }
-                    FileName = ConvertPathV4(FileName);
-                }
-                break;
-            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
-                {
-                    var datasize = HeaderSize - newLhdSize - nameSize;
-                    if (HasFlag(FileFlagsV4.SALT))
-                    {
-                        datasize -= EncryptionConstV5.SIZE_SALT30;
-                    }
-                    if (datasize > 0)
-                    {
-                        SubData = await reader
-                            .ReadBytesAsync(datasize, cancellationToken)
-                            .ConfigureAwait(false);
-                    }
-
-                    if (NewSubHeaderType.SUBHEAD_TYPE_RR.Equals(fileNameBytes.Take(4).ToArray()))
-                    {
-                        if (SubData is null)
-                        {
-                            throw new InvalidFormatException();
-                        }
-                        RecoverySectors =
-                            SubData[8]
-                            + (SubData[9] << 8)
-                            + (SubData[10] << 16)
-                            + (SubData[11] << 24);
-                    }
-                }
-                break;
-        }
-
-        if (HasFlag(FileFlagsV4.SALT))
-        {
-            R4Salt = await reader.ReadBytesAsync(EncryptionConstV5.SIZE_SALT30, cancellationToken);
-        }
-        if (HasFlag(FileFlagsV4.EXT_TIME))
-        {
-            if (reader.CurrentReadByteCount >= 2)
-            {
-                var extendedFlags = await reader
-                    .ReadUInt16Async(cancellationToken)
-                    .ConfigureAwait(false);
-                if (FileLastModifiedTime is not null)
-                {
-                    FileLastModifiedTime = await ProcessExtendedTimeV4Async(
-                            extendedFlags,
-                            FileLastModifiedTime,
-                            reader,
-                            0,
-                            cancellationToken
-                        )
-                        .ConfigureAwait(false);
-                }
-
-                FileCreatedTime = await ProcessExtendedTimeV4Async(
-                        extendedFlags,
-                        null,
-                        reader,
-                        1,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-                FileLastAccessedTime = await ProcessExtendedTimeV4Async(
-                        extendedFlags,
-                        null,
-                        reader,
-                        2,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-                FileArchivedTime = await ProcessExtendedTimeV4Async(
-                        extendedFlags,
-                        null,
-                        reader,
-                        3,
-                        cancellationToken
-                    )
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
-    private static async ValueTask<DateTime> ReadExtendedTimeV5Async(
-        AsyncMarkingBinaryReader reader,
-        bool isWindowsTime,
-        CancellationToken cancellationToken
-    )
-    {
-        if (isWindowsTime)
-        {
-            return DateTime.FromFileTime(
-                await reader.ReadInt64Async(cancellationToken).ConfigureAwait(false)
-            );
-        }
-        else
-        {
-            return Utility.UnixTimeToDateTime(
-                await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false)
-            );
-        }
-    }
-
-    private static async ValueTask<DateTime?> ProcessExtendedTimeV4Async(
-        ushort extendedFlags,
-        DateTime? time,
-        AsyncMarkingBinaryReader reader,
-        int i,
-        CancellationToken cancellationToken
-    )
-    {
-        var rmode = (uint)extendedFlags >> ((3 - i) * 4);
-        if ((rmode & 8) == 0)
-        {
-            return null;
-        }
-        if (i != 0)
-        {
-            var dosTime = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-            time = Utility.DosDateToDateTime(dosTime);
-        }
-        if ((rmode & 4) == 0 && time is not null)
-        {
-            time = time.Value.AddSeconds(1);
-        }
-        uint nanosecondHundreds = 0;
-        var count = (int)rmode & 3;
-        for (var j = 0; j < count; j++)
-        {
-            var b = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-            nanosecondHundreds |= (((uint)b) << ((j + 3 - count) * 8));
-        }
-
-        if (time is not null)
-        {
-            return time.Value.AddMilliseconds(nanosecondHundreds * Math.Pow(10, -4));
-        }
-        return null;
-    }
-
     public override string ToString() => FileName ?? "FileHeader";
 
     private ushort Flags { get; set; }

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

@@ -0,0 +1,132 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal partial class MarkHeader
+{
+    private static async ValueTask<byte> GetByteAsync(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = new byte[1];
+        var bytesRead = await stream
+            .ReadAsync(buffer, 0, 1, cancellationToken)
+            .ConfigureAwait(false);
+        if (bytesRead == 1)
+        {
+            return buffer[0];
+        }
+        throw new EndOfStreamException();
+    }
+
+    public static async ValueTask<MarkHeader> ReadAsync(
+        Stream stream,
+        bool leaveStreamOpen,
+        bool lookForHeader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
+        try
+        {
+            var start = -1;
+            var b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+            start++;
+            while (start <= maxScanIndex)
+            {
+                if (b == 0x52)
+                {
+                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                    start++;
+                    if (b == 0x61)
+                    {
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x72)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x21)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x1a)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x07)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b == 1)
+                        {
+                            b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                            start++;
+                            if (b != 0)
+                            {
+                                continue;
+                            }
+
+                            return new MarkHeader(true); // Rar5
+                        }
+                        else if (b == 0)
+                        {
+                            return new MarkHeader(false); // Rar4
+                        }
+                    }
+                    else if (b == 0x45)
+                    {
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x7e)
+                        {
+                            continue;
+                        }
+
+                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                        start++;
+                        if (b != 0x5e)
+                        {
+                            continue;
+                        }
+
+                        throw new InvalidFormatException(
+                            "Rar format version pre-4 is unsupported."
+                        );
+                    }
+                }
+                else
+                {
+                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
+                    start++;
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            if (!leaveStreamOpen)
+            {
+                stream.Dispose();
+            }
+            throw new InvalidFormatException("Error trying to read rar signature.", e);
+        }
+
+        throw new InvalidFormatException("Rar signature not found");
+    }
+}

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

@@ -5,7 +5,7 @@ using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-internal class MarkHeader : IRarHeader
+internal partial class MarkHeader : IRarHeader
 {
     private const int MAX_SFX_SIZE = 0x80000 - 16; //archive.cpp line 136
 
@@ -27,19 +27,6 @@ internal class MarkHeader : IRarHeader
         throw new EndOfStreamException();
     }
 
-    private static async Task<byte> GetByteAsync(Stream stream, CancellationToken cancellationToken)
-    {
-        var buffer = new byte[1];
-        var bytesRead = await stream
-            .ReadAsync(buffer, 0, 1, cancellationToken)
-            .ConfigureAwait(false);
-        if (bytesRead == 1)
-        {
-            return buffer[0];
-        }
-        throw new EndOfStreamException();
-    }
-
     public static MarkHeader Read(Stream stream, bool leaveStreamOpen, bool lookForHeader)
     {
         var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
@@ -144,111 +131,4 @@ internal class MarkHeader : IRarHeader
 
         throw new InvalidFormatException("Rar signature not found");
     }
-
-    public static async ValueTask<MarkHeader> ReadAsync(
-        Stream stream,
-        bool leaveStreamOpen,
-        bool lookForHeader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var maxScanIndex = lookForHeader ? MAX_SFX_SIZE : 0;
-        try
-        {
-            var start = -1;
-            var b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-            start++;
-            while (start <= maxScanIndex)
-            {
-                if (b == 0x52)
-                {
-                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                    start++;
-                    if (b == 0x61)
-                    {
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x72)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x21)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x1a)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x07)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b == 1)
-                        {
-                            b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                            start++;
-                            if (b != 0)
-                            {
-                                continue;
-                            }
-
-                            return new MarkHeader(true); // Rar5
-                        }
-                        else if (b == 0)
-                        {
-                            return new MarkHeader(false); // Rar4
-                        }
-                    }
-                    else if (b == 0x45)
-                    {
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x7e)
-                        {
-                            continue;
-                        }
-
-                        b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                        start++;
-                        if (b != 0x5e)
-                        {
-                            continue;
-                        }
-
-                        throw new InvalidFormatException(
-                            "Rar format version pre-4 is unsupported."
-                        );
-                    }
-                }
-                else
-                {
-                    b = await GetByteAsync(stream, cancellationToken).ConfigureAwait(false);
-                    start++;
-                }
-            }
-        }
-        catch (Exception e)
-        {
-            if (!leaveStreamOpen)
-            {
-                stream.Dispose();
-            }
-            throw new InvalidFormatException("Error trying to read rar signature.", e);
-        }
-
-        throw new InvalidFormatException("Rar signature not found");
-    }
 }

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

@@ -0,0 +1,40 @@
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal sealed partial class ProtectHeader
+{
+    public static async ValueTask<ProtectHeader> CreateAsync(
+        RarHeader header,
+        AsyncRarCrcBinaryReader reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var c = await CreateChildAsync<ProtectHeader>(
+                header,
+                reader,
+                HeaderType.Protect,
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+        if (c.IsRar5)
+        {
+            throw new InvalidFormatException("unexpected rar5 record");
+        }
+        return c;
+    }
+
+    protected sealed override async ValueTask ReadFinishAsync(
+        AsyncMarkingBinaryReader reader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        Version = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
+        RecSectors = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
+        TotalBlocks = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
+        Mark = await reader.ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
+    }
+}

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

@@ -1,11 +1,9 @@
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-internal sealed class ProtectHeader : RarHeader
+internal sealed partial class ProtectHeader : RarHeader
 {
     public static ProtectHeader Create(RarHeader header, RarCrcBinaryReader reader)
     {
@@ -17,27 +15,7 @@ internal sealed class ProtectHeader : RarHeader
         return c;
     }
 
-    public static async ValueTask<ProtectHeader> CreateAsync(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var c = await CreateChildAsync<ProtectHeader>(
-                header,
-                reader,
-                HeaderType.Protect,
-                cancellationToken
-            )
-            .ConfigureAwait(false);
-        if (c.IsRar5)
-        {
-            throw new InvalidFormatException("unexpected rar5 record");
-        }
-        return c;
-    }
-
-    protected override void ReadFinish(MarkingBinaryReader reader)
+    protected sealed override void ReadFinish(MarkingBinaryReader reader)
     {
         Version = reader.ReadByte();
         RecSectors = reader.ReadUInt16();
@@ -45,17 +23,6 @@ internal sealed class ProtectHeader : RarHeader
         Mark = reader.ReadBytes(8);
     }
 
-    protected override async ValueTask ReadFinishAsync(
-        AsyncMarkingBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        Version = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-        RecSectors = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
-        TotalBlocks = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-        Mark = await reader.ReadBytesAsync(8, cancellationToken).ConfigureAwait(false);
-    }
-
     internal uint DataSize => checked((uint)AdditionalDataSize);
     internal byte Version { get; private set; }
     internal ushort RecSectors { get; private set; }

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

@@ -0,0 +1,115 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+internal partial class RarHeader
+{
+    internal static async ValueTask<RarHeader?> TryReadBaseAsync(
+        AsyncRarCrcBinaryReader reader,
+        bool isRar5,
+        IArchiveEncoding archiveEncoding,
+        CancellationToken cancellationToken = default
+    )
+    {
+        try
+        {
+            var header = new RarHeader();
+            await header
+                .InitializeAsync(reader, isRar5, archiveEncoding, cancellationToken)
+                .ConfigureAwait(false);
+            return header;
+        }
+        catch (InvalidFormatException)
+        {
+            return null;
+        }
+    }
+
+    private async ValueTask InitializeAsync(
+        AsyncRarCrcBinaryReader reader,
+        bool isRar5,
+        IArchiveEncoding archiveEncoding,
+        CancellationToken cancellationToken
+    )
+    {
+        _headerType = HeaderType.Null;
+        _isRar5 = isRar5;
+        ArchiveEncoding = archiveEncoding;
+        if (IsRar5)
+        {
+            HeaderCrc = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
+            reader.ResetCrc();
+            HeaderSize = (int)
+                await reader.ReadRarVIntUInt32Async(3, cancellationToken).ConfigureAwait(false);
+            reader.Mark();
+            HeaderCode = await reader
+                .ReadRarVIntByteAsync(cancellationToken: cancellationToken)
+                .ConfigureAwait(false);
+            HeaderFlags = await reader
+                .ReadRarVIntUInt16Async(2, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
+            {
+                ExtraSize = await reader
+                    .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
+                    .ConfigureAwait(false);
+            }
+            if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
+            {
+                AdditionalDataSize = (long)
+                    await reader
+                        .ReadRarVIntAsync(cancellationToken: cancellationToken)
+                        .ConfigureAwait(false);
+            }
+        }
+        else
+        {
+            reader.Mark();
+            HeaderCrc = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
+            reader.ResetCrc();
+            HeaderCode = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
+            HeaderFlags = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
+            HeaderSize = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
+            if (HasHeaderFlag(HeaderFlagsV4.HAS_DATA))
+            {
+                AdditionalDataSize = await reader
+                    .ReadUInt32Async(cancellationToken)
+                    .ConfigureAwait(false);
+            }
+        }
+    }
+
+    internal static async ValueTask<T> CreateChildAsync<T>(
+        RarHeader header,
+        AsyncRarCrcBinaryReader reader,
+        HeaderType headerType,
+        CancellationToken cancellationToken = default
+    )
+        where T : RarHeader, new()
+    {
+        var child = new T() { ArchiveEncoding = header.ArchiveEncoding };
+        child._headerType = headerType;
+        child._isRar5 = header.IsRar5;
+        child.HeaderCrc = header.HeaderCrc;
+        child.HeaderCode = header.HeaderCode;
+        child.HeaderFlags = header.HeaderFlags;
+        child.HeaderSize = header.HeaderSize;
+        child.ExtraSize = header.ExtraSize;
+        child.AdditionalDataSize = header.AdditionalDataSize;
+        await child.ReadFinishAsync(reader, cancellationToken).ConfigureAwait(false);
+
+        var n = child.RemainingHeaderBytesAsync(reader);
+        if (n > 0)
+        {
+            await reader.ReadBytesAsync(n, cancellationToken).ConfigureAwait(false);
+        }
+
+        child.VerifyHeaderCrc(reader.GetCrc32());
+        return child;
+    }
+}

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

@@ -8,7 +8,7 @@ namespace SharpCompress.Common.Rar.Headers;
 
 // http://www.forensicswiki.org/w/images/5/5b/RARFileStructure.txt
 // https://www.rarlab.com/technote.htm
-internal class RarHeader : IRarHeader
+internal partial class RarHeader : IRarHeader
 {
     private HeaderType _headerType;
     private bool _isRar5;
@@ -36,27 +36,6 @@ internal class RarHeader : IRarHeader
         }
     }
 
-    internal static async ValueTask<RarHeader?> TryReadBaseAsync(
-        AsyncRarCrcBinaryReader reader,
-        bool isRar5,
-        IArchiveEncoding archiveEncoding,
-        CancellationToken cancellationToken = default
-    )
-    {
-        try
-        {
-            var header = new RarHeader();
-            await header
-                .InitializeAsync(reader, isRar5, archiveEncoding, cancellationToken)
-                .ConfigureAwait(false);
-            return header;
-        }
-        catch (InvalidFormatException)
-        {
-            return null;
-        }
-    }
-
     private void Initialize(
         RarCrcBinaryReader reader,
         bool isRar5,
@@ -99,57 +78,6 @@ internal class RarHeader : IRarHeader
         }
     }
 
-    private async ValueTask InitializeAsync(
-        AsyncRarCrcBinaryReader reader,
-        bool isRar5,
-        IArchiveEncoding archiveEncoding,
-        CancellationToken cancellationToken
-    )
-    {
-        _headerType = HeaderType.Null;
-        _isRar5 = isRar5;
-        ArchiveEncoding = archiveEncoding;
-        if (IsRar5)
-        {
-            HeaderCrc = await reader.ReadUInt32Async(cancellationToken).ConfigureAwait(false);
-            reader.ResetCrc();
-            HeaderSize = (int)
-                await reader.ReadRarVIntUInt32Async( 3, cancellationToken).ConfigureAwait(false);
-            reader.Mark();
-            HeaderCode = await reader.ReadRarVIntByteAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-            HeaderFlags = await reader
-                .ReadRarVIntUInt16Async(2,cancellationToken)
-                .ConfigureAwait(false);
-
-            if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
-            {
-                ExtraSize = await reader
-                    .ReadRarVIntUInt32Async(cancellationToken: cancellationToken)
-                    .ConfigureAwait(false);
-            }
-            if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
-            {
-                AdditionalDataSize = (long)
-                    await reader.ReadRarVIntAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
-            }
-        }
-        else
-        {
-            reader.Mark();
-            HeaderCrc = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
-            reader.ResetCrc();
-            HeaderCode = await reader.ReadByteAsync(cancellationToken).ConfigureAwait(false);
-            HeaderFlags = await reader.ReadUInt16Async(cancellationToken).ConfigureAwait(false);
-            HeaderSize = await reader.ReadInt16Async(cancellationToken).ConfigureAwait(false);
-            if (HasHeaderFlag(HeaderFlagsV4.HAS_DATA))
-            {
-                AdditionalDataSize = await reader
-                    .ReadUInt32Async(cancellationToken)
-                    .ConfigureAwait(false);
-            }
-        }
-    }
-
     internal static T CreateChild<T>(
         RarHeader header,
         RarCrcBinaryReader reader,
@@ -178,35 +106,6 @@ internal class RarHeader : IRarHeader
         return child;
     }
 
-    internal static async ValueTask<T> CreateChildAsync<T>(
-        RarHeader header,
-        AsyncRarCrcBinaryReader reader,
-        HeaderType headerType,
-        CancellationToken cancellationToken = default
-    )
-        where T : RarHeader, new()
-    {
-        var child = new T() { ArchiveEncoding = header.ArchiveEncoding };
-        child._headerType = headerType;
-        child._isRar5 = header.IsRar5;
-        child.HeaderCrc = header.HeaderCrc;
-        child.HeaderCode = header.HeaderCode;
-        child.HeaderFlags = header.HeaderFlags;
-        child.HeaderSize = header.HeaderSize;
-        child.ExtraSize = header.ExtraSize;
-        child.AdditionalDataSize = header.AdditionalDataSize;
-        await child.ReadFinishAsync(reader, cancellationToken).ConfigureAwait(false);
-
-        var n = child.RemainingHeaderBytesAsync(reader);
-        if (n > 0)
-        {
-            await reader.ReadBytesAsync(n, cancellationToken).ConfigureAwait(false);
-        }
-
-        child.VerifyHeaderCrc(reader.GetCrc32());
-        return child;
-    }
-
     protected int RemainingHeaderBytes(MarkingBinaryReader reader) =>
         checked(HeaderSize - (int)reader.CurrentReadByteCount);
 

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

@@ -0,0 +1,256 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Rar;
+using SharpCompress.IO;
+using SharpCompress.Readers;
+
+namespace SharpCompress.Common.Rar.Headers;
+
+public partial class RarHeaderFactory
+{
+    public async IAsyncEnumerable<IRarHeader> ReadHeadersAsync(Stream stream)
+    {
+        var markHeader = await MarkHeader
+            .ReadAsync(
+                stream,
+                Options.LeaveStreamOpen,
+                Options.LookForHeader,
+                CancellationToken.None
+            )
+            .ConfigureAwait(false);
+        _isRar5 = markHeader.IsRar5;
+        yield return markHeader;
+
+        RarHeader? header;
+        while (
+            (
+                header = await TryReadNextHeaderAsync(stream, CancellationToken.None)
+                    .ConfigureAwait(false)
+            ) != null
+        )
+        {
+            yield return header;
+            if (header.HeaderType == HeaderType.EndArchive)
+            {
+                // End of archive marker. RAR does not read anything after this header letting to use third
+                // party tools to add extra information such as a digital signature to archive.
+                yield break;
+            }
+        }
+    }
+
+    private async ValueTask<RarHeader?> TryReadNextHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken
+    )
+    {
+        AsyncRarCrcBinaryReader reader;
+        if (!IsEncrypted)
+        {
+            reader = new AsyncRarCrcBinaryReader(stream);
+        }
+        else
+        {
+            if (Options.Password is null)
+            {
+                throw new CryptographicException(
+                    "Encrypted Rar archive has no password specified."
+                );
+            }
+
+            if (_isRar5 && _cryptInfo != null)
+            {
+                await _cryptInfo.ReadInitVAsync(new AsyncMarkingBinaryReader(stream));
+                var _headerKey = new CryptKey5(Options.Password!, _cryptInfo);
+
+                reader = await AsyncRarCryptoBinaryReader.Create(
+                    stream,
+                    _headerKey,
+                    _cryptInfo.Salt
+                );
+            }
+            else
+            {
+                var key = new CryptKey3(Options.Password);
+                reader = await AsyncRarCryptoBinaryReader.Create(stream, key);
+            }
+        }
+
+        var header = await RarHeader
+            .TryReadBaseAsync(reader, _isRar5, Options.ArchiveEncoding, cancellationToken)
+            .ConfigureAwait(false);
+        if (header is null)
+        {
+            return null;
+        }
+        switch (header.HeaderCode)
+        {
+            case HeaderCodeV.RAR5_ARCHIVE_HEADER:
+            case HeaderCodeV.RAR4_ARCHIVE_HEADER:
+            {
+                var ah = await ArchiveHeader
+                    .CreateAsync(header, reader, cancellationToken)
+                    .ConfigureAwait(false);
+                if (ah.IsEncrypted == true)
+                {
+                    //!!! rar5 we don't know yet
+                    IsEncrypted = true;
+                }
+                return ah;
+            }
+
+            case HeaderCodeV.RAR4_PROTECT_HEADER:
+            {
+                var ph = await ProtectHeader
+                    .CreateAsync(header, reader, cancellationToken)
+                    .ConfigureAwait(false);
+                // skip the recovery record data, we do not use it.
+                switch (StreamingMode)
+                {
+                    case StreamingMode.Seekable:
+                        {
+                            reader.BaseStream.Position += ph.DataSize;
+                        }
+                        break;
+                    case StreamingMode.Streaming:
+                        {
+                            await reader
+                                .BaseStream.SkipAsync(ph.DataSize, cancellationToken)
+                                .ConfigureAwait(false);
+                        }
+                        break;
+                    default:
+                    {
+                        throw new InvalidFormatException("Invalid StreamingMode");
+                    }
+                }
+                return ph;
+            }
+
+            case HeaderCodeV.RAR5_SERVICE_HEADER:
+            {
+                var fh = await FileHeader
+                    .CreateAsync(header, reader, HeaderType.Service, cancellationToken)
+                    .ConfigureAwait(false);
+                if (fh.FileName == "CMT")
+                {
+                    fh.PackedStream = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
+                }
+                else
+                {
+                    await SkipDataAsync(fh, reader, cancellationToken).ConfigureAwait(false);
+                }
+                return fh;
+            }
+
+            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+            {
+                var fh = await FileHeader
+                    .CreateAsync(header, reader, HeaderType.NewSub, cancellationToken)
+                    .ConfigureAwait(false);
+                await SkipDataAsync(fh, reader, cancellationToken).ConfigureAwait(false);
+                return fh;
+            }
+
+            case HeaderCodeV.RAR5_FILE_HEADER:
+            case HeaderCodeV.RAR4_FILE_HEADER:
+            {
+                var fh = await FileHeader
+                    .CreateAsync(header, reader, HeaderType.File, cancellationToken)
+                    .ConfigureAwait(false);
+                switch (StreamingMode)
+                {
+                    case StreamingMode.Seekable:
+                        {
+                            fh.DataStartPosition = reader.BaseStream.Position;
+                            reader.BaseStream.Position += fh.CompressedSize;
+                        }
+                        break;
+                    case StreamingMode.Streaming:
+                        {
+                            var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
+                            if (fh.R4Salt is null && fh.Rar5CryptoInfo is null)
+                            {
+                                fh.PackedStream = ms;
+                            }
+                            else
+                            {
+                                fh.PackedStream = new RarCryptoWrapper(
+                                    ms,
+                                    fh.R4Salt is null
+                                        ? fh.Rar5CryptoInfo.NotNull().Salt
+                                        : fh.R4Salt,
+                                    fh.R4Salt is null
+                                        ? new CryptKey5(
+                                            Options.Password,
+                                            fh.Rar5CryptoInfo.NotNull()
+                                        )
+                                        : new CryptKey3(Options.Password)
+                                );
+                            }
+                        }
+                        break;
+                    default:
+                    {
+                        throw new InvalidFormatException("Invalid StreamingMode");
+                    }
+                }
+                return fh;
+            }
+            case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
+            case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
+            {
+                return await EndArchiveHeader
+                    .CreateAsync(header, reader, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+            case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
+            {
+                var cryptoHeader = await ArchiveCryptHeader
+                    .CreateAsync(header, reader, cancellationToken)
+                    .ConfigureAwait(false);
+                IsEncrypted = true;
+                _cryptInfo = cryptoHeader.CryptInfo;
+
+                return cryptoHeader;
+            }
+            default:
+            {
+                throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
+            }
+        }
+    }
+
+    private async ValueTask SkipDataAsync(
+        FileHeader fh,
+        AsyncRarCrcBinaryReader reader,
+        CancellationToken cancellationToken
+    )
+    {
+        switch (StreamingMode)
+        {
+            case StreamingMode.Seekable:
+                {
+                    fh.DataStartPosition = reader.BaseStream.Position;
+                    reader.BaseStream.Position += fh.CompressedSize;
+                }
+                break;
+            case StreamingMode.Streaming:
+                {
+                    //skip the data because it's useless?
+                    await reader
+                        .BaseStream.SkipAsync(fh.CompressedSize, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                break;
+            default:
+            {
+                throw new InvalidFormatException("Invalid StreamingMode");
+            }
+        }
+    }
+}

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

@@ -2,15 +2,13 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Rar;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Common.Rar.Headers;
 
-public class RarHeaderFactory
+public partial class RarHeaderFactory
 {
     private bool _isRar5;
 
@@ -45,37 +43,6 @@ public class RarHeaderFactory
         }
     }
 
-    public async IAsyncEnumerable<IRarHeader> ReadHeadersAsync(Stream stream)
-    {
-        var markHeader = await MarkHeader
-            .ReadAsync(
-                stream,
-                Options.LeaveStreamOpen,
-                Options.LookForHeader,
-                CancellationToken.None
-            )
-            .ConfigureAwait(false);
-        _isRar5 = markHeader.IsRar5;
-        yield return markHeader;
-
-        RarHeader? header;
-        while (
-            (
-                header = await TryReadNextHeaderAsync(stream, CancellationToken.None)
-                    .ConfigureAwait(false)
-            ) != null
-        )
-        {
-            yield return header;
-            if (header.HeaderType == HeaderType.EndArchive)
-            {
-                // End of archive marker. RAR does not read anything after this header letting to use third
-                // party tools to add extra information such as a digital signature to archive.
-                yield break;
-            }
-        }
-    }
-
     private RarHeader? TryReadNextHeader(Stream stream)
     {
         RarCrcBinaryReader reader;
@@ -102,7 +69,7 @@ public class RarHeaderFactory
             else
             {
                 var key = new CryptKey3(Options.Password);
-                reader =  RarCryptoBinaryReader.Create(stream, key);
+                reader = RarCryptoBinaryReader.Create(stream, key);
             }
         }
 
@@ -234,184 +201,6 @@ public class RarHeaderFactory
         }
     }
 
-    private async ValueTask<RarHeader?> TryReadNextHeaderAsync(
-        Stream stream,
-        CancellationToken cancellationToken
-    )
-    {
-        AsyncRarCrcBinaryReader reader;
-        if (!IsEncrypted)
-        {
-            reader = new AsyncRarCrcBinaryReader(stream);
-        }
-        else
-        {
-            if (Options.Password is null)
-            {
-                throw new CryptographicException(
-                    "Encrypted Rar archive has no password specified."
-                );
-            }
-
-            if (_isRar5 && _cryptInfo != null)
-            {
-                await _cryptInfo.ReadInitVAsync(new AsyncMarkingBinaryReader(stream));
-                var _headerKey = new CryptKey5(Options.Password!, _cryptInfo);
-
-                reader = await AsyncRarCryptoBinaryReader.Create(stream, _headerKey, _cryptInfo.Salt);
-            }
-            else
-            {
-                var key = new CryptKey3(Options.Password);
-                reader = await AsyncRarCryptoBinaryReader.Create(stream, key);
-            }
-        }
-
-        var header = await RarHeader
-            .TryReadBaseAsync(reader, _isRar5, Options.ArchiveEncoding, cancellationToken)
-            .ConfigureAwait(false);
-        if (header is null)
-        {
-            return null;
-        }
-        switch (header.HeaderCode)
-        {
-            case HeaderCodeV.RAR5_ARCHIVE_HEADER:
-            case HeaderCodeV.RAR4_ARCHIVE_HEADER:
-            {
-                var ah = await ArchiveHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-                if (ah.IsEncrypted == true)
-                {
-                    //!!! rar5 we don't know yet
-                    IsEncrypted = true;
-                }
-                return ah;
-            }
-
-            case HeaderCodeV.RAR4_PROTECT_HEADER:
-            {
-                var ph = await ProtectHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-                // skip the recovery record data, we do not use it.
-                switch (StreamingMode)
-                {
-                    case StreamingMode.Seekable:
-                        {
-                            reader.BaseStream.Position += ph.DataSize;
-                        }
-                        break;
-                    case StreamingMode.Streaming:
-                        {
-                            await reader
-                                .BaseStream.SkipAsync(ph.DataSize, cancellationToken)
-                                .ConfigureAwait(false);
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-                return ph;
-            }
-
-            case HeaderCodeV.RAR5_SERVICE_HEADER:
-            {
-                var fh = await FileHeader
-                    .CreateAsync(header, reader, HeaderType.Service, cancellationToken)
-                    .ConfigureAwait(false);
-                if (fh.FileName == "CMT")
-                {
-                    fh.PackedStream = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                }
-                else
-                {
-                    await SkipDataAsync(fh, reader, cancellationToken).ConfigureAwait(false);
-                }
-                return fh;
-            }
-
-            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
-            {
-                var fh = await FileHeader
-                    .CreateAsync(header, reader, HeaderType.NewSub, cancellationToken)
-                    .ConfigureAwait(false);
-                await SkipDataAsync(fh, reader, cancellationToken).ConfigureAwait(false);
-                return fh;
-            }
-
-            case HeaderCodeV.RAR5_FILE_HEADER:
-            case HeaderCodeV.RAR4_FILE_HEADER:
-            {
-                var fh = await FileHeader
-                    .CreateAsync(header, reader, HeaderType.File, cancellationToken)
-                    .ConfigureAwait(false);
-                switch (StreamingMode)
-                {
-                    case StreamingMode.Seekable:
-                        {
-                            fh.DataStartPosition = reader.BaseStream.Position;
-                            reader.BaseStream.Position += fh.CompressedSize;
-                        }
-                        break;
-                    case StreamingMode.Streaming:
-                        {
-                            var ms = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
-                            if (fh.R4Salt is null && fh.Rar5CryptoInfo is null)
-                            {
-                                fh.PackedStream = ms;
-                            }
-                            else
-                            {
-                                fh.PackedStream = new RarCryptoWrapper(
-                                    ms,
-                                    fh.R4Salt is null
-                                        ? fh.Rar5CryptoInfo.NotNull().Salt
-                                        : fh.R4Salt,
-                                    fh.R4Salt is null
-                                        ? new CryptKey5(
-                                            Options.Password,
-                                            fh.Rar5CryptoInfo.NotNull()
-                                        )
-                                        : new CryptKey3(Options.Password)
-                                );
-                            }
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-                return fh;
-            }
-            case HeaderCodeV.RAR5_END_ARCHIVE_HEADER:
-            case HeaderCodeV.RAR4_END_ARCHIVE_HEADER:
-            {
-                return await EndArchiveHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-            }
-            case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
-            {
-                var cryptoHeader = await ArchiveCryptHeader
-                    .CreateAsync(header, reader, cancellationToken)
-                    .ConfigureAwait(false);
-                IsEncrypted = true;
-                _cryptInfo = cryptoHeader.CryptInfo;
-
-                return cryptoHeader;
-            }
-            default:
-            {
-                throw new InvalidFormatException("Unknown Rar Header: " + header.HeaderCode);
-            }
-        }
-    }
-
     private void SkipData(FileHeader fh, RarCrcBinaryReader reader)
     {
         switch (StreamingMode)
@@ -434,33 +223,4 @@ public class RarHeaderFactory
             }
         }
     }
-
-    private async ValueTask SkipDataAsync(
-        FileHeader fh,
-        AsyncRarCrcBinaryReader reader,
-        CancellationToken cancellationToken
-    )
-    {
-        switch (StreamingMode)
-        {
-            case StreamingMode.Seekable:
-                {
-                    fh.DataStartPosition = reader.BaseStream.Position;
-                    reader.BaseStream.Position += fh.CompressedSize;
-                }
-                break;
-            case StreamingMode.Streaming:
-                {
-                    //skip the data because it's useless?
-                    await reader
-                        .BaseStream.SkipAsync(fh.CompressedSize, cancellationToken)
-                        .ConfigureAwait(false);
-                }
-                break;
-            default:
-            {
-                throw new InvalidFormatException("Invalid StreamingMode");
-            }
-        }
-    }
 }

src/SharpCompress/Common/Rar/Rar5CryptoInfo.cs

@@ -20,7 +20,10 @@ internal class Rar5CryptoInfo
             throw new CryptographicException($"Unsupported crypto version of {cryptVersion}");
         }
         var encryptionFlags = reader.ReadRarVIntUInt32();
-        cryptoInfo.UsePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
+        cryptoInfo.UsePswCheck = FlagUtility.HasFlag(
+            encryptionFlags,
+            EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK
+        );
         cryptoInfo.LG2Count = reader.ReadRarVIntByte(1);
 
         if (cryptoInfo.LG2Count > EncryptionConstV5.CRYPT5_KDF_LG2_COUNT_MAX)
@@ -41,23 +44,33 @@ internal class Rar5CryptoInfo
             var _pswCheckCsm = reader.ReadBytes(EncryptionConstV5.SIZE_PSWCHECK_CSUM);
 
             var sha = SHA256.Create();
-            cryptoInfo.UsePswCheck = sha.ComputeHash(cryptoInfo.PswCheck).AsSpan().StartsWith(_pswCheckCsm.AsSpan());
+            cryptoInfo.UsePswCheck = sha.ComputeHash(cryptoInfo.PswCheck)
+                .AsSpan()
+                .StartsWith(_pswCheckCsm.AsSpan());
         }
         return cryptoInfo;
     }
 
-    public static async ValueTask<Rar5CryptoInfo> CreateAsync(AsyncMarkingBinaryReader reader, bool readInitV)
+    public static async ValueTask<Rar5CryptoInfo> CreateAsync(
+        AsyncMarkingBinaryReader reader,
+        bool readInitV
+    )
     {
         var cryptoInfo = new Rar5CryptoInfo();
-        var cryptVersion =
-            await reader.ReadRarVIntUInt32Async(cancellationToken: CancellationToken.None);
+        var cryptVersion = await reader.ReadRarVIntUInt32Async(
+            cancellationToken: CancellationToken.None
+        );
         if (cryptVersion > EncryptionConstV5.VERSION)
         {
             throw new CryptographicException($"Unsupported crypto version of {cryptVersion}");
         }
-        var encryptionFlags =
-            await reader.ReadRarVIntUInt32Async(cancellationToken: CancellationToken.None);
-        cryptoInfo.UsePswCheck = FlagUtility.HasFlag(encryptionFlags, EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK);
+        var encryptionFlags = await reader.ReadRarVIntUInt32Async(
+            cancellationToken: CancellationToken.None
+        );
+        cryptoInfo.UsePswCheck = FlagUtility.HasFlag(
+            encryptionFlags,
+            EncryptionFlagsV5.CHFL_CRYPT_PSWCHECK
+        );
         cryptoInfo.LG2Count = (int)
             await reader.ReadRarVIntUInt32Async(cancellationToken: CancellationToken.None);
         if (cryptoInfo.LG2Count > EncryptionConstV5.CRYPT5_KDF_LG2_COUNT_MAX)
@@ -65,8 +78,10 @@ internal class Rar5CryptoInfo
             throw new CryptographicException($"Unsupported LG2 count of {cryptoInfo.LG2Count}.");
         }
 
-        cryptoInfo.Salt = await reader
-            .ReadBytesAsync(EncryptionConstV5.SIZE_SALT50, CancellationToken.None);
+        cryptoInfo.Salt = await reader.ReadBytesAsync(
+            EncryptionConstV5.SIZE_SALT50,
+            CancellationToken.None
+        );
 
         if (readInitV)
         {
@@ -75,13 +90,19 @@ internal class Rar5CryptoInfo
 
         if (cryptoInfo.UsePswCheck)
         {
-            cryptoInfo.PswCheck = await reader
-                .ReadBytesAsync(EncryptionConstV5.SIZE_PSWCHECK, CancellationToken.None);
-            var _pswCheckCsm = await reader
-                .ReadBytesAsync(EncryptionConstV5.SIZE_PSWCHECK_CSUM, CancellationToken.None);
+            cryptoInfo.PswCheck = await reader.ReadBytesAsync(
+                EncryptionConstV5.SIZE_PSWCHECK,
+                CancellationToken.None
+            );
+            var _pswCheckCsm = await reader.ReadBytesAsync(
+                EncryptionConstV5.SIZE_PSWCHECK_CSUM,
+                CancellationToken.None
+            );
 
             var sha = SHA256.Create();
-            cryptoInfo.UsePswCheck = sha.ComputeHash(cryptoInfo.PswCheck).AsSpan().StartsWith(_pswCheckCsm.AsSpan());
+            cryptoInfo.UsePswCheck = sha.ComputeHash(cryptoInfo.PswCheck)
+                .AsSpan()
+                .StartsWith(_pswCheckCsm.AsSpan());
         }
         return cryptoInfo;
     }
@@ -90,8 +111,7 @@ internal class Rar5CryptoInfo
         InitV = reader.ReadBytes(EncryptionConstV5.SIZE_INITV);
 
     public async ValueTask ReadInitVAsync(AsyncMarkingBinaryReader reader) =>
-        InitV = await reader
-            .ReadBytesAsync(EncryptionConstV5.SIZE_INITV, CancellationToken.None);
+        InitV = await reader.ReadBytesAsync(EncryptionConstV5.SIZE_INITV, CancellationToken.None);
 
     public bool UsePswCheck = false;
 

src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs

@@ -1,5 +1,3 @@
-
-
 using System.Collections.Generic;
 using System.IO;
 using SharpCompress.Common.Rar.Headers;
@@ -14,11 +12,13 @@ internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
     private long _readCount;
 
     private RarCryptoBinaryReader(Stream stream)
-        : base(stream)
-    {
-    }
+        : base(stream) { }
 
-    public static RarCryptoBinaryReader Create(Stream stream, ICryptKey cryptKey, byte[]? salt = null)
+    public static RarCryptoBinaryReader Create(
+        Stream stream,
+        ICryptKey cryptKey,
+        byte[]? salt = null
+    )
     {
         var binary = new RarCryptoBinaryReader(stream);
         if (salt == null)

src/SharpCompress/Common/Rar/RarVolume.cs

@@ -76,10 +76,16 @@ public abstract class RarVolume : Volume
         }
     }
 
-    internal async IAsyncEnumerable<RarFilePart> GetVolumeFilePartsAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
+    internal async IAsyncEnumerable<RarFilePart> GetVolumeFilePartsAsync(
+        [EnumeratorCancellation] CancellationToken cancellationToken = default
+    )
     {
         MarkHeader? lastMarkHeader = null;
-        await foreach (var header in _headerFactory.ReadHeadersAsync(Stream).WithCancellation(cancellationToken))
+        await foreach (
+            var header in _headerFactory
+                .ReadHeadersAsync(Stream)
+                .WithCancellation(cancellationToken)
+        )
         {
             switch (header.HeaderType)
             {
@@ -124,11 +130,11 @@ public abstract class RarVolume : Volume
         if (ArchiveHeader is null)
         {
             if (Mode == StreamingMode.Streaming)
-        {
-            throw new InvalidOperationException(
+            {
+                throw new InvalidOperationException(
                     "ArchiveHeader should never been null in a streaming read."
-            );
-        }
+                );
+            }
 
             // we only want to load the archive header to avoid overhead but have to do the nasty thing and reset the stream
             GetVolumeFileParts().First();

src/SharpCompress/Common/SevenZip/ArchiveReader.Async.cs

@@ -0,0 +1,158 @@
+#nullable disable
+
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Compressors.LZMA;
+using SharpCompress.Compressors.LZMA.Utilites;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.SevenZip;
+
+internal sealed partial class ArchiveReader
+{
+    public async ValueTask OpenAsync(
+        Stream stream,
+        bool lookForHeader,
+        CancellationToken cancellationToken = default
+    )
+    {
+        Close();
+
+        _streamOrigin = stream.Position;
+        _streamEnding = stream.Length;
+
+        var canScan = lookForHeader ? 0x80000 - 20 : 0;
+        while (true)
+        {
+            // TODO: Check Signature!
+            _header = new byte[0x20];
+            await stream.ReadExactAsync(_header, 0, 0x20, cancellationToken);
+
+            if (
+                !lookForHeader
+                || _header
+                    .AsSpan(0, length: 6)
+                    .SequenceEqual<byte>([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])
+            )
+            {
+                break;
+            }
+
+            if (canScan == 0)
+            {
+                throw new InvalidFormatException("Unable to find 7z signature");
+            }
+
+            canScan--;
+            stream.Position = ++_streamOrigin;
+        }
+
+        _stream = stream;
+    }
+
+    public async ValueTask<ArchiveDatabase> ReadDatabaseAsync(
+        IPasswordProvider pass,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var db = new ArchiveDatabase(pass);
+        db.Clear();
+
+        db._majorVersion = _header[6];
+        db._minorVersion = _header[7];
+
+        if (db._majorVersion != 0)
+        {
+            throw new InvalidOperationException();
+        }
+
+        var crcFromArchive = DataReader.Get32(_header, 8);
+        var nextHeaderOffset = (long)DataReader.Get64(_header, 0xC);
+        var nextHeaderSize = (long)DataReader.Get64(_header, 0x14);
+        var nextHeaderCrc = DataReader.Get32(_header, 0x1C);
+
+        var crc = Crc.INIT_CRC;
+        crc = Crc.Update(crc, nextHeaderOffset);
+        crc = Crc.Update(crc, nextHeaderSize);
+        crc = Crc.Update(crc, nextHeaderCrc);
+        crc = Crc.Finish(crc);
+
+        if (crc != crcFromArchive)
+        {
+            throw new InvalidOperationException();
+        }
+
+        db._startPositionAfterHeader = _streamOrigin + 0x20;
+
+        // empty header is ok
+        if (nextHeaderSize == 0)
+        {
+            db.Fill();
+            return db;
+        }
+
+        if (nextHeaderOffset < 0 || nextHeaderSize < 0 || nextHeaderSize > int.MaxValue)
+        {
+            throw new InvalidOperationException();
+        }
+
+        if (nextHeaderOffset > _streamEnding - db._startPositionAfterHeader)
+        {
+            throw new InvalidOperationException("nextHeaderOffset is invalid");
+        }
+
+        _stream.Seek(nextHeaderOffset, SeekOrigin.Current);
+
+        var header = new byte[nextHeaderSize];
+        await _stream.ReadExactAsync(header, 0, header.Length, cancellationToken);
+
+        if (Crc.Finish(Crc.Update(Crc.INIT_CRC, header, 0, header.Length)) != nextHeaderCrc)
+        {
+            throw new InvalidOperationException();
+        }
+
+        using (var streamSwitch = new CStreamSwitch())
+        {
+            streamSwitch.Set(this, header);
+
+            var type = ReadId();
+            if (type != BlockType.Header)
+            {
+                if (type != BlockType.EncodedHeader)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                var dataVector = ReadAndDecodePackedStreams(
+                    db._startPositionAfterHeader,
+                    db.PasswordProvider
+                );
+
+                // compressed header without content is odd but ok
+                if (dataVector.Count == 0)
+                {
+                    db.Fill();
+                    return db;
+                }
+
+                if (dataVector.Count != 1)
+                {
+                    throw new InvalidOperationException();
+                }
+
+                streamSwitch.Set(this, dataVector[0]);
+
+                if (ReadId() != BlockType.Header)
+                {
+                    throw new InvalidOperationException();
+                }
+            }
+
+            ReadHeader(db, db.PasswordProvider);
+        }
+        db.Fill();
+        return db;
+    }
+}

src/SharpCompress/Common/SevenZip/ArchiveReader.cs

@@ -13,7 +13,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.SevenZip;
 
-internal class ArchiveReader
+internal partial class ArchiveReader
 {
     internal Stream _stream;
     internal Stack<DataReader> _readerStack = new();
@@ -1272,45 +1272,7 @@ internal class ArchiveReader
         _stream = stream;
     }
 
-    public async Task OpenAsync(
-        Stream stream,
-        bool lookForHeader,
-        CancellationToken cancellationToken = default
-    )
-    {
-        Close();
-
-        _streamOrigin = stream.Position;
-        _streamEnding = stream.Length;
-
-        var canScan = lookForHeader ? 0x80000 - 20 : 0;
-        while (true)
-        {
-            // TODO: Check Signature!
-            _header = new byte[0x20];
-            await stream.ReadExactAsync(_header, 0, 0x20, cancellationToken);
-
-            if (
-                !lookForHeader
-                || _header
-                    .AsSpan(0, length: 6)
-                    .SequenceEqual<byte>([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])
-            )
-            {
-                break;
-            }
-
-            if (canScan == 0)
-            {
-                throw new InvalidFormatException("Unable to find 7z signature");
-            }
-
-            canScan--;
-            stream.Position = ++_streamOrigin;
-        }
-
-        _stream = stream;
-    }
+    // OpenAsync moved to ArchiveReader.Async.cs
 
     public void Close()
     {
@@ -1425,109 +1387,7 @@ internal class ArchiveReader
         return db;
     }
 
-    public async Task<ArchiveDatabase> ReadDatabaseAsync(
-        IPasswordProvider pass,
-        CancellationToken cancellationToken = default
-    )
-    {
-        var db = new ArchiveDatabase(pass);
-        db.Clear();
-
-        db._majorVersion = _header[6];
-        db._minorVersion = _header[7];
-
-        if (db._majorVersion != 0)
-        {
-            throw new InvalidOperationException();
-        }
-
-        var crcFromArchive = DataReader.Get32(_header, 8);
-        var nextHeaderOffset = (long)DataReader.Get64(_header, 0xC);
-        var nextHeaderSize = (long)DataReader.Get64(_header, 0x14);
-        var nextHeaderCrc = DataReader.Get32(_header, 0x1C);
-
-        var crc = Crc.INIT_CRC;
-        crc = Crc.Update(crc, nextHeaderOffset);
-        crc = Crc.Update(crc, nextHeaderSize);
-        crc = Crc.Update(crc, nextHeaderCrc);
-        crc = Crc.Finish(crc);
-
-        if (crc != crcFromArchive)
-        {
-            throw new InvalidOperationException();
-        }
-
-        db._startPositionAfterHeader = _streamOrigin + 0x20;
-
-        // empty header is ok
-        if (nextHeaderSize == 0)
-        {
-            db.Fill();
-            return db;
-        }
-
-        if (nextHeaderOffset < 0 || nextHeaderSize < 0 || nextHeaderSize > int.MaxValue)
-        {
-            throw new InvalidOperationException();
-        }
-
-        if (nextHeaderOffset > _streamEnding - db._startPositionAfterHeader)
-        {
-            throw new InvalidOperationException("nextHeaderOffset is invalid");
-        }
-
-        _stream.Seek(nextHeaderOffset, SeekOrigin.Current);
-
-        var header = new byte[nextHeaderSize];
-        await _stream.ReadExactAsync(header, 0, header.Length, cancellationToken);
-
-        if (Crc.Finish(Crc.Update(Crc.INIT_CRC, header, 0, header.Length)) != nextHeaderCrc)
-        {
-            throw new InvalidOperationException();
-        }
-
-        using (var streamSwitch = new CStreamSwitch())
-        {
-            streamSwitch.Set(this, header);
-
-            var type = ReadId();
-            if (type != BlockType.Header)
-            {
-                if (type != BlockType.EncodedHeader)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                var dataVector = ReadAndDecodePackedStreams(
-                    db._startPositionAfterHeader,
-                    db.PasswordProvider
-                );
-
-                // compressed header without content is odd but ok
-                if (dataVector.Count == 0)
-                {
-                    db.Fill();
-                    return db;
-                }
-
-                if (dataVector.Count != 1)
-                {
-                    throw new InvalidOperationException();
-                }
-
-                streamSwitch.Set(this, dataVector[0]);
-
-                if (ReadId() != BlockType.Header)
-                {
-                    throw new InvalidOperationException();
-                }
-            }
-
-            ReadHeader(db, db.PasswordProvider);
-        }
-        db.Fill();
-        return db;
-    }
+    // ReadDatabaseAsync moved to ArchiveReader.Async.cs
 
     internal class CExtractFolderInfo
     {

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

@@ -0,0 +1,339 @@
+using System;
+using System.Buffers;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Tar.Headers;
+
+internal sealed partial class TarHeader
+{
+    internal async ValueTask WriteAsync(
+        Stream output,
+        CancellationToken cancellationToken = default
+    )
+    {
+        switch (WriteFormat)
+        {
+            case TarHeaderWriteFormat.GNU_TAR_LONG_LINK:
+                await WriteGnuTarLongLinkAsync(output, cancellationToken);
+                break;
+            case TarHeaderWriteFormat.USTAR:
+                await WriteUstarAsync(output, cancellationToken);
+                break;
+            default:
+                throw new Exception("This should be impossible...");
+        }
+    }
+
+    private async ValueTask WriteUstarAsync(Stream output, CancellationToken cancellationToken)
+    {
+        var buffer = new byte[BLOCK_SIZE];
+
+        WriteOctalBytes(511, buffer, 100, 8);
+        WriteOctalBytes(0, buffer, 108, 8);
+        WriteOctalBytes(0, buffer, 116, 8);
+
+        var nameByteCount = ArchiveEncoding
+            .GetEncoding()
+            .GetByteCount(Name.NotNull("Name is null"));
+
+        if (nameByteCount > 100)
+        {
+            string fullName = Name.NotNull("Name is null");
+
+            List<int> dirSeps = new List<int>();
+            for (int i = 0; i < fullName.Length; i++)
+            {
+                if (fullName[i] == Path.DirectorySeparatorChar)
+                {
+                    dirSeps.Add(i);
+                }
+            }
+
+            int splitIndex = -1;
+            for (int i = 0; i < dirSeps.Count; i++)
+            {
+                int count = ArchiveEncoding
+                    .GetEncoding()
+                    .GetByteCount(fullName.Substring(0, dirSeps[i]));
+                if (count < 155)
+                {
+                    splitIndex = dirSeps[i];
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            if (splitIndex == -1)
+            {
+                throw new Exception(
+                    $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Directory separator not found! Try using GNU Tar format instead!"
+                );
+            }
+
+            string namePrefix = fullName.Substring(0, splitIndex);
+            string name = fullName.Substring(splitIndex + 1);
+
+            if (this.ArchiveEncoding.GetEncoding().GetByteCount(namePrefix) >= 155)
+            {
+                throw new Exception(
+                    $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!"
+                );
+            }
+
+            if (this.ArchiveEncoding.GetEncoding().GetByteCount(name) >= 100)
+            {
+                throw new Exception(
+                    $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!"
+                );
+            }
+
+            WriteStringBytes(ArchiveEncoding.Encode(namePrefix), buffer, 345, 100);
+            WriteStringBytes(ArchiveEncoding.Encode(name), buffer, 100);
+        }
+        else
+        {
+            WriteStringBytes(ArchiveEncoding.Encode(Name.NotNull("Name is null")), buffer, 100);
+        }
+
+        WriteOctalBytes(Size, buffer, 124, 12);
+        var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
+        WriteOctalBytes(time, buffer, 136, 12);
+        buffer[156] = (byte)EntryType;
+
+        WriteStringBytes(Encoding.ASCII.GetBytes("ustar"), buffer, 257, 6);
+        buffer[263] = 0x30;
+        buffer[264] = 0x30;
+
+        var crc = RecalculateChecksum(buffer);
+        WriteOctalBytes(crc, buffer, 148, 8);
+
+        await output.WriteAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async ValueTask WriteGnuTarLongLinkAsync(
+        Stream output,
+        CancellationToken cancellationToken
+    )
+    {
+        var buffer = new byte[BLOCK_SIZE];
+
+        WriteOctalBytes(511, buffer, 100, 8);
+        WriteOctalBytes(0, buffer, 108, 8);
+        WriteOctalBytes(0, buffer, 116, 8);
+
+        var nameByteCount = ArchiveEncoding
+            .GetEncoding()
+            .GetByteCount(Name.NotNull("Name is null"));
+        if (nameByteCount > 100)
+        {
+            WriteStringBytes("././@LongLink", buffer, 0, 100);
+            buffer[156] = (byte)EntryType.LongName;
+            WriteOctalBytes(nameByteCount + 1, buffer, 124, 12);
+        }
+        else
+        {
+            WriteStringBytes(ArchiveEncoding.Encode(Name.NotNull("Name is null")), buffer, 100);
+            WriteOctalBytes(Size, buffer, 124, 12);
+            var time = (long)(LastModifiedTime.ToUniversalTime() - EPOCH).TotalSeconds;
+            WriteOctalBytes(time, buffer, 136, 12);
+            buffer[156] = (byte)EntryType;
+
+            if (Size >= 0x1FFFFFFFF)
+            {
+                Span<byte> bytes12 = stackalloc byte[12];
+                BinaryPrimitives.WriteInt64BigEndian(bytes12.Slice(4), Size);
+                bytes12[0] |= 0x80;
+                bytes12.CopyTo(buffer.AsSpan(124));
+            }
+        }
+
+        var crc = RecalculateChecksum(buffer);
+        WriteOctalBytes(crc, buffer, 148, 8);
+
+        await output.WriteAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false);
+
+        if (nameByteCount > 100)
+        {
+            await WriteLongFilenameHeaderAsync(output, cancellationToken);
+            Name = ArchiveEncoding.Decode(
+                ArchiveEncoding.Encode(Name.NotNull("Name is null")),
+                0,
+                100 - ArchiveEncoding.GetEncoding().GetMaxByteCount(1)
+            );
+            await WriteGnuTarLongLinkAsync(output, cancellationToken);
+        }
+    }
+
+    private async ValueTask WriteLongFilenameHeaderAsync(
+        Stream output,
+        CancellationToken cancellationToken
+    )
+    {
+        var nameBytes = ArchiveEncoding.Encode(Name.NotNull("Name is null"));
+        await output
+            .WriteAsync(nameBytes, 0, nameBytes.Length, cancellationToken)
+            .ConfigureAwait(false);
+
+        var numPaddingBytes = BLOCK_SIZE - (nameBytes.Length % BLOCK_SIZE);
+        if (numPaddingBytes == 0)
+        {
+            numPaddingBytes = BLOCK_SIZE;
+        }
+
+        await output
+            .WriteAsync(new byte[numPaddingBytes], 0, numPaddingBytes, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
+    internal async ValueTask<bool> ReadAsync(AsyncBinaryReader reader)
+    {
+        string? longName = null;
+        string? longLinkName = null;
+        var hasLongValue = true;
+        byte[] buffer;
+        EntryType entryType;
+
+        do
+        {
+            buffer = await ReadBlockAsync(reader);
+
+            if (buffer.Length == 0)
+            {
+                return false;
+            }
+
+            entryType = ReadEntryType(buffer);
+
+            // LongName and LongLink headers can follow each other and need
+            // to apply to the header that follows them.
+            if (entryType == EntryType.LongName)
+            {
+                longName = await ReadLongNameAsync(reader, buffer);
+                continue;
+            }
+            else if (entryType == EntryType.LongLink)
+            {
+                longLinkName = await ReadLongNameAsync(reader, buffer);
+                continue;
+            }
+
+            hasLongValue = false;
+        } while (hasLongValue);
+
+        // Check header checksum
+        if (!checkChecksum(buffer))
+        {
+            return false;
+        }
+
+        Name = longName ?? ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
+        EntryType = entryType;
+        Size = ReadSize(buffer);
+
+        // for symlinks, additionally read the linkname
+        if (entryType == EntryType.SymLink || entryType == EntryType.HardLink)
+        {
+            LinkName = longLinkName ?? ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
+        }
+
+        Mode = ReadAsciiInt64Base8(buffer, 100, 7);
+
+        if (entryType == EntryType.Directory)
+        {
+            Mode |= 0b1_000_000_000;
+        }
+
+        UserId = ReadAsciiInt64Base8oldGnu(buffer, 108, 7);
+        GroupId = ReadAsciiInt64Base8oldGnu(buffer, 116, 7);
+
+        var unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
+
+        LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();
+        Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();
+
+        if (!string.IsNullOrEmpty(Magic) && "ustar".Equals(Magic))
+        {
+            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157).TrimNulls();
+
+            if (!string.IsNullOrEmpty(namePrefix))
+            {
+                Name = namePrefix + "/" + Name;
+            }
+        }
+
+        if (entryType != EntryType.LongName && Name.Length == 0)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    private static async ValueTask<byte[]> ReadBlockAsync(AsyncBinaryReader reader)
+    {
+        var buffer = ArrayPool<byte>.Shared.Rent(BLOCK_SIZE);
+        try
+        {
+            await reader.ReadBytesAsync(buffer, 0, BLOCK_SIZE);
+
+            if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
+            {
+                throw new InvalidFormatException("Buffer is invalid size");
+            }
+
+            return buffer;
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+    }
+
+    private async ValueTask<string> ReadLongNameAsync(AsyncBinaryReader reader, byte[] buffer)
+    {
+        var size = ReadSize(buffer);
+
+        // Validate size to prevent memory exhaustion from malformed headers
+        if (size < 0 || size > MAX_LONG_NAME_SIZE)
+        {
+            throw new InvalidFormatException(
+                $"Long name size {size} is invalid or exceeds maximum allowed size of {MAX_LONG_NAME_SIZE} bytes"
+            );
+        }
+
+        var nameLength = (int)size;
+        var nameBytes = ArrayPool<byte>.Shared.Rent(nameLength);
+        try
+        {
+            await reader.ReadBytesAsync(nameBytes, 0, nameLength);
+            var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);
+
+            // Read the rest of the block and discard the data
+            if (remainingBytesToRead < BLOCK_SIZE)
+            {
+                var remainingBytes = ArrayPool<byte>.Shared.Rent(remainingBytesToRead);
+                try
+                {
+                    await reader.ReadBytesAsync(remainingBytes, 0, remainingBytesToRead);
+                }
+                finally
+                {
+                    ArrayPool<byte>.Shared.Return(remainingBytes);
+                }
+            }
+
+            return ArchiveEncoding.Decode(nameBytes, 0, nameLength).TrimNulls();
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(nameBytes);
+        }
+    }
+}

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

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Tar.Headers;
 
-internal sealed class TarHeader
+internal sealed partial class TarHeader
 {
     internal static readonly DateTime EPOCH = new(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
@@ -112,14 +112,18 @@ internal sealed class TarHeader
             string name = fullName.Substring(splitIndex + 1);
 
             if (this.ArchiveEncoding.GetEncoding().GetByteCount(namePrefix) >= 155)
+            {
                 throw new Exception(
                     $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!"
                 );
+            }
 
             if (this.ArchiveEncoding.GetEncoding().GetByteCount(name) >= 100)
+            {
                 throw new Exception(
                     $"Tar header USTAR format can not fit file name \"{fullName}\" of length {nameByteCount}! Try using GNU Tar format instead!"
                 );
+            }
 
             // write name prefix
             WriteStringBytes(ArchiveEncoding.Encode(namePrefix), buffer, 345, 100);
@@ -497,90 +501,6 @@ internal sealed class TarHeader
         return true;
     }
 
-    internal async Task<bool> ReadAsync(AsyncBinaryReader reader)
-    {
-        string? longName = null;
-        string? longLinkName = null;
-        var hasLongValue = true;
-        byte[] buffer;
-        EntryType entryType;
-
-        do
-        {
-            buffer = await ReadBlockAsync(reader);
-
-            if (buffer.Length == 0)
-            {
-                return false;
-            }
-
-            entryType = ReadEntryType(buffer);
-
-            // LongName and LongLink headers can follow each other and need
-            // to apply to the header that follows them.
-            if (entryType == EntryType.LongName)
-            {
-                longName = await ReadLongNameAsync(reader, buffer);
-                continue;
-            }
-            else if (entryType == EntryType.LongLink)
-            {
-                longLinkName = await ReadLongNameAsync(reader, buffer);
-                continue;
-            }
-
-            hasLongValue = false;
-        } while (hasLongValue);
-
-        // Check header checksum
-        if (!checkChecksum(buffer))
-        {
-            return false;
-        }
-
-        Name = longName ?? ArchiveEncoding.Decode(buffer, 0, 100).TrimNulls();
-        EntryType = entryType;
-        Size = ReadSize(buffer);
-
-        // for symlinks, additionally read the linkname
-        if (entryType == EntryType.SymLink || entryType == EntryType.HardLink)
-        {
-            LinkName = longLinkName ?? ArchiveEncoding.Decode(buffer, 157, 100).TrimNulls();
-        }
-
-        Mode = ReadAsciiInt64Base8(buffer, 100, 7);
-
-        if (entryType == EntryType.Directory)
-        {
-            Mode |= 0b1_000_000_000;
-        }
-
-        UserId = ReadAsciiInt64Base8oldGnu(buffer, 108, 7);
-        GroupId = ReadAsciiInt64Base8oldGnu(buffer, 116, 7);
-
-        var unixTimeStamp = ReadAsciiInt64Base8(buffer, 136, 11);
-
-        LastModifiedTime = EPOCH.AddSeconds(unixTimeStamp).ToLocalTime();
-        Magic = ArchiveEncoding.Decode(buffer, 257, 6).TrimNulls();
-
-        if (!string.IsNullOrEmpty(Magic) && "ustar".Equals(Magic))
-        {
-            var namePrefix = ArchiveEncoding.Decode(buffer, 345, 157).TrimNulls();
-
-            if (!string.IsNullOrEmpty(namePrefix))
-            {
-                Name = namePrefix + "/" + Name;
-            }
-        }
-
-        if (entryType != EntryType.LongName && Name.Length == 0)
-        {
-            return false;
-        }
-
-        return true;
-    }
-
     internal static int RecalculateChecksum(byte[] buf)
     {
         // Set default value for checksum. That is 8 spaces.
@@ -616,65 +536,4 @@ internal sealed class TarHeader
     public long? DataStartPosition { get; set; }
 
     public string? Magic { get; set; }
-
-    private static async ValueTask<byte[]> ReadBlockAsync(AsyncBinaryReader reader)
-    {
-        var buffer = ArrayPool<byte>.Shared.Rent(BLOCK_SIZE);
-        try
-        {
-            await reader.ReadBytesAsync(buffer, 0, BLOCK_SIZE);
-
-            if (buffer.Length != 0 && buffer.Length < BLOCK_SIZE)
-            {
-                throw new InvalidFormatException("Buffer is invalid size");
-            }
-
-            return buffer;
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(buffer);
-        }
-    }
-
-    private async Task<string> ReadLongNameAsync(AsyncBinaryReader reader, byte[] buffer)
-    {
-        var size = ReadSize(buffer);
-
-        // Validate size to prevent memory exhaustion from malformed headers
-        if (size < 0 || size > MAX_LONG_NAME_SIZE)
-        {
-            throw new InvalidFormatException(
-                $"Long name size {size} is invalid or exceeds maximum allowed size of {MAX_LONG_NAME_SIZE} bytes"
-            );
-        }
-
-        var nameLength = (int)size;
-        var nameBytes = ArrayPool<byte>.Shared.Rent(nameLength);
-        try
-        {
-            await reader.ReadBytesAsync(buffer, 0, nameLength);
-            var remainingBytesToRead = BLOCK_SIZE - (nameLength % BLOCK_SIZE);
-
-            // Read the rest of the block and discard the data
-            if (remainingBytesToRead < BLOCK_SIZE)
-            {
-                var remainingBytes = ArrayPool<byte>.Shared.Rent(remainingBytesToRead);
-                try
-                {
-                    await reader.ReadBytesAsync(remainingBytes, 0, remainingBytesToRead);
-                }
-                finally
-                {
-                    ArrayPool<byte>.Shared.Return(nameBytes);
-                }
-            }
-
-            return ArchiveEncoding.Decode(nameBytes, 0, nameLength).TrimNulls();
-        }
-        finally
-        {
-            ArrayPool<byte>.Shared.Return(nameBytes);
-        }
-    }
 }

src/SharpCompress/Common/Tar/TarEntry.Async.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Tar;
+
+public partial class TarEntry
+{
+    internal static async IAsyncEnumerable<TarEntry> GetEntriesAsync(
+        StreamingMode mode,
+        Stream stream,
+        CompressionType compressionType,
+        IArchiveEncoding archiveEncoding
+    )
+    {
+        await foreach (
+            var header in TarHeaderFactory.ReadHeaderAsync(mode, stream, archiveEncoding)
+        )
+        {
+            if (header != null)
+            {
+                if (mode == StreamingMode.Seekable)
+                {
+                    yield return new TarEntry(new TarFilePart(header, stream), compressionType);
+                }
+                else
+                {
+                    yield return new TarEntry(new TarFilePart(header, null), compressionType);
+                }
+            }
+            else
+            {
+                throw new IncompleteArchiveException("Unexpected EOF reading tar file");
+            }
+        }
+    }
+}

src/SharpCompress/Common/Tar/TarEntry.cs

@@ -6,7 +6,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar;
 
-public class TarEntry : Entry
+public partial class TarEntry : Entry
 {
     private readonly TarFilePart? _filePart;
 
@@ -76,4 +76,6 @@ public class TarEntry : Entry
             }
         }
     }
+
+    // Async methods moved to TarEntry.Async.cs
 }

src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.IO;
+using SharpCompress.Common.Tar.Headers;
+using SharpCompress.IO;
+
+namespace SharpCompress.Common.Tar;
+
+internal static partial class TarHeaderFactory
+{
+    internal static async IAsyncEnumerable<TarHeader?> ReadHeaderAsync(
+        StreamingMode mode,
+        Stream stream,
+        IArchiveEncoding archiveEncoding
+    )
+    {
+        while (true)
+        {
+            TarHeader? header = null;
+            try
+            {
+                var reader = new AsyncBinaryReader(stream, false);
+                header = new TarHeader(archiveEncoding);
+                if (!await header.ReadAsync(reader))
+                {
+                    yield break;
+                }
+                switch (mode)
+                {
+                    case StreamingMode.Seekable:
+                        {
+                            header.DataStartPosition = stream.Position;
+
+                            //skip to nearest 512
+                            stream.Position += PadTo512(header.Size);
+                        }
+                        break;
+                    case StreamingMode.Streaming:
+                        {
+                            header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
+                        }
+                        break;
+                    default:
+                    {
+                        throw new InvalidFormatException("Invalid StreamingMode");
+                    }
+                }
+            }
+            catch
+            {
+                header = null;
+            }
+            yield return header;
+        }
+    }
+}

src/SharpCompress/Common/Tar/TarHeaderFactory.cs

@@ -5,7 +5,7 @@ using SharpCompress.IO;
 
 namespace SharpCompress.Common.Tar;
 
-internal static class TarHeaderFactory
+internal static partial class TarHeaderFactory
 {
     internal static IEnumerable<TarHeader?> ReadHeader(
         StreamingMode mode,
@@ -26,52 +26,6 @@ internal static class TarHeaderFactory
                     yield break;
                 }
                 switch (mode)
-                {
-                    case StreamingMode.Seekable:
-                        {
-                            header.DataStartPosition = reader.BaseStream.Position;
-
-                            //skip to nearest 512
-                            reader.BaseStream.Position += PadTo512(header.Size);
-                        }
-                        break;
-                    case StreamingMode.Streaming:
-                        {
-                            header.PackedStream = new TarReadOnlySubStream(stream, header.Size);
-                        }
-                        break;
-                    default:
-                    {
-                        throw new InvalidFormatException("Invalid StreamingMode");
-                    }
-                }
-            }
-            catch
-            {
-                header = null;
-            }
-            yield return header;
-        }
-    }
-
-    internal static async IAsyncEnumerable<TarHeader?> ReadHeaderAsync(
-        StreamingMode mode,
-        Stream stream,
-        IArchiveEncoding archiveEncoding
-    )
-    {
-        while (true)
-        {
-            TarHeader? header = null;
-            try
-            {
-                var reader = new AsyncBinaryReader(stream, false);
-                header = new TarHeader(archiveEncoding);
-                if (!await header.ReadAsync(reader))
-                {
-                    yield break;
-                }
-                switch (mode)
                 {
                     case StreamingMode.Seekable:
                         {
@@ -100,6 +54,8 @@ internal static class TarHeaderFactory
         }
     }
 
+    // Async methods moved to TarHeaderFactory.Async.cs
+
     private static long PadTo512(long size)
     {
         var zeros = (int)(size % 512);

src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs

@@ -66,7 +66,7 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
         base.Dispose(disposing);
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
+#if !LEGACY_DOTNET
     public override async System.Threading.Tasks.ValueTask DisposeAsync()
     {
         if (_isDisposed)
@@ -170,7 +170,7 @@ internal class TarReadOnlySubStream : SharpCompressStream, IStreamStack
         return read;
     }
 
-#if !NETFRAMEWORK && !NETSTANDARD2_0
+#if !LEGACY_DOTNET
     public override async System.Threading.Tasks.ValueTask<int> ReadAsync(
         System.Memory<byte> buffer,
         System.Threading.CancellationToken cancellationToken = default

src/SharpCompress/Common/Volume.Async.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common;
+
+public abstract partial class Volume
+{
+    public virtual async ValueTask DisposeAsync()
+    {
+#if LEGACY_DOTNET
+        _actualStream.Dispose();
+        await Task.CompletedTask;
+#else
+        await _actualStream.DisposeAsync().ConfigureAwait(false);
+#endif
+        GC.SuppressFinalize(this);
+    }
+}

src/SharpCompress/Common/Volume.cs

@@ -1,11 +1,12 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Common;
 
-public abstract class Volume : IVolume
+public abstract partial class Volume : IVolume, IAsyncDisposable
 {
     private readonly Stream _baseStream;
     private readonly Stream _actualStream;
@@ -21,7 +22,9 @@ public abstract class Volume : IVolume
         }
 
         if (stream is IStreamStack ss)
+        {
             ss.SetBuffer(ReaderOptions.BufferSize, true);
+        }
 
         _actualStream = stream;
     }

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

@@ -0,0 +1,20 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Zip.Headers;
+
+internal partial class DirectoryEndHeader
+{
+    internal override async ValueTask Read(AsyncBinaryReader reader)
+    {
+        VolumeNumber = await reader.ReadUInt16Async();
+        FirstVolumeWithDirectory = await reader.ReadUInt16Async();
+        TotalNumberOfEntriesInDisk = await reader.ReadUInt16Async();
+        TotalNumberOfEntries = await reader.ReadUInt16Async();
+        DirectorySize = await reader.ReadUInt32Async();
+        DirectoryStartOffsetRelativeToDisk = await reader.ReadUInt32Async();
+        CommentLength = await reader.ReadUInt16Async();
+        Comment = new byte[CommentLength];
+        await reader.ReadBytesAsync(Comment, 0, CommentLength);
+    }
+}

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

@@ -1,9 +1,8 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class DirectoryEndHeader : ZipHeader
+internal partial class DirectoryEndHeader : ZipHeader
 {
     public DirectoryEndHeader()
         : base(ZipHeaderType.DirectoryEnd) { }
@@ -20,19 +19,6 @@ internal class DirectoryEndHeader : ZipHeader
         Comment = reader.ReadBytes(CommentLength);
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        VolumeNumber = await reader.ReadUInt16Async();
-        FirstVolumeWithDirectory = await reader.ReadUInt16Async();
-        TotalNumberOfEntriesInDisk = await reader.ReadUInt16Async();
-        TotalNumberOfEntries = await reader.ReadUInt16Async();
-        DirectorySize = await reader.ReadUInt32Async();
-        DirectoryStartOffsetRelativeToDisk = await reader.ReadUInt32Async();
-        CommentLength = await reader.ReadUInt16Async();
-        Comment = new byte[CommentLength];
-        await reader.ReadBytesAsync(Comment, 0, CommentLength);
-    }
-
     public ushort VolumeNumber { get; private set; }
 
     public ushort FirstVolumeWithDirectory { get; private set; }

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

@@ -0,0 +1,37 @@
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using SharpCompress.Common;
+
+namespace SharpCompress.Common.Zip.Headers;
+
+internal partial class DirectoryEntryHeader
+{
+    internal override async ValueTask Read(AsyncBinaryReader reader)
+    {
+        Version = await reader.ReadUInt16Async();
+        VersionNeededToExtract = await reader.ReadUInt16Async();
+        Flags = (HeaderFlags)await reader.ReadUInt16Async();
+        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
+        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
+        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
+        Crc = await reader.ReadUInt32Async();
+        CompressedSize = await reader.ReadUInt32Async();
+        UncompressedSize = await reader.ReadUInt32Async();
+        var nameLength = await reader.ReadUInt16Async();
+        var extraLength = await reader.ReadUInt16Async();
+        var commentLength = await reader.ReadUInt16Async();
+        DiskNumberStart = await reader.ReadUInt16Async();
+        InternalFileAttributes = await reader.ReadUInt16Async();
+        ExternalFileAttributes = await reader.ReadUInt32Async();
+        RelativeOffsetOfEntryHeader = await reader.ReadUInt32Async();
+        var name = new byte[nameLength];
+        var extra = new byte[extraLength];
+        var comment = new byte[commentLength];
+        await reader.ReadBytesAsync(name, 0, nameLength);
+        await reader.ReadBytesAsync(extra, 0, extraLength);
+        await reader.ReadBytesAsync(comment, 0, commentLength);
+
+        ProcessReadData(name, extra, comment);
+    }
+}

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

@@ -1,10 +1,9 @@
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class DirectoryEntryHeader : ZipFileEntry
+internal partial class DirectoryEntryHeader : ZipFileEntry
 {
     public DirectoryEntryHeader(IArchiveEncoding archiveEncoding)
         : base(ZipHeaderType.DirectoryEntry, archiveEncoding) { }
@@ -35,34 +34,6 @@ internal class DirectoryEntryHeader : ZipFileEntry
         ProcessReadData(name, extra, comment);
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        Version = await reader.ReadUInt16Async();
-        VersionNeededToExtract = await reader.ReadUInt16Async();
-        Flags = (HeaderFlags)await reader.ReadUInt16Async();
-        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
-        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
-        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
-        Crc = await reader.ReadUInt32Async();
-        CompressedSize = await reader.ReadUInt32Async();
-        UncompressedSize = await reader.ReadUInt32Async();
-        var nameLength = await reader.ReadUInt16Async();
-        var extraLength = await reader.ReadUInt16Async();
-        var commentLength = await reader.ReadUInt16Async();
-        DiskNumberStart = await reader.ReadUInt16Async();
-        InternalFileAttributes = await reader.ReadUInt16Async();
-        ExternalFileAttributes = await reader.ReadUInt32Async();
-        RelativeOffsetOfEntryHeader = await reader.ReadUInt32Async();
-        var name = new byte[nameLength];
-        var extra = new byte[extraLength];
-        var comment = new byte[commentLength];
-        await reader.ReadBytesAsync(name, 0, nameLength);
-        await reader.ReadBytesAsync(extra, 0, extraLength);
-        await reader.ReadBytesAsync(comment, 0, commentLength);
-
-        ProcessReadData(name, extra, comment);
-    }
-
     private void ProcessReadData(byte[] name, byte[] extra, byte[] comment)
     {
         //

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

@@ -0,0 +1,28 @@
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Zip.Headers;
+
+internal partial class LocalEntryHeader
+{
+    internal override async ValueTask Read(AsyncBinaryReader reader)
+    {
+        Version = await reader.ReadUInt16Async();
+        Flags = (HeaderFlags)await reader.ReadUInt16Async();
+        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
+        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
+        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
+        Crc = await reader.ReadUInt32Async();
+        CompressedSize = await reader.ReadUInt32Async();
+        UncompressedSize = await reader.ReadUInt32Async();
+        var nameLength = await reader.ReadUInt16Async();
+        var extraLength = await reader.ReadUInt16Async();
+        var name = new byte[nameLength];
+        var extra = new byte[extraLength];
+        await reader.ReadBytesAsync(name, 0, nameLength);
+        await reader.ReadBytesAsync(extra, 0, extraLength);
+
+        ProcessReadData(name, extra);
+    }
+}

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

@@ -1,12 +1,13 @@
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class LocalEntryHeader(IArchiveEncoding archiveEncoding)
-    : ZipFileEntry(ZipHeaderType.LocalEntry, archiveEncoding)
+internal partial class LocalEntryHeader : ZipFileEntry
 {
+    public LocalEntryHeader(IArchiveEncoding archiveEncoding)
+        : base(ZipHeaderType.LocalEntry, archiveEncoding) { }
+
     internal override void Read(BinaryReader reader)
     {
         Version = reader.ReadUInt16();
@@ -25,26 +26,6 @@ internal class LocalEntryHeader(IArchiveEncoding archiveEncoding)
         ProcessReadData(name, extra);
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        Version = await reader.ReadUInt16Async();
-        Flags = (HeaderFlags)await reader.ReadUInt16Async();
-        CompressionMethod = (ZipCompressionMethod)await reader.ReadUInt16Async();
-        OriginalLastModifiedTime = LastModifiedTime = await reader.ReadUInt16Async();
-        OriginalLastModifiedDate = LastModifiedDate = await reader.ReadUInt16Async();
-        Crc = await reader.ReadUInt32Async();
-        CompressedSize = await reader.ReadUInt32Async();
-        UncompressedSize = await reader.ReadUInt32Async();
-        var nameLength = await reader.ReadUInt16Async();
-        var extraLength = await reader.ReadUInt16Async();
-        var name = new byte[nameLength];
-        var extra = new byte[extraLength];
-        await reader.ReadBytesAsync(name, 0, nameLength);
-        await reader.ReadBytesAsync(extra, 0, extraLength);
-
-        ProcessReadData(name, extra);
-    }
-
     private void ProcessReadData(byte[] name, byte[] extra)
     {
         //

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

@@ -0,0 +1,25 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Zip.Headers;
+
+internal partial class Zip64DirectoryEndHeader
+{
+    internal override async ValueTask Read(AsyncBinaryReader reader)
+    {
+        SizeOfDirectoryEndRecord = (long)await reader.ReadUInt64Async();
+        VersionMadeBy = await reader.ReadUInt16Async();
+        VersionNeededToExtract = await reader.ReadUInt16Async();
+        VolumeNumber = await reader.ReadUInt32Async();
+        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
+        TotalNumberOfEntriesInDisk = (long)await reader.ReadUInt64Async();
+        TotalNumberOfEntries = (long)await reader.ReadUInt64Async();
+        DirectorySize = (long)await reader.ReadUInt64Async();
+        DirectoryStartOffsetRelativeToDisk = (long)await reader.ReadUInt64Async();
+        var size = (int)(
+            SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
+        );
+        DataSector = new byte[size];
+        await reader.ReadBytesAsync(DataSector, 0, size);
+    }
+}

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

@@ -1,9 +1,8 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class Zip64DirectoryEndHeader : ZipHeader
+internal partial class Zip64DirectoryEndHeader : ZipHeader
 {
     public Zip64DirectoryEndHeader()
         : base(ZipHeaderType.Zip64DirectoryEnd) { }
@@ -27,24 +26,6 @@ internal class Zip64DirectoryEndHeader : ZipHeader
         );
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        SizeOfDirectoryEndRecord = (long)await reader.ReadUInt64Async();
-        VersionMadeBy = await reader.ReadUInt16Async();
-        VersionNeededToExtract = await reader.ReadUInt16Async();
-        VolumeNumber = await reader.ReadUInt32Async();
-        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
-        TotalNumberOfEntriesInDisk = (long)await reader.ReadUInt64Async();
-        TotalNumberOfEntries = (long)await reader.ReadUInt64Async();
-        DirectorySize = (long)await reader.ReadUInt64Async();
-        DirectoryStartOffsetRelativeToDisk = (long)await reader.ReadUInt64Async();
-        var size = (int)(
-            SizeOfDirectoryEndRecord - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
-        );
-        DataSector = new byte[size];
-        await reader.ReadBytesAsync(DataSector, 0, size);
-    }
-
     private const int SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS = 44;
 
     public long SizeOfDirectoryEndRecord { get; private set; }

src/SharpCompress/Common/Zip/Headers/Zip64DirectoryEndLocatorHeader.Async.cs

@@ -0,0 +1,14 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Zip.Headers;
+
+internal partial class Zip64DirectoryEndLocatorHeader
+{
+    internal override async ValueTask Read(AsyncBinaryReader reader)
+    {
+        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
+        RelativeOffsetOfTheEndOfDirectoryRecord = (long)await reader.ReadUInt64Async();
+        TotalNumberOfVolumes = await reader.ReadUInt32Async();
+    }
+}

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

@@ -1,9 +1,9 @@
 using System.IO;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class Zip64DirectoryEndLocatorHeader() : ZipHeader(ZipHeaderType.Zip64DirectoryEndLocator)
+internal partial class Zip64DirectoryEndLocatorHeader()
+    : ZipHeader(ZipHeaderType.Zip64DirectoryEndLocator)
 {
     internal override void Read(BinaryReader reader)
     {
@@ -12,13 +12,6 @@ internal class Zip64DirectoryEndLocatorHeader() : ZipHeader(ZipHeaderType.Zip64D
         TotalNumberOfVolumes = reader.ReadUInt32();
     }
 
-    internal override async ValueTask Read(AsyncBinaryReader reader)
-    {
-        FirstVolumeWithDirectory = await reader.ReadUInt32Async();
-        RelativeOffsetOfTheEndOfDirectoryRecord = (long)await reader.ReadUInt64Async();
-        TotalNumberOfVolumes = await reader.ReadUInt32Async();
-    }
-
     public uint FirstVolumeWithDirectory { get; private set; }
 
     public long RelativeOffsetOfTheEndOfDirectoryRecord { get; private set; }

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

@@ -0,0 +1,27 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common.Zip.Headers;
+
+internal abstract partial class ZipFileEntry
+{
+    internal async ValueTask<PkwareTraditionalEncryptionData> ComposeEncryptionDataAsync(
+        Stream archiveStream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (archiveStream is null)
+        {
+            throw new ArgumentNullException(nameof(archiveStream));
+        }
+
+        var buffer = new byte[12];
+        await archiveStream.ReadFullyAsync(buffer, 0, 12, cancellationToken).ConfigureAwait(false);
+
+        var encryptionData = PkwareTraditionalEncryptionData.ForRead(Password!, this, buffer);
+
+        return encryptionData;
+    }
+}

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

@@ -2,12 +2,10 @@ using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal abstract class ZipFileEntry(ZipHeaderType type, IArchiveEncoding archiveEncoding)
+internal abstract partial class ZipFileEntry(ZipHeaderType type, IArchiveEncoding archiveEncoding)
     : ZipHeader(type)
 {
     internal bool IsDirectory
@@ -59,24 +57,6 @@ internal abstract class ZipFileEntry(ZipHeaderType type, IArchiveEncoding archiv
         return encryptionData;
     }
 
-    internal async ValueTask<PkwareTraditionalEncryptionData> ComposeEncryptionDataAsync(
-        Stream archiveStream,
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (archiveStream is null)
-        {
-            throw new ArgumentNullException(nameof(archiveStream));
-        }
-
-        var buffer = new byte[12];
-        await archiveStream.ReadFullyAsync(buffer, 0, 12, cancellationToken).ConfigureAwait(false);
-
-        var encryptionData = PkwareTraditionalEncryptionData.ForRead(Password!, this, buffer);
-
-        return encryptionData;
-    }
-
     internal WinzipAesEncryptionData? WinzipAesEncryptionData { get; set; }
 
     /// <summary>
@@ -137,7 +117,7 @@ internal abstract class ZipFileEntry(ZipHeaderType type, IArchiveEncoding archiv
             if (i + 4 + length > extra.Length)
             {
                 // incomplete or corrupt field
-                break; // allow processing optional other blocks
+                break; // allow processing other blocks
             }
 
             var data = new byte[length];

src/SharpCompress/Common/Zip/SeekableZipFilePart.Async.cs

@@ -0,0 +1,24 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using SharpCompress.Common.Zip.Headers;
+
+namespace SharpCompress.Common.Zip;
+
+internal partial class SeekableZipFilePart
+{
+    internal override async ValueTask<Stream?> GetCompressedStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!_isLocalHeaderLoaded)
+        {
+            await LoadLocalHeaderAsync(cancellationToken);
+            _isLocalHeaderLoaded = true;
+        }
+        return await base.GetCompressedStreamAsync(cancellationToken);
+    }
+
+    private async ValueTask LoadLocalHeaderAsync(CancellationToken cancellationToken = default) =>
+        Header = await _headerFactory.GetLocalHeaderAsync(BaseStream, (DirectoryEntryHeader)Header);
+}

src/SharpCompress/Common/Zip/SeekableZipFilePart.cs

@@ -1,11 +1,9 @@
 using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 
 namespace SharpCompress.Common.Zip;
 
-internal class SeekableZipFilePart : ZipFilePart
+internal partial class SeekableZipFilePart : ZipFilePart
 {
     private bool _isLocalHeaderLoaded;
     private readonly SeekableZipHeaderFactory _headerFactory;
@@ -27,24 +25,9 @@ internal class SeekableZipFilePart : ZipFilePart
         return base.GetCompressedStream();
     }
 
-    internal override async ValueTask<Stream?> GetCompressedStreamAsync(
-        CancellationToken cancellationToken = default
-    )
-    {
-        if (!_isLocalHeaderLoaded)
-        {
-            await LoadLocalHeaderAsync(cancellationToken);
-            _isLocalHeaderLoaded = true;
-        }
-        return await base.GetCompressedStreamAsync(cancellationToken);
-    }
-
     private void LoadLocalHeader() =>
         Header = _headerFactory.GetLocalHeader(BaseStream, (DirectoryEntryHeader)Header);
 
-    private async ValueTask LoadLocalHeaderAsync(CancellationToken cancellationToken = default) =>
-        Header = await _headerFactory.GetLocalHeaderAsync(BaseStream, (DirectoryEntryHeader)Header);
-
     protected override Stream CreateBaseStream()
     {
         BaseStream.Position = Header.DataStartPosition.NotNull();

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.Async.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using SharpCompress.Common.Zip.Headers;
+
+namespace SharpCompress.Common.Zip;
+
+internal sealed partial class SeekableZipHeaderFactory
+{
+    internal async IAsyncEnumerable<ZipHeader> ReadSeekableHeaderAsync(Stream stream)
+    {
+        var reader = new AsyncBinaryReader(stream);
+
+        await SeekBackToHeaderAsync(stream, reader);
+
+        var eocd_location = stream.Position;
+        var entry = new DirectoryEndHeader();
+        await entry.Read(reader);
+
+        if (entry.IsZip64)
+        {
+            _zip64 = true;
+
+            // ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR should be before the EOCD
+            stream.Seek(eocd_location - ZIP64_EOCD_LENGTH - 4, SeekOrigin.Begin);
+            uint zip64_locator = await reader.ReadUInt32Async();
+            if (zip64_locator != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR)
+            {
+                throw new ArchiveException("Failed to locate the Zip64 Directory Locator");
+            }
+
+            var zip64Locator = new Zip64DirectoryEndLocatorHeader();
+            await zip64Locator.Read(reader);
+
+            stream.Seek(zip64Locator.RelativeOffsetOfTheEndOfDirectoryRecord, SeekOrigin.Begin);
+            var zip64Signature = await reader.ReadUInt32Async();
+            if (zip64Signature != ZIP64_END_OF_CENTRAL_DIRECTORY)
+            {
+                throw new ArchiveException("Failed to locate the Zip64 Header");
+            }
+
+            var zip64Entry = new Zip64DirectoryEndHeader();
+            await zip64Entry.Read(reader);
+            stream.Seek(zip64Entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
+        }
+        else
+        {
+            stream.Seek(entry.DirectoryStartOffsetRelativeToDisk, SeekOrigin.Begin);
+        }
+
+        var position = stream.Position;
+        while (true)
+        {
+            stream.Position = position;
+            var signature = await reader.ReadUInt32Async();
+            var nextHeader = await ReadHeader(signature, reader, _zip64);
+            position = stream.Position;
+
+            if (nextHeader is null)
+            {
+                yield break;
+            }
+
+            if (nextHeader is DirectoryEntryHeader entryHeader)
+            {
+                //entry could be zero bytes so we need to know that.
+                entryHeader.HasData = entryHeader.CompressedSize != 0;
+                yield return entryHeader;
+            }
+            else if (nextHeader is DirectoryEndHeader endHeader)
+            {
+                yield return endHeader;
+            }
+        }
+    }
+
+    private static async ValueTask SeekBackToHeaderAsync(Stream stream, AsyncBinaryReader reader)
+    {
+        // Minimum EOCD length
+        if (stream.Length < MINIMUM_EOCD_LENGTH)
+        {
+            throw new ArchiveException(
+                "Could not find Zip file Directory at the end of the file. File may be corrupted."
+            );
+        }
+
+        var len =
+            stream.Length < MAX_SEARCH_LENGTH_FOR_EOCD
+                ? (int)stream.Length
+                : MAX_SEARCH_LENGTH_FOR_EOCD;
+
+        stream.Seek(-len, SeekOrigin.End);
+        var seek = ArrayPool<byte>.Shared.Rent(len);
+
+        try
+        {
+            await reader.ReadBytesAsync(seek, 0, len, default);
+            var memory = new Memory<byte>(seek, 0, len);
+            var span = memory.Span;
+            span.Reverse();
+
+            // don't exclude the minimum eocd region, otherwise you fail to locate the header in empty zip files
+            var max_search_area = len; // - MINIMUM_EOCD_LENGTH;
+
+            for (var pos_from_end = 0; pos_from_end < max_search_area; ++pos_from_end)
+            {
+                if (IsMatch(span, pos_from_end, needle))
+                {
+                    stream.Seek(-pos_from_end, SeekOrigin.End);
+                    return;
+                }
+            }
+
+            throw new ArchiveException("Failed to locate the Zip Header");
+        }
+        finally
+        {
+            ArrayPool<byte>.Shared.Return(seek);
+        }
+    }
+
+    internal async ValueTask<LocalEntryHeader> GetLocalHeaderAsync(
+        Stream stream,
+        DirectoryEntryHeader directoryEntryHeader
+    )
+    {
+        stream.Seek(directoryEntryHeader.RelativeOffsetOfEntryHeader, SeekOrigin.Begin);
+        var reader = new AsyncBinaryReader(stream);
+        var signature = await reader.ReadUInt32Async();
+        if (await ReadHeader(signature, reader, _zip64) is not LocalEntryHeader localEntryHeader)
+        {
+            throw new InvalidOperationException();
+        }
+
+        // populate fields only known from the DirectoryEntryHeader
+        localEntryHeader.HasData = directoryEntryHeader.HasData;
+        localEntryHeader.ExternalFileAttributes = directoryEntryHeader.ExternalFileAttributes;
+        localEntryHeader.Comment = directoryEntryHeader.Comment;
+
+        if (FlagUtility.HasFlag(localEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor))
+        {
+            localEntryHeader.Crc = directoryEntryHeader.Crc;
+            localEntryHeader.CompressedSize = directoryEntryHeader.CompressedSize;
+            localEntryHeader.UncompressedSize = directoryEntryHeader.UncompressedSize;
+        }
+        return localEntryHeader;
+    }
+}