async loading for rar is better

Implement full async I/O support for RAR header reading pipeline

src/SharpCompress/Archives/ArchiveFactory.cs

@@ -2,6 +2,8 @@ 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;
@@ -24,6 +26,27 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(stream).Open(stream, readerOptions);
     }
 
+    /// <summary>
+    /// Opens an Archive for random access asynchronously
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        readerOptions ??= new ReaderOptions();
+        stream = SharpCompressStream.Create(stream, bufferSize: readerOptions.BufferSize);
+        var factory = FindFactory<IArchiveFactory>(stream);
+        return await factory
+            .OpenAsync(stream, readerOptions, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     public static IWritableArchive Create(ArchiveType type)
     {
         var factory = Factory
@@ -49,6 +72,22 @@ public static class ArchiveFactory
         return Open(new FileInfo(filePath), options);
     }
 
+    /// <summary>
+    /// Opens an Archive from a filepath asynchronously.
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static Task<IArchive> OpenAsync(
+        string filePath,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenAsync(new FileInfo(filePath), options, cancellationToken);
+    }
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
@@ -61,6 +100,24 @@ public static class ArchiveFactory
         return FindFactory<IArchiveFactory>(fileInfo).Open(fileInfo, options);
     }
 
+    /// <summary>
+    /// Opens an Archive from a FileInfo object asynchronously.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = FindFactory<IArchiveFactory>(fileInfo);
+        return await factory.OpenAsync(fileInfo, options, cancellationToken).ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Constructor with IEnumerable FileInfo objects, multi and split support.
     /// </summary>
@@ -87,6 +144,40 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(fileInfo).Open(filesArray, options);
     }
 
+    /// <summary>
+    /// Opens a multi-part archive from files asynchronously.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        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 OpenAsync(fileInfo, options, cancellationToken).ConfigureAwait(false);
+        }
+
+        fileInfo.NotNull(nameof(fileInfo));
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+
+        var factory = FindFactory<IMultiArchiveFactory>(fileInfo);
+        return await factory
+            .OpenAsync(filesArray, options, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Constructor with IEnumerable FileInfo objects, multi and split support.
     /// </summary>
@@ -113,6 +204,41 @@ public static class ArchiveFactory
         return FindFactory<IMultiArchiveFactory>(firstStream).Open(streamsArray, options);
     }
 
+    /// <summary>
+    /// Opens a multi-part archive from streams asynchronously.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        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 OpenAsync(firstStream, options, cancellationToken).ConfigureAwait(false);
+        }
+
+        firstStream.NotNull(nameof(firstStream));
+        options ??= new ReaderOptions();
+
+        var factory = FindFactory<IMultiArchiveFactory>(firstStream);
+        return await factory
+            .OpenAsync(streamsArray, options, cancellationToken)
+            .ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Extract to specific directory, retaining filename
     /// </summary>

src/SharpCompress/Archives/AutoArchiveFactory.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 
@@ -20,11 +22,30 @@ class AutoArchiveFactory : IArchiveFactory
         int bufferSize = ReaderOptions.DefaultBufferSize
     ) => throw new NotSupportedException();
 
+    public Task<bool> IsArchiveAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    ) => throw new NotSupportedException();
+
     public FileInfo? GetFilePart(int index, FileInfo part1) => throw new NotSupportedException();
 
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         ArchiveFactory.Open(stream, readerOptions);
 
+    public Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => ArchiveFactory.OpenAsync(stream, readerOptions, cancellationToken);
+
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         ArchiveFactory.Open(fileInfo, readerOptions);
+
+    public Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => ArchiveFactory.OpenAsync(fileInfo, readerOptions, cancellationToken);
 }

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -102,6 +102,70 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         );
     }
 
+    /// <summary>
+    /// Opens a GZipArchive asynchronously from a stream.
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a GZipArchive asynchronously from a FileInfo.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a GZipArchive asynchronously from multiple streams.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a GZipArchive asynchronously from multiple FileInfo objects.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
+    }
+
     public static GZipArchive Create() => new();
 
     /// <summary>
@@ -167,6 +231,28 @@ public class GZipArchive : AbstractWritableArchive<GZipArchiveEntry, GZipVolume>
         return true;
     }
 
+    public static async Task<bool> IsGZipFileAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        // read the header on the first read
+        byte[] header = new byte[10];
+
+        // workitem 8501: handle edge case (decompress empty stream)
+        if (!await stream.ReadFullyAsync(header, cancellationToken).ConfigureAwait(false))
+        {
+            return false;
+        }
+
+        if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
     internal GZipArchive()
         : base(ArchiveType.GZip) { }
 

src/SharpCompress/Archives/IArchiveFactory.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -26,10 +28,34 @@ public interface IArchiveFactory : IFactory
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(Stream stream, ReaderOptions? readerOptions = null);
 
+    /// <summary>
+    /// Opens an Archive for random access asynchronously.
+    /// </summary>
+    /// <param name="stream">An open, readable and seekable stream.</param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
     /// <summary>
     /// Constructor with a FileInfo object to an existing file.
     /// </summary>
     /// <param name="fileInfo">the file to open.</param>
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null);
+
+    /// <summary>
+    /// Opens an Archive from a FileInfo object asynchronously.
+    /// </summary>
+    /// <param name="fileInfo">the file to open.</param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Archives/IMultiArchiveFactory.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Factories;
 using SharpCompress.Readers;
 
@@ -27,10 +29,34 @@ public interface IMultiArchiveFactory : IFactory
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null);
 
+    /// <summary>
+    /// Opens a multi-part archive from streams asynchronously.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
+
     /// <summary>
     /// Constructor with IEnumerable Stream objects, multi and split support.
     /// </summary>
     /// <param name="fileInfos"></param>
     /// <param name="readerOptions">reading options.</param>
     IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null);
+
+    /// <summary>
+    /// Opens a multi-part archive from files asynchronously.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions">reading options.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Archives/Rar/RarArchive.cs

@@ -2,6 +2,8 @@ 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.Rar;
 using SharpCompress.Common.Rar.Headers;
@@ -181,6 +183,70 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         );
     }
 
+    /// <summary>
+    /// Opens a RarArchive asynchronously from a stream.
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a RarArchive asynchronously from a FileInfo.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a RarArchive asynchronously from multiple streams.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a RarArchive asynchronously from multiple FileInfo objects.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
+    }
+
     public static bool IsRarFile(string filePath) => IsRarFile(new FileInfo(filePath));
 
     public static bool IsRarFile(FileInfo fileInfo)
@@ -206,5 +272,24 @@ public class RarArchive : AbstractArchive<RarArchiveEntry, RarVolume>
         }
     }
 
+    public static async Task<bool> IsRarFileAsync(
+        Stream stream,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        try
+        {
+            await MarkHeader
+                .ReadAsync(stream, true, false, cancellationToken)
+                .ConfigureAwait(false);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     #endregion
 }

src/SharpCompress/Archives/SevenZip/SevenZipArchive.cs

@@ -105,6 +105,70 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
         );
     }
 
+    /// <summary>
+    /// Opens a SevenZipArchive asynchronously from a stream.
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a SevenZipArchive asynchronously from a FileInfo.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a SevenZipArchive asynchronously from multiple streams.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a SevenZipArchive asynchronously from multiple FileInfo objects.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
+    }
+
     /// <summary>
     /// Constructor with a SourceStream able to handle FileInfo and Streams.
     /// </summary>
@@ -241,6 +305,31 @@ public class SevenZipArchive : AbstractArchive<SevenZipArchiveEntry, SevenZipVol
             }
         }
 
+        protected override async IAsyncEnumerable<SevenZipEntry> GetEntriesAsync(
+            Stream stream,
+            [System.Runtime.CompilerServices.EnumeratorCancellation]
+                CancellationToken cancellationToken = default
+        )
+        {
+            var entries = _archive.Entries.ToList();
+            stream.Position = 0;
+            foreach (var dir in entries.Where(x => x.IsDirectory))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                _currentEntry = dir;
+                yield return dir;
+            }
+            // For non-directory entries, yield them without creating shared streams
+            // Each call to GetEntryStream() will create a fresh decompression stream
+            // to avoid state corruption issues with async operations
+            foreach (var entry in entries.Where(x => !x.IsDirectory))
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                _currentEntry = entry;
+                yield return entry;
+            }
+        }
+
         protected override EntryStream GetEntryStream()
         {
             // Create a fresh decompression stream for each file (no state sharing).

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -103,6 +103,70 @@ public class TarArchive : AbstractWritableArchive<TarArchiveEntry, TarVolume>
         );
     }
 
+    /// <summary>
+    /// Opens a TarArchive asynchronously from a stream.
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a TarArchive asynchronously from a FileInfo.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a TarArchive asynchronously from multiple streams.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a TarArchive asynchronously from multiple FileInfo objects.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
+    }
+
     public static bool IsTarFile(string filePath) => IsTarFile(new FileInfo(filePath));
 
     public static bool IsTarFile(FileInfo fileInfo)

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -124,6 +124,70 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
         );
     }
 
+    /// <summary>
+    /// Opens a ZipArchive asynchronously from a stream.
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a ZipArchive asynchronously from a FileInfo.
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfo, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a ZipArchive asynchronously from multiple streams.
+    /// </summary>
+    /// <param name="streams"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(streams, readerOptions)).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Opens a ZipArchive asynchronously from multiple FileInfo objects.
+    /// </summary>
+    /// <param name="fileInfos"></param>
+    /// <param name="readerOptions"></param>
+    /// <param name="cancellationToken"></param>
+    public static async Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(fileInfos, readerOptions)).ConfigureAwait(false);
+    }
+
     public static bool IsZipFile(
         string filePath,
         string? password = null,
@@ -199,7 +263,93 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
                 if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
                 {
                     var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
-                    var x = z.ReadSeekableHeader(stream).FirstOrDefault();
+                    var x = z.ReadSeekableHeader(stream, useSync: true).FirstOrDefault();
+                    return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static async Task<bool> IsZipFileAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                return false;
+            }
+            return Enum.IsDefined(typeof(ZipHeaderType), header.ZipHeaderType);
+        }
+        catch (CryptographicException)
+        {
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    public static async Task<bool> IsZipMultiAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var headerFactory = new StreamingZipHeaderFactory(password, new ArchiveEncoding(), null);
+        try
+        {
+            if (stream is not SharpCompressStream)
+            {
+                stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+            }
+
+            var header = headerFactory
+                .ReadStreamHeader(stream)
+                .FirstOrDefault(x => x.ZipHeaderType != ZipHeaderType.Split);
+            if (header is null)
+            {
+                if (stream.CanSeek) //could be multipart. Test for central directory - might not be z64 safe
+                {
+                    var z = new SeekableZipHeaderFactory(password, new ArchiveEncoding());
+                    ZipHeader? x = null;
+                    await foreach (
+                        var h in z.ReadSeekableHeader(stream).WithCancellation(cancellationToken)
+                    )
+                    {
+                        x = h;
+                        break;
+                    }
                     return x?.ZipHeaderType == ZipHeaderType.DirectoryEntry;
                 }
                 else
@@ -254,7 +404,9 @@ public class ZipArchive : AbstractWritableArchive<ZipArchiveEntry, ZipVolume>
     protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolume> volumes)
     {
         var vols = volumes.ToArray();
-        foreach (var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream))
+        foreach (
+            var h in headerFactory.NotNull().ReadSeekableHeader(vols.Last().Stream, useSync: true)
+        )
         {
             if (h != null)
             {

src/SharpCompress/Common/AsyncBinaryReader.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Buffers.Binary;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Common
+{
+    public sealed class AsyncBinaryReader : IDisposable
+    {
+        private readonly Stream _stream;
+        private readonly Stream _originalStream;
+        private readonly bool _leaveOpen;
+        private readonly byte[] _buffer = new byte[8];
+        private bool _disposed;
+
+        public AsyncBinaryReader(Stream stream, bool leaveOpen = false, int bufferSize = 4096)
+        {
+            _originalStream = stream ?? throw new ArgumentNullException(nameof(stream));
+            _leaveOpen = leaveOpen;
+
+            // Use the stream directly without wrapping in BufferedStream
+            // BufferedStream uses synchronous Read internally which doesn't work with async-only streams
+            // SharpCompress uses SharpCompressStream for buffering which supports true async reads
+            _stream = stream;
+        }
+
+        public Stream BaseStream => _stream;
+
+        public async ValueTask<byte> ReadByteAsync(CancellationToken ct = default)
+        {
+            await ReadExactAsync(_buffer, 0, 1, ct).ConfigureAwait(false);
+            return _buffer[0];
+        }
+
+        public async ValueTask<ushort> ReadUInt16Async(CancellationToken ct = default)
+        {
+            await ReadExactAsync(_buffer, 0, 2, ct).ConfigureAwait(false);
+            return BinaryPrimitives.ReadUInt16LittleEndian(_buffer);
+        }
+
+        public async ValueTask<uint> ReadUInt32Async(CancellationToken ct = default)
+        {
+            await ReadExactAsync(_buffer, 0, 4, ct).ConfigureAwait(false);
+            return BinaryPrimitives.ReadUInt32LittleEndian(_buffer);
+        }
+
+        public async ValueTask<ulong> ReadUInt64Async(CancellationToken ct = default)
+        {
+            await ReadExactAsync(_buffer, 0, 8, ct).ConfigureAwait(false);
+            return BinaryPrimitives.ReadUInt64LittleEndian(_buffer);
+        }
+
+        public async ValueTask<byte[]> ReadBytesAsync(int count, CancellationToken ct = default)
+        {
+            var result = new byte[count];
+            await ReadExactAsync(result, 0, count, ct).ConfigureAwait(false);
+            return result;
+        }
+
+        private async ValueTask ReadExactAsync(
+            byte[] destination,
+            int offset,
+            int length,
+            CancellationToken ct
+        )
+        {
+            var read = 0;
+            while (read < length)
+            {
+                var n = await _stream
+                    .ReadAsync(destination, offset + read, length - read, ct)
+                    .ConfigureAwait(false);
+                if (n == 0)
+                {
+                    throw new EndOfStreamException();
+                }
+
+                read += n;
+            }
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+
+            // Dispose the original stream if we own it
+            if (!_leaveOpen)
+            {
+                _originalStream.Dispose();
+            }
+        }
+
+#if NET6_0_OR_GREATER
+        public async ValueTask DisposeAsync()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+
+            // Dispose the original stream if we own it
+            if (!_leaveOpen)
+            {
+                await _originalStream.DisposeAsync().ConfigureAwait(false);
+            }
+        }
+#endif
+    }
+}

src/SharpCompress/Common/FilePart.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common;
 
@@ -14,4 +16,8 @@ public abstract class FilePart
     internal abstract Stream? GetCompressedStream();
     internal abstract Stream? GetRawStream();
     internal bool Skipped { get; set; }
+
+    internal virtual Task<Stream?> GetCompressedStreamAsync(
+        CancellationToken cancellationToken = default
+    ) => Task.FromResult(GetCompressedStream());
 }

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

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Rar.Headers;
 
@@ -129,4 +131,130 @@ internal class MarkHeader : IRarHeader
 
         throw new InvalidFormatException("Rar signature not found");
     }
+
+    private static async Task<byte> GetByteAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        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 Task<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)
+            {
+                // Rar old signature: 52 45 7E 5E
+                // Rar4 signature:    52 61 72 21 1A 07 00
+                // Rar5 signature:    52 61 72 21 1A 07 01 00
+                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/RarHeader.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 
 namespace SharpCompress.Common.Rar.Headers;
@@ -8,7 +10,7 @@ namespace SharpCompress.Common.Rar.Headers;
 internal class RarHeader : IRarHeader
 {
     private readonly HeaderType _headerType;
-    private readonly bool _isRar5;
+    private bool _isRar5;
 
     internal static RarHeader? TryReadBase(
         RarCrcBinaryReader reader,
@@ -26,6 +28,97 @@ internal class RarHeader : IRarHeader
         }
     }
 
+    internal static async Task<RarHeader?> TryReadBaseAsync(
+        RarCrcBinaryReader reader,
+        bool isRar5,
+        ArchiveEncoding archiveEncoding,
+        CancellationToken cancellationToken = default
+    )
+    {
+        try
+        {
+            return await CreateAsync(reader, isRar5, archiveEncoding, cancellationToken)
+                .ConfigureAwait(false);
+        }
+        catch (InvalidFormatException)
+        {
+            return null;
+        }
+    }
+
+    private static async Task<RarHeader> CreateAsync(
+        RarCrcBinaryReader reader,
+        bool isRar5,
+        ArchiveEncoding archiveEncoding,
+        CancellationToken cancellationToken
+    )
+    {
+        var header = new RarHeader();
+        await header
+            .InitializeAsync(reader, isRar5, archiveEncoding, cancellationToken)
+            .ConfigureAwait(false);
+        return header;
+    }
+
+    private RarHeader()
+    {
+        _headerType = HeaderType.Null;
+        ArchiveEncoding = new ArchiveEncoding();
+    }
+
+    private async Task InitializeAsync(
+        RarCrcBinaryReader reader,
+        bool isRar5,
+        ArchiveEncoding archiveEncoding,
+        CancellationToken cancellationToken
+    )
+    {
+        _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(2, cancellationToken)
+                .ConfigureAwait(false);
+            HeaderFlags = await reader
+                .ReadRarVIntUInt16Async(2, cancellationToken)
+                .ConfigureAwait(false);
+
+            if (HasHeaderFlag(HeaderFlagsV5.HAS_EXTRA))
+            {
+                ExtraSize = await reader
+                    .ReadRarVIntUInt32Async(5, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+            if (HasHeaderFlag(HeaderFlagsV5.HAS_DATA))
+            {
+                AdditionalDataSize = (long)
+                    await reader.ReadRarVIntAsync(10, 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);
+            }
+        }
+    }
+
     private RarHeader(RarCrcBinaryReader reader, bool isRar5, ArchiveEncoding archiveEncoding)
     {
         _headerType = HeaderType.Null;
@@ -105,25 +198,25 @@ internal class RarHeader : IRarHeader
 
     protected bool IsRar5 => _isRar5;
 
-    protected uint HeaderCrc { get; }
+    protected uint HeaderCrc { get; private set; }
 
-    internal byte HeaderCode { get; }
+    internal byte HeaderCode { get; private set; }
 
-    protected ushort HeaderFlags { get; }
+    protected ushort HeaderFlags { get; private set; }
 
     protected bool HasHeaderFlag(ushort flag) => (HeaderFlags & flag) == flag;
 
-    protected int HeaderSize { get; }
+    protected int HeaderSize { get; private set; }
 
-    internal ArchiveEncoding ArchiveEncoding { get; }
+    internal ArchiveEncoding ArchiveEncoding { get; private set; }
 
     /// <summary>
     /// Extra header size.
     /// </summary>
-    protected uint ExtraSize { get; }
+    protected uint ExtraSize { get; private set; }
 
     /// <summary>
     /// Size of additional data (eg file contents)
     /// </summary>
-    protected long AdditionalDataSize { get; }
+    protected long AdditionalDataSize { get; private set; }
 }

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

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.IO;
 using SharpCompress.Readers;
 
@@ -40,6 +42,34 @@ public class RarHeaderFactory
         }
     }
 
+    public async IAsyncEnumerable<IRarHeader> ReadHeadersAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        var markHeader = await MarkHeader
+            .ReadAsync(stream, Options.LeaveStreamOpen, Options.LookForHeader, cancellationToken)
+            .ConfigureAwait(false);
+        _isRar5 = markHeader.IsRar5;
+        yield return markHeader;
+
+        RarHeader? header;
+        while (
+            (header = await TryReadNextHeaderAsync(stream, cancellationToken).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;
@@ -198,6 +228,169 @@ public class RarHeaderFactory
         }
     }
 
+    private async Task<RarHeader?> TryReadNextHeaderAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        RarCrcBinaryReader reader;
+        if (!IsEncrypted)
+        {
+            reader = new RarCrcBinaryReader(stream);
+        }
+        else
+        {
+            if (Options.Password is null)
+            {
+                throw new CryptographicException(
+                    "Encrypted Rar archive has no password specified."
+                );
+            }
+
+            if (_isRar5 && _cryptInfo != null)
+            {
+                _cryptInfo.ReadInitV(new MarkingBinaryReader(stream));
+                var _headerKey = new CryptKey5(Options.Password!, _cryptInfo);
+
+                reader = new RarCryptoBinaryReader(stream, _headerKey, _cryptInfo.Salt);
+            }
+            else
+            {
+                var key = new CryptKey3(Options.Password);
+                reader = new RarCryptoBinaryReader(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 = new ArchiveHeader(header, reader);
+                if (ah.IsEncrypted == true)
+                {
+                    //!!! rar5 we don't know yet
+                    IsEncrypted = true;
+                }
+                return ah;
+            }
+
+            case HeaderCodeV.RAR4_PROTECT_HEADER:
+            {
+                var ph = new ProtectHeader(header, reader);
+                // skip the recovery record data, we do not use it.
+                switch (StreamingMode)
+                {
+                    case StreamingMode.Seekable:
+                        {
+                            reader.BaseStream.Position += ph.DataSize;
+                        }
+                        break;
+                    case StreamingMode.Streaming:
+                        {
+                            reader.BaseStream.Skip(ph.DataSize);
+                        }
+                        break;
+                    default:
+                    {
+                        throw new InvalidFormatException("Invalid StreamingMode");
+                    }
+                }
+
+                return ph;
+            }
+
+            case HeaderCodeV.RAR5_SERVICE_HEADER:
+            {
+                var fh = new FileHeader(header, reader, HeaderType.Service);
+                if (fh.FileName == "CMT")
+                {
+                    fh.PackedStream = new ReadOnlySubStream(reader.BaseStream, fh.CompressedSize);
+                }
+                else
+                {
+                    SkipData(fh, reader);
+                }
+                return fh;
+            }
+
+            case HeaderCodeV.RAR4_NEW_SUB_HEADER:
+            {
+                var fh = new FileHeader(header, reader, HeaderType.NewSub);
+                SkipData(fh, reader);
+                return fh;
+            }
+
+            case HeaderCodeV.RAR5_FILE_HEADER:
+            case HeaderCodeV.RAR4_FILE_HEADER:
+            {
+                var fh = new FileHeader(header, reader, HeaderType.File);
+                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 new EndArchiveHeader(header, reader);
+            }
+            case HeaderCodeV.RAR5_ARCHIVE_ENCRYPTION_HEADER:
+            {
+                var cryptoHeader = new ArchiveCryptHeader(header, reader);
+                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)

src/SharpCompress/Common/Rar/RarCrcBinaryReader.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Compressors.Rar;
 using SharpCompress.IO;
 
@@ -32,4 +34,27 @@ internal class RarCrcBinaryReader : MarkingBinaryReader
         _currentCrc = RarCRC.CheckCrc(_currentCrc, result, 0, result.Length);
         return result;
     }
+
+    // Async versions
+    public override async Task<byte> ReadByteAsync(CancellationToken cancellationToken = default)
+    {
+        var b = await base.ReadByteAsync(cancellationToken).ConfigureAwait(false);
+        _currentCrc = RarCRC.CheckCrc(_currentCrc, b);
+        return b;
+    }
+
+    public override async Task<byte[]> ReadBytesAsync(
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var result = await base.ReadBytesAsync(count, cancellationToken).ConfigureAwait(false);
+        _currentCrc = RarCRC.CheckCrc(_currentCrc, result, 0, result.Length);
+        return result;
+    }
+
+    public async Task<byte[]> ReadBytesNoCrcAsync(
+        int count,
+        CancellationToken cancellationToken = default
+    ) => await base.ReadBytesAsync(count, cancellationToken).ConfigureAwait(false);
 }

src/SharpCompress/Common/Rar/RarCryptoBinaryReader.cs

@@ -2,6 +2,8 @@
 
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.Crypto;
 
@@ -81,4 +83,49 @@ internal sealed class RarCryptoBinaryReader : RarCrcBinaryReader
         BaseStream.Position = position + _data.Count;
         ClearQueue();
     }
+
+    // Async versions
+    public override async Task<byte> ReadByteAsync(CancellationToken cancellationToken = default) =>
+        (await ReadAndDecryptBytesAsync(1, cancellationToken).ConfigureAwait(false))[0];
+
+    public override async Task<byte[]> ReadBytesAsync(
+        int count,
+        CancellationToken cancellationToken = default
+    ) => await ReadAndDecryptBytesAsync(count, cancellationToken).ConfigureAwait(false);
+
+    private async Task<byte[]> ReadAndDecryptBytesAsync(
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        var queueSize = _data.Count;
+        var sizeToRead = count - queueSize;
+
+        if (sizeToRead > 0)
+        {
+            var alignedSize = sizeToRead + ((~sizeToRead + 1) & 0xf);
+            for (var i = 0; i < alignedSize / 16; i++)
+            {
+                var cipherText = await ReadBytesNoCrcAsync(16, cancellationToken)
+                    .ConfigureAwait(false);
+                var readBytes = _rijndael.ProcessBlock(cipherText);
+                foreach (var readByte in readBytes)
+                {
+                    _data.Enqueue(readByte);
+                }
+            }
+        }
+
+        var decryptedBytes = new byte[count];
+
+        for (var i = 0; i < count; i++)
+        {
+            var b = _data.Dequeue();
+            decryptedBytes[i] = b;
+            UpdateCrc(b);
+        }
+
+        _readCount += count;
+        return decryptedBytes;
+    }
 }

src/SharpCompress/Common/Rar/RarVolume.cs

@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
 using SharpCompress.Readers;
@@ -26,6 +28,14 @@ public abstract class RarVolume : Volume
 
     internal abstract IEnumerable<RarFilePart> ReadFileParts();
 
+    internal virtual IAsyncEnumerable<RarFilePart> ReadFilePartsAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        // Default implementation - derived classes can override for better async support
+        throw new NotImplementedException("Async read is not supported for this volume type");
+    }
+
     internal abstract RarFilePart CreateFilePart(MarkHeader markHeader, FileHeader fileHeader);
 
     internal IEnumerable<RarFilePart> GetVolumeFileParts()
@@ -71,6 +81,56 @@ public abstract class RarVolume : Volume
         }
     }
 
+    internal async IAsyncEnumerable<RarFilePart> GetVolumeFilePartsAsync(
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        MarkHeader? lastMarkHeader = null;
+        await foreach (
+            var header in _headerFactory
+                .ReadHeadersAsync(Stream, cancellationToken)
+                .ConfigureAwait(false)
+        )
+        {
+            switch (header.HeaderType)
+            {
+                case HeaderType.Mark:
+                    {
+                        lastMarkHeader = (MarkHeader)header;
+                    }
+                    break;
+                case HeaderType.Archive:
+                    {
+                        ArchiveHeader = (ArchiveHeader)header;
+                    }
+                    break;
+                case HeaderType.File:
+                    {
+                        var fh = (FileHeader)header;
+                        if (_maxCompressionAlgorithm < fh.CompressionAlgorithm)
+                        {
+                            _maxCompressionAlgorithm = fh.CompressionAlgorithm;
+                        }
+
+                        yield return CreateFilePart(lastMarkHeader!, fh);
+                    }
+                    break;
+                case HeaderType.Service:
+                    {
+                        var fh = (FileHeader)header;
+                        if (fh.FileName == "CMT")
+                        {
+                            var buffer = new byte[fh.CompressedSize];
+                            fh.PackedStream.NotNull().ReadFully(buffer);
+                            Comment = Encoding.UTF8.GetString(buffer, 0, buffer.Length - 1);
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+
     private void EnsureArchiveHeaderLoaded()
     {
         if (ArchiveHeader is null)

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

@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -19,6 +20,18 @@ 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 = await reader.ReadBytesAsync(CommentLength);
+    }
+
     public ushort VolumeNumber { get; private set; }
 
     public ushort FirstVolumeWithDirectory { get; private set; }

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

@@ -1,5 +1,6 @@
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -31,7 +32,37 @@ internal class DirectoryEntryHeader : ZipFileEntry
         var extra = reader.ReadBytes(extraLength);
         var comment = reader.ReadBytes(commentLength);
 
-        // According to .ZIP File Format Specification
+        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 = await reader.ReadBytesAsync(nameLength);
+        var extra = await reader.ReadBytesAsync(extraLength);
+        var comment = await reader.ReadBytesAsync(commentLength);
+
+        ProcessReadData(name, extra, comment);
+    }
+
+    private void ProcessReadData(byte[] name, byte[] extra, byte[] comment)
+    {
         //
         // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         //

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

@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -8,4 +9,6 @@ internal class IgnoreHeader : ZipHeader
         : base(type) { }
 
     internal override void Read(BinaryReader reader) { }
+
+    internal override ValueTask Read(AsyncBinaryReader reader) => default;
 }

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

@@ -1,13 +1,12 @@
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class LocalEntryHeader : ZipFileEntry
+internal class LocalEntryHeader(ArchiveEncoding archiveEncoding)
+    : ZipFileEntry(ZipHeaderType.LocalEntry, archiveEncoding)
 {
-    public LocalEntryHeader(ArchiveEncoding archiveEncoding)
-        : base(ZipHeaderType.LocalEntry, archiveEncoding) { }
-
     internal override void Read(BinaryReader reader)
     {
         Version = reader.ReadUInt16();
@@ -23,7 +22,29 @@ internal class LocalEntryHeader : ZipFileEntry
         var name = reader.ReadBytes(nameLength);
         var extra = reader.ReadBytes(extraLength);
 
-        // According to .ZIP File Format Specification
+        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 = await reader.ReadBytesAsync(nameLength);
+        var extra = await reader.ReadBytesAsync(extraLength);
+
+        ProcessReadData(name, extra);
+    }
+
+    private void ProcessReadData(byte[] name, byte[] extra)
+    {
         //
         // For example: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
         //

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

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -9,4 +10,7 @@ internal class SplitHeader : ZipHeader
         : base(ZipHeaderType.Split) { }
 
     internal override void Read(BinaryReader reader) => throw new NotImplementedException();
+
+    internal override ValueTask Read(AsyncBinaryReader reader) =>
+        throw new NotImplementedException();
 }

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

@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
@@ -26,6 +27,25 @@ 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();
+        DataSector = await reader.ReadBytesAsync(
+            (int)(
+                SizeOfDirectoryEndRecord
+                - SIZE_OF_FIXED_HEADER_DATA_EXCEPT_SIGNATURE_AND_SIZE_FIELDS
+            )
+        );
+    }
+
     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.cs

@@ -1,12 +1,10 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal class Zip64DirectoryEndLocatorHeader : ZipHeader
+internal class Zip64DirectoryEndLocatorHeader() : ZipHeader(ZipHeaderType.Zip64DirectoryEndLocator)
 {
-    public Zip64DirectoryEndLocatorHeader()
-        : base(ZipHeaderType.Zip64DirectoryEndLocator) { }
-
     internal override void Read(BinaryReader reader)
     {
         FirstVolumeWithDirectory = reader.ReadUInt32();
@@ -14,6 +12,13 @@ internal class Zip64DirectoryEndLocatorHeader : ZipHeader
         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.cs

@@ -2,18 +2,14 @@ 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 : ZipHeader
+internal abstract class ZipFileEntry(ZipHeaderType type, ArchiveEncoding archiveEncoding)
+    : ZipHeader(type)
 {
-    protected ZipFileEntry(ZipHeaderType type, ArchiveEncoding archiveEncoding)
-        : base(type)
-    {
-        Extra = new List<ExtraData>();
-        ArchiveEncoding = archiveEncoding;
-    }
-
     internal bool IsDirectory
     {
         get
@@ -30,7 +26,7 @@ internal abstract class ZipFileEntry : ZipHeader
 
     internal Stream? PackedStream { get; set; }
 
-    internal ArchiveEncoding ArchiveEncoding { get; }
+    internal ArchiveEncoding ArchiveEncoding { get; } = archiveEncoding;
 
     internal string? Name { get; set; }
 
@@ -44,7 +40,7 @@ internal abstract class ZipFileEntry : ZipHeader
 
     internal long UncompressedSize { get; set; }
 
-    internal List<ExtraData> Extra { get; set; }
+    internal List<ExtraData> Extra { get; set; } = new();
 
     public string? Password { get; set; }
 
@@ -63,6 +59,24 @@ internal abstract class ZipFileEntry : ZipHeader
         return encryptionData;
     }
 
+    internal async Task<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>

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

@@ -1,18 +1,14 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.Zip.Headers;
 
-internal abstract class ZipHeader
+internal abstract class ZipHeader(ZipHeaderType type)
 {
-    protected ZipHeader(ZipHeaderType type)
-    {
-        ZipHeaderType = type;
-        HasData = true;
-    }
-
-    internal ZipHeaderType ZipHeaderType { get; }
+    internal ZipHeaderType ZipHeaderType { get; } = type;
 
     internal abstract void Read(BinaryReader reader);
+    internal abstract ValueTask Read(AsyncBinaryReader reader);
 
-    internal bool HasData { get; set; }
+    internal bool HasData { get; set; } = true;
 }

src/SharpCompress/Common/Zip/SeekableZipHeaderFactory.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -18,7 +19,74 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
     internal SeekableZipHeaderFactory(string? password, ArchiveEncoding archiveEncoding)
         : base(StreamingMode.Seekable, password, archiveEncoding) { }
 
-    internal IEnumerable<ZipHeader> ReadSeekableHeader(Stream stream)
+    internal async IAsyncEnumerable<ZipHeader> ReadSeekableHeader(Stream stream)
+    {
+        var reader = new AsyncBinaryReader(stream);
+
+        await SeekBackToHeader(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;
+            }
+        }
+    }
+
+    internal IEnumerable<ZipHeader> ReadSeekableHeader(Stream stream, bool useSync)
     {
         var reader = new BinaryReader(stream);
 
@@ -98,6 +166,45 @@ internal sealed class SeekableZipHeaderFactory : ZipHeaderFactory
         return true;
     }
 
+    private static async ValueTask SeekBackToHeader(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;
+        // We search for marker in reverse to find the first occurance
+        byte[] needle = { 0x06, 0x05, 0x4b, 0x50 };
+
+        stream.Seek(-len, SeekOrigin.End);
+
+        var seek = await reader.ReadBytesAsync(len);
+
+        // Search in reverse
+        Array.Reverse(seek);
+
+        // 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(seek, pos_from_end, needle))
+            {
+                stream.Seek(-pos_from_end, SeekOrigin.End);
+                return;
+            }
+        }
+
+        throw new ArchiveException("Failed to locate the Zip Header");
+    }
+
     private static void SeekBackToHeader(Stream stream, BinaryReader reader)
     {
         // Minimum EOCD length

src/SharpCompress/Common/Zip/StreamingZipFilePart.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
@@ -31,6 +33,28 @@ internal sealed class StreamingZipFilePart : ZipFilePart
         return _decompressionStream;
     }
 
+    internal override async Task<Stream?> GetCompressedStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!Header.HasData)
+        {
+            return Stream.Null;
+        }
+        _decompressionStream = await CreateDecompressionStreamAsync(
+                await GetCryptoStreamAsync(CreateBaseStream(), cancellationToken)
+                    .ConfigureAwait(false),
+                Header.CompressionMethod,
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+        if (LeaveStreamOpen)
+        {
+            return SharpCompressStream.Create(_decompressionStream, leaveOpen: true);
+        }
+        return _decompressionStream;
+    }
+
     internal BinaryReader FixStreamedFileLocation(ref SharpCompressStream rewindableStream)
     {
         if (Header.IsDirectory)

src/SharpCompress/Common/Zip/StreamingZipHeaderFactory.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -200,4 +201,196 @@ internal class StreamingZipHeaderFactory : ZipHeaderFactory
             yield return header;
         }
     }
+
+    internal async IAsyncEnumerable<ZipHeader> ReadStreamHeaderAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        if (stream is not SharpCompressStream) //ensure the stream is already a SharpCompressStream. So the buffer/size will already be set
+        {
+            //the original code wrapped this with RewindableStream. Wrap with SharpCompressStream as we can get the buffer size
+            if (stream is SourceStream src)
+            {
+                stream = new SharpCompressStream(
+                    stream,
+                    src.ReaderOptions.LeaveStreamOpen,
+                    bufferSize: src.ReaderOptions.BufferSize
+                );
+            }
+            else
+            {
+                throw new ArgumentException("Stream must be a SharpCompressStream", nameof(stream));
+            }
+        }
+        var rewindableStream = (SharpCompressStream)stream;
+
+        while (true)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            var reader = new AsyncBinaryReader(rewindableStream, leaveOpen: true);
+            uint headerBytes = 0;
+            if (
+                _lastEntryHeader != null
+                && FlagUtility.HasFlag(_lastEntryHeader.Flags, HeaderFlags.UsePostDataDescriptor)
+            )
+            {
+                if (_lastEntryHeader.Part is null)
+                {
+                    continue;
+                }
+
+                // removed requirement for FixStreamedFileLocation()
+
+                var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
+
+                var crc = await reader.ReadUInt32Async().ConfigureAwait(false);
+                if (crc == POST_DATA_DESCRIPTOR)
+                {
+                    crc = await reader.ReadUInt32Async().ConfigureAwait(false);
+                }
+                _lastEntryHeader.Crc = crc;
+
+                //attempt 32bit read
+                ulong compSize = await reader.ReadUInt32Async().ConfigureAwait(false);
+                ulong uncompSize = await reader.ReadUInt32Async().ConfigureAwait(false);
+                headerBytes = await reader.ReadUInt32Async().ConfigureAwait(false);
+
+                //check for zip64 sentinel or unexpected header
+                bool isSentinel = compSize == 0xFFFFFFFF || uncompSize == 0xFFFFFFFF;
+                bool isHeader = headerBytes == 0x04034b50 || headerBytes == 0x02014b50;
+
+                if (!isHeader && !isSentinel)
+                {
+                    //reshuffle into 64-bit values
+                    compSize = (uncompSize << 32) | compSize;
+                    uncompSize =
+                        ((ulong)headerBytes << 32)
+                        | await reader.ReadUInt32Async().ConfigureAwait(false);
+                    headerBytes = await reader.ReadUInt32Async().ConfigureAwait(false);
+                }
+                else if (isSentinel)
+                {
+                    //standards-compliant zip64 descriptor
+                    compSize = await reader.ReadUInt64Async().ConfigureAwait(false);
+                    uncompSize = await reader.ReadUInt64Async().ConfigureAwait(false);
+                }
+
+                _lastEntryHeader.CompressedSize = (long)compSize;
+                _lastEntryHeader.UncompressedSize = (long)uncompSize;
+
+                if (pos.HasValue)
+                {
+                    _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
+                }
+            }
+            else if (_lastEntryHeader != null && _lastEntryHeader.IsZip64)
+            {
+                if (_lastEntryHeader.Part is null)
+                    continue;
+
+                //reader = ((StreamingZipFilePart)_lastEntryHeader.Part).FixStreamedFileLocation(
+                //    ref rewindableStream
+                //);
+
+                var pos = rewindableStream.CanSeek ? (long?)rewindableStream.Position : null;
+
+                headerBytes = await reader.ReadUInt32Async().ConfigureAwait(false);
+
+                var version = await reader.ReadUInt16Async().ConfigureAwait(false);
+                var flags = (HeaderFlags)await reader.ReadUInt16Async().ConfigureAwait(false);
+                var compressionMethod = (ZipCompressionMethod)
+                    await reader.ReadUInt16Async().ConfigureAwait(false);
+                var lastModifiedDate = await reader.ReadUInt16Async().ConfigureAwait(false);
+                var lastModifiedTime = await reader.ReadUInt16Async().ConfigureAwait(false);
+
+                var crc = await reader.ReadUInt32Async().ConfigureAwait(false);
+
+                if (crc == POST_DATA_DESCRIPTOR)
+                {
+                    crc = await reader.ReadUInt32Async().ConfigureAwait(false);
+                }
+                _lastEntryHeader.Crc = crc;
+
+                // The DataDescriptor can be either 64bit or 32bit
+                var compressed_size = await reader.ReadUInt32Async().ConfigureAwait(false);
+                var uncompressed_size = await reader.ReadUInt32Async().ConfigureAwait(false);
+
+                // Check if we have header or 64bit DataDescriptor
+                var test_header = !(headerBytes == 0x04034b50 || headerBytes == 0x02014b50);
+
+                var test_64bit = ((long)uncompressed_size << 32) | compressed_size;
+                if (test_64bit == _lastEntryHeader.CompressedSize && test_header)
+                {
+                    _lastEntryHeader.UncompressedSize =
+                        ((long)await reader.ReadUInt32Async().ConfigureAwait(false) << 32)
+                        | headerBytes;
+                    headerBytes = await reader.ReadUInt32Async().ConfigureAwait(false);
+                }
+                else
+                {
+                    _lastEntryHeader.UncompressedSize = uncompressed_size;
+                }
+
+                if (pos.HasValue)
+                {
+                    _lastEntryHeader.DataStartPosition = pos - _lastEntryHeader.CompressedSize;
+
+                    // 4 = First 4 bytes of the entry header (i.e. 50 4B 03 04)
+                    rewindableStream.Position = pos.Value + 4;
+                }
+            }
+            else
+            {
+                headerBytes = await reader.ReadUInt32Async().ConfigureAwait(false);
+            }
+
+            _lastEntryHeader = null;
+            var header = await ReadHeader(headerBytes, reader).ConfigureAwait(false);
+            if (header is null)
+            {
+                yield break;
+            }
+
+            //entry could be zero bytes so we need to know that.
+            if (header.ZipHeaderType == ZipHeaderType.LocalEntry)
+            {
+                var local_header = ((LocalEntryHeader)header);
+                var dir_header = _entries?.FirstOrDefault(entry =>
+                    entry.Key == local_header.Name
+                    && local_header.CompressedSize == 0
+                    && local_header.UncompressedSize == 0
+                    && local_header.Crc == 0
+                    && local_header.IsDirectory == false
+                );
+
+                if (dir_header != null)
+                {
+                    local_header.UncompressedSize = dir_header.Size;
+                    local_header.CompressedSize = dir_header.CompressedSize;
+                    local_header.Crc = (uint)dir_header.Crc;
+                }
+
+                // If we have CompressedSize, there is data to be read
+                if (local_header.CompressedSize > 0)
+                {
+                    header.HasData = true;
+                } // Check if zip is streaming ( Length is 0 and is declared in PostDataDescriptor )
+                else if (local_header.Flags.HasFlag(HeaderFlags.UsePostDataDescriptor))
+                {
+                    var nextHeaderBytes = await reader.ReadUInt32Async().ConfigureAwait(false);
+                    ((IStreamStack)rewindableStream).Rewind(sizeof(uint));
+
+                    // Check if next data is PostDataDescriptor, streamed file with 0 length
+                    header.HasData = !IsHeader(nextHeaderBytes);
+                }
+                else // We are not streaming and compressed size is 0, we have no data
+                {
+                    header.HasData = false;
+                }
+            }
+            yield return header;
+        }
+    }
 }

src/SharpCompress/Common/Zip/ZipFilePart.cs

@@ -2,6 +2,8 @@ using System;
 using System.Buffers.Binary;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.BZip2;
@@ -264,4 +266,220 @@ internal abstract class ZipFilePart : FilePart
         }
         return plainStream;
     }
+
+    internal override async Task<Stream?> GetCompressedStreamAsync(
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (!Header.HasData)
+        {
+            return Stream.Null;
+        }
+        var decompressionStream = await CreateDecompressionStreamAsync(
+                await GetCryptoStreamAsync(CreateBaseStream(), cancellationToken)
+                    .ConfigureAwait(false),
+                Header.CompressionMethod,
+                cancellationToken
+            )
+            .ConfigureAwait(false);
+        if (LeaveStreamOpen)
+        {
+            return SharpCompressStream.Create(decompressionStream, leaveOpen: true);
+        }
+        return decompressionStream;
+    }
+
+    protected async Task<Stream> GetCryptoStreamAsync(
+        Stream plainStream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var isFileEncrypted = FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted);
+
+        if (Header.CompressedSize == 0 && isFileEncrypted)
+        {
+            throw new NotSupportedException("Cannot encrypt file with unknown size at start.");
+        }
+
+        if (
+            (
+                Header.CompressedSize == 0
+                && FlagUtility.HasFlag(Header.Flags, HeaderFlags.UsePostDataDescriptor)
+            ) || Header.IsZip64
+        )
+        {
+            plainStream = SharpCompressStream.Create(plainStream, leaveOpen: true); //make sure AES doesn't close
+        }
+        else
+        {
+            plainStream = new ReadOnlySubStream(plainStream, Header.CompressedSize); //make sure AES doesn't close
+        }
+
+        if (isFileEncrypted)
+        {
+            switch (Header.CompressionMethod)
+            {
+                case ZipCompressionMethod.None:
+                case ZipCompressionMethod.Shrink:
+                case ZipCompressionMethod.Reduce1:
+                case ZipCompressionMethod.Reduce2:
+                case ZipCompressionMethod.Reduce3:
+                case ZipCompressionMethod.Reduce4:
+                case ZipCompressionMethod.Deflate:
+                case ZipCompressionMethod.Deflate64:
+                case ZipCompressionMethod.BZip2:
+                case ZipCompressionMethod.LZMA:
+                case ZipCompressionMethod.PPMd:
+                {
+                    return new PkwareTraditionalCryptoStream(
+                        plainStream,
+                        await Header
+                            .ComposeEncryptionDataAsync(plainStream, cancellationToken)
+                            .ConfigureAwait(false),
+                        CryptoMode.Decrypt
+                    );
+                }
+
+                case ZipCompressionMethod.WinzipAes:
+                {
+                    if (Header.WinzipAesEncryptionData != null)
+                    {
+                        return new WinzipAesCryptoStream(
+                            plainStream,
+                            Header.WinzipAesEncryptionData,
+                            Header.CompressedSize - 10
+                        );
+                    }
+                    return plainStream;
+                }
+
+                default:
+                {
+                    throw new InvalidOperationException("Header.CompressionMethod is invalid");
+                }
+            }
+        }
+        return plainStream;
+    }
+
+    protected async Task<Stream> CreateDecompressionStreamAsync(
+        Stream stream,
+        ZipCompressionMethod method,
+        CancellationToken cancellationToken = default
+    )
+    {
+        switch (method)
+        {
+            case ZipCompressionMethod.None:
+            {
+                if (Header.CompressedSize is 0)
+                {
+                    return new DataDescriptorStream(stream);
+                }
+
+                return stream;
+            }
+            case ZipCompressionMethod.Shrink:
+            {
+                return new ShrinkStream(
+                    stream,
+                    CompressionMode.Decompress,
+                    Header.CompressedSize,
+                    Header.UncompressedSize
+                );
+            }
+            case ZipCompressionMethod.Reduce1:
+            {
+                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 1);
+            }
+            case ZipCompressionMethod.Reduce2:
+            {
+                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 2);
+            }
+            case ZipCompressionMethod.Reduce3:
+            {
+                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 3);
+            }
+            case ZipCompressionMethod.Reduce4:
+            {
+                return new ReduceStream(stream, Header.CompressedSize, Header.UncompressedSize, 4);
+            }
+            case ZipCompressionMethod.Explode:
+            {
+                return new ExplodeStream(
+                    stream,
+                    Header.CompressedSize,
+                    Header.UncompressedSize,
+                    Header.Flags
+                );
+            }
+
+            case ZipCompressionMethod.Deflate:
+            {
+                return new DeflateStream(stream, CompressionMode.Decompress);
+            }
+            case ZipCompressionMethod.Deflate64:
+            {
+                return new Deflate64Stream(stream, CompressionMode.Decompress);
+            }
+            case ZipCompressionMethod.BZip2:
+            {
+                return new BZip2Stream(stream, CompressionMode.Decompress, false);
+            }
+            case ZipCompressionMethod.LZMA:
+            {
+                if (FlagUtility.HasFlag(Header.Flags, HeaderFlags.Encrypted))
+                {
+                    throw new NotSupportedException("LZMA with pkware encryption.");
+                }
+                var buffer = new byte[4];
+                await stream.ReadFullyAsync(buffer, 0, 4, cancellationToken).ConfigureAwait(false);
+                var version = BinaryPrimitives.ReadUInt16LittleEndian(buffer.AsSpan(0, 2));
+                var propsSize = BinaryPrimitives.ReadUInt16LittleEndian(buffer.AsSpan(2, 2));
+                var props = new byte[propsSize];
+                await stream
+                    .ReadFullyAsync(props, 0, propsSize, cancellationToken)
+                    .ConfigureAwait(false);
+                return new LzmaStream(
+                    props,
+                    stream,
+                    Header.CompressedSize > 0 ? Header.CompressedSize - 4 - props.Length : -1,
+                    FlagUtility.HasFlag(Header.Flags, HeaderFlags.Bit1)
+                        ? -1
+                        : Header.UncompressedSize
+                );
+            }
+            case ZipCompressionMethod.Xz:
+            {
+                return new XZStream(stream);
+            }
+            case ZipCompressionMethod.ZStandard:
+            {
+                return new DecompressionStream(stream);
+            }
+            case ZipCompressionMethod.PPMd:
+            {
+                var props = new byte[2];
+                await stream.ReadFullyAsync(props, 0, 2, cancellationToken).ConfigureAwait(false);
+                return new PpmdStream(new PpmdProperties(props), stream, false);
+            }
+            case ZipCompressionMethod.WinzipAes:
+            {
+                var data = Header.Extra.SingleOrDefault(x => x.Type == ExtraDataType.WinZipAes);
+                if (data is null)
+                {
+                    throw new InvalidFormatException("No Winzip AES extra data found.");
+                }
+                if (data.Length != 7)
+                {
+                    throw new InvalidFormatException("Winzip data length is not 7.");
+                }
+                throw new NotSupportedException("WinzipAes isn't supported for streaming");
+            }
+            default:
+            {
+                throw new NotSupportedException("CompressionMethod: " + Header.CompressionMethod);
+            }
+        }
+    }
 }

src/SharpCompress/Common/Zip/ZipHeaderFactory.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using SharpCompress.Common.Zip.Headers;
 using SharpCompress.IO;
 
@@ -34,6 +35,82 @@ internal class ZipHeaderFactory
         _archiveEncoding = archiveEncoding;
     }
 
+    protected async ValueTask<ZipHeader?> ReadHeader(
+        uint headerBytes,
+        AsyncBinaryReader reader,
+        bool zip64 = false
+    )
+    {
+        switch (headerBytes)
+        {
+            case ENTRY_HEADER_BYTES:
+            {
+                var entryHeader = new LocalEntryHeader(_archiveEncoding);
+                await entryHeader.Read(reader);
+                LoadHeader(entryHeader, reader.BaseStream);
+
+                _lastEntryHeader = entryHeader;
+                return entryHeader;
+            }
+            case DIRECTORY_START_HEADER_BYTES:
+            {
+                var entry = new DirectoryEntryHeader(_archiveEncoding);
+                await entry.Read(reader);
+                return entry;
+            }
+            case POST_DATA_DESCRIPTOR:
+            {
+                if (
+                    _lastEntryHeader != null
+                    && FlagUtility.HasFlag(
+                        _lastEntryHeader.NotNull().Flags,
+                        HeaderFlags.UsePostDataDescriptor
+                    )
+                )
+                {
+                    _lastEntryHeader.Crc = await reader.ReadUInt32Async();
+                    _lastEntryHeader.CompressedSize = zip64
+                        ? (long)await reader.ReadUInt64Async()
+                        : await reader.ReadUInt32Async();
+                    _lastEntryHeader.UncompressedSize = zip64
+                        ? (long)await reader.ReadUInt64Async()
+                        : await reader.ReadUInt32Async();
+                }
+                else
+                {
+                    await reader.ReadBytesAsync(zip64 ? 20 : 12);
+                }
+                return null;
+            }
+            case DIGITAL_SIGNATURE:
+                return null;
+            case DIRECTORY_END_HEADER_BYTES:
+            {
+                var entry = new DirectoryEndHeader();
+                await entry.Read(reader);
+                return entry;
+            }
+            case SPLIT_ARCHIVE_HEADER_BYTES:
+            {
+                return new SplitHeader();
+            }
+            case ZIP64_END_OF_CENTRAL_DIRECTORY:
+            {
+                var entry = new Zip64DirectoryEndHeader();
+                await entry.Read(reader);
+                return entry;
+            }
+            case ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR:
+            {
+                var entry = new Zip64DirectoryEndLocatorHeader();
+                await entry.Read(reader);
+                return entry;
+            }
+            default:
+                return null;
+        }
+    }
+
     protected ZipHeader? ReadHeader(uint headerBytes, BinaryReader reader, bool zip64 = false)
     {
         switch (headerBytes)

src/SharpCompress/Factories/ArcFactory.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;
@@ -42,5 +43,15 @@ namespace SharpCompress.Factories
 
         public IReader OpenReader(Stream stream, ReaderOptions? options) =>
             ArcReader.Open(stream, options);
+
+        public async Task<IReader> OpenReaderAsync(
+            Stream stream,
+            ReaderOptions? options,
+            CancellationToken cancellationToken = default
+        )
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return await Task.FromResult(OpenReader(stream, options)).ConfigureAwait(false);
+        }
     }
 }

src/SharpCompress/Factories/ArjFactory.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Arj.Headers;
@@ -38,5 +39,15 @@ namespace SharpCompress.Factories
 
         public IReader OpenReader(Stream stream, ReaderOptions? options) =>
             ArjReader.Open(stream, options);
+
+        public async Task<IReader> OpenReaderAsync(
+            Stream stream,
+            ReaderOptions? options,
+            CancellationToken cancellationToken = default
+        )
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            return await Task.FromResult(OpenReader(stream, options)).ConfigureAwait(false);
+        }
     }
 }

src/SharpCompress/Factories/Factory.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.IO;
 using SharpCompress.Readers;
@@ -56,6 +58,18 @@ public abstract class Factory : IFactory
         int bufferSize = ReaderOptions.DefaultBufferSize
     );
 
+    /// <inheritdoc/>
+    public virtual Task<bool> IsArchiveAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return Task.FromResult(IsArchive(stream, password, bufferSize));
+    }
+
     /// <inheritdoc/>
     public virtual FileInfo? GetFilePart(int index, FileInfo part1) => null;
 

src/SharpCompress/Factories/GZipFactory.cs

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Archives;
 using SharpCompress.Archives.GZip;
 using SharpCompress.Archives.Tar;
@@ -46,6 +48,14 @@ public class GZipFactory
         int bufferSize = ReaderOptions.DefaultBufferSize
     ) => GZipArchive.IsGZipFile(stream);
 
+    /// <inheritdoc/>
+    public override Task<bool> IsArchiveAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    ) => GZipArchive.IsGZipFileAsync(stream, cancellationToken);
+
     #endregion
 
     #region IArchiveFactory
@@ -54,10 +64,24 @@ public class GZipFactory
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         GZipArchive.Open(stream, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => GZipArchive.OpenAsync(stream, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         GZipArchive.Open(fileInfo, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => GZipArchive.OpenAsync(fileInfo, readerOptions, cancellationToken);
+
     #endregion
 
     #region IMultiArchiveFactory
@@ -66,10 +90,24 @@ public class GZipFactory
     public IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null) =>
         GZipArchive.Open(streams, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => GZipArchive.OpenAsync(streams, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null) =>
         GZipArchive.Open(fileInfos, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => GZipArchive.OpenAsync(fileInfos, readerOptions, cancellationToken);
+
     #endregion
 
     #region IReaderFactory
@@ -108,6 +146,17 @@ public class GZipFactory
     public IReader OpenReader(Stream stream, ReaderOptions? options) =>
         GZipReader.Open(stream, options);
 
+    /// <inheritdoc/>
+    public async Task<IReader> OpenReaderAsync(
+        Stream stream,
+        ReaderOptions? options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(OpenReader(stream, options)).ConfigureAwait(false);
+    }
+
     #endregion
 
     #region IWriterFactory
@@ -122,6 +171,17 @@ public class GZipFactory
         return new GZipWriter(stream, new GZipWriterOptions(writerOptions));
     }
 
+    /// <inheritdoc/>
+    public async Task<IWriter> OpenAsync(
+        Stream stream,
+        WriterOptions writerOptions,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, writerOptions)).ConfigureAwait(false);
+    }
+
     #endregion
 
     #region IWriteableArchiveFactory

src/SharpCompress/Factories/IFactory.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Readers;
 
 namespace SharpCompress.Factories;
@@ -42,6 +44,20 @@ public interface IFactory
         int bufferSize = ReaderOptions.DefaultBufferSize
     );
 
+    /// <summary>
+    /// Returns true if the stream represents an archive of the format defined by this type asynchronously.
+    /// </summary>
+    /// <param name="stream">A stream, pointing to the beginning of the archive.</param>
+    /// <param name="password">optional password</param>
+    /// <param name="bufferSize">buffer size for reading</param>
+    /// <param name="cancellationToken">cancellation token</param>
+    Task<bool> IsArchiveAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    );
+
     /// <summary>
     /// From a passed in archive (zip, rar, 7z, 001), return all parts.
     /// </summary>

src/SharpCompress/Factories/RarFactory.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Rar;
 using SharpCompress.Common;
@@ -35,6 +37,14 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade
         int bufferSize = ReaderOptions.DefaultBufferSize
     ) => RarArchive.IsRarFile(stream);
 
+    /// <inheritdoc/>
+    public override async Task<bool> IsArchiveAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    ) => await RarArchive.IsRarFileAsync(stream, null, cancellationToken).ConfigureAwait(false);
+
     /// <inheritdoc/>
     public override FileInfo? GetFilePart(int index, FileInfo part1) =>
         RarArchiveVolumeFactory.GetFilePart(index, part1);
@@ -47,10 +57,24 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         RarArchive.Open(stream, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => RarArchive.OpenAsync(stream, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         RarArchive.Open(fileInfo, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => RarArchive.OpenAsync(fileInfo, readerOptions, cancellationToken);
+
     #endregion
 
     #region IMultiArchiveFactory
@@ -59,10 +83,24 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade
     public IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null) =>
         RarArchive.Open(streams, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => RarArchive.OpenAsync(streams, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null) =>
         RarArchive.Open(fileInfos, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => RarArchive.OpenAsync(fileInfos, readerOptions, cancellationToken);
+
     #endregion
 
     #region IReaderFactory
@@ -71,5 +109,16 @@ public class RarFactory : Factory, IArchiveFactory, IMultiArchiveFactory, IReade
     public IReader OpenReader(Stream stream, ReaderOptions? options) =>
         RarReader.Open(stream, options);
 
+    /// <inheritdoc/>
+    public async Task<IReader> OpenReaderAsync(
+        Stream stream,
+        ReaderOptions? options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(OpenReader(stream, options)).ConfigureAwait(false);
+    }
+
     #endregion
 }

src/SharpCompress/Factories/SevenZipFactory.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Archives;
 using SharpCompress.Archives.SevenZip;
 using SharpCompress.Common;
@@ -42,10 +44,24 @@ public class SevenZipFactory : Factory, IArchiveFactory, IMultiArchiveFactory
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         SevenZipArchive.Open(stream, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => SevenZipArchive.OpenAsync(stream, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         SevenZipArchive.Open(fileInfo, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => SevenZipArchive.OpenAsync(fileInfo, readerOptions, cancellationToken);
+
     #endregion
 
     #region IMultiArchiveFactory
@@ -54,10 +70,24 @@ public class SevenZipFactory : Factory, IArchiveFactory, IMultiArchiveFactory
     public IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null) =>
         SevenZipArchive.Open(streams, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => SevenZipArchive.OpenAsync(streams, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null) =>
         SevenZipArchive.Open(fileInfos, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => SevenZipArchive.OpenAsync(fileInfos, readerOptions, cancellationToken);
+
     #endregion
 
     #region reader

src/SharpCompress/Factories/TarFactory.cs

@@ -2,6 +2,8 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Tar;
 using SharpCompress.Common;
@@ -67,10 +69,24 @@ public class TarFactory
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         TarArchive.Open(stream, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => TarArchive.OpenAsync(stream, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         TarArchive.Open(fileInfo, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => TarArchive.OpenAsync(fileInfo, readerOptions, cancellationToken);
+
     #endregion
 
     #region IMultiArchiveFactory
@@ -79,10 +95,24 @@ public class TarFactory
     public IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null) =>
         TarArchive.Open(streams, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => TarArchive.OpenAsync(streams, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null) =>
         TarArchive.Open(fileInfos, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => TarArchive.OpenAsync(fileInfos, readerOptions, cancellationToken);
+
     #endregion
 
     #region IReaderFactory
@@ -234,6 +264,17 @@ public class TarFactory
     public IReader OpenReader(Stream stream, ReaderOptions? options) =>
         TarReader.Open(stream, options);
 
+    /// <inheritdoc/>
+    public async Task<IReader> OpenReaderAsync(
+        Stream stream,
+        ReaderOptions? options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(OpenReader(stream, options)).ConfigureAwait(false);
+    }
+
     #endregion
 
     #region IWriterFactory
@@ -242,6 +283,17 @@ public class TarFactory
     public IWriter Open(Stream stream, WriterOptions writerOptions) =>
         new TarWriter(stream, new TarWriterOptions(writerOptions));
 
+    /// <inheritdoc/>
+    public async Task<IWriter> OpenAsync(
+        Stream stream,
+        WriterOptions writerOptions,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, writerOptions)).ConfigureAwait(false);
+    }
+
     #endregion
 
     #region IWriteableArchiveFactory

src/SharpCompress/Factories/ZipFactory.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
@@ -79,6 +81,49 @@ public class ZipFactory
         return false;
     }
 
+    /// <inheritdoc/>
+    public override async Task<bool> IsArchiveAsync(
+        Stream stream,
+        string? password = null,
+        int bufferSize = ReaderOptions.DefaultBufferSize,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        var startPosition = stream.CanSeek ? stream.Position : -1;
+
+        // probe for single volume zip
+
+        if (stream is not SharpCompressStream) // wrap to provide buffer bef
+        {
+            stream = new SharpCompressStream(stream, bufferSize: bufferSize);
+        }
+
+        if (await ZipArchive.IsZipFileAsync(stream, password, bufferSize, cancellationToken))
+        {
+            return true;
+        }
+
+        // probe for a multipart zip
+
+        if (!stream.CanSeek)
+        {
+            return false;
+        }
+
+        stream.Position = startPosition;
+
+        //test the zip (last) file of a multipart zip
+        if (await ZipArchive.IsZipMultiAsync(stream, password, bufferSize, cancellationToken))
+        {
+            return true;
+        }
+
+        stream.Position = startPosition;
+
+        return false;
+    }
+
     /// <inheritdoc/>
     public override FileInfo? GetFilePart(int index, FileInfo part1) =>
         ZipArchiveVolumeFactory.GetFilePart(index, part1);
@@ -91,10 +136,24 @@ public class ZipFactory
     public IArchive Open(Stream stream, ReaderOptions? readerOptions = null) =>
         ZipArchive.Open(stream, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        Stream stream,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => ZipArchive.OpenAsync(stream, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(FileInfo fileInfo, ReaderOptions? readerOptions = null) =>
         ZipArchive.Open(fileInfo, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => ZipArchive.OpenAsync(fileInfo, readerOptions, cancellationToken);
+
     #endregion
 
     #region IMultiArchiveFactory
@@ -103,10 +162,24 @@ public class ZipFactory
     public IArchive Open(IReadOnlyList<Stream> streams, ReaderOptions? readerOptions = null) =>
         ZipArchive.Open(streams, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<Stream> streams,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => ZipArchive.OpenAsync(streams, readerOptions, cancellationToken);
+
     /// <inheritdoc/>
     public IArchive Open(IReadOnlyList<FileInfo> fileInfos, ReaderOptions? readerOptions = null) =>
         ZipArchive.Open(fileInfos, readerOptions);
 
+    /// <inheritdoc/>
+    public Task<IArchive> OpenAsync(
+        IReadOnlyList<FileInfo> fileInfos,
+        ReaderOptions? readerOptions = null,
+        CancellationToken cancellationToken = default
+    ) => ZipArchive.OpenAsync(fileInfos, readerOptions, cancellationToken);
+
     #endregion
 
     #region IReaderFactory
@@ -115,6 +188,17 @@ public class ZipFactory
     public IReader OpenReader(Stream stream, ReaderOptions? options) =>
         ZipReader.Open(stream, options);
 
+    /// <inheritdoc/>
+    public async Task<IReader> OpenReaderAsync(
+        Stream stream,
+        ReaderOptions? options,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(OpenReader(stream, options)).ConfigureAwait(false);
+    }
+
     #endregion
 
     #region IWriterFactory
@@ -123,6 +207,17 @@ public class ZipFactory
     public IWriter Open(Stream stream, WriterOptions writerOptions) =>
         new ZipWriter(stream, new ZipWriterOptions(writerOptions));
 
+    /// <inheritdoc/>
+    public async Task<IWriter> OpenAsync(
+        Stream stream,
+        WriterOptions writerOptions,
+        CancellationToken cancellationToken = default
+    )
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        return await Task.FromResult(Open(stream, writerOptions)).ConfigureAwait(false);
+    }
+
     #endregion
 
     #region IWriteableArchiveFactory

src/SharpCompress/IO/MarkingBinaryReader.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Buffers.Binary;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 
 namespace SharpCompress.IO;
@@ -155,4 +157,168 @@ internal class MarkingBinaryReader : BinaryReader
 
         throw new FormatException("malformed vint");
     }
+
+    // Async versions of read methods
+    public virtual async Task<byte> ReadByteAsync(CancellationToken cancellationToken = default)
+    {
+        CurrentReadByteCount++;
+        var buffer = new byte[1];
+        var bytesRead = await BaseStream
+            .ReadAsync(buffer, 0, 1, cancellationToken)
+            .ConfigureAwait(false);
+        if (bytesRead != 1)
+        {
+            throw new EndOfStreamException();
+        }
+        return buffer[0];
+    }
+
+    public virtual async Task<byte[]> ReadBytesAsync(
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        CurrentReadByteCount += count;
+        var bytes = new byte[count];
+        var totalRead = 0;
+        while (totalRead < count)
+        {
+            var bytesRead = await BaseStream
+                .ReadAsync(bytes, totalRead, count - totalRead, cancellationToken)
+                .ConfigureAwait(false);
+            if (bytesRead == 0)
+            {
+                throw new InvalidFormatException(
+                    string.Format(
+                        "Could not read the requested amount of bytes.  End of stream reached. Requested: {0} Read: {1}",
+                        count,
+                        totalRead
+                    )
+                );
+            }
+            totalRead += bytesRead;
+        }
+        return bytes;
+    }
+
+    public async Task<bool> ReadBooleanAsync(CancellationToken cancellationToken = default) =>
+        await ReadByteAsync(cancellationToken).ConfigureAwait(false) != 0;
+
+    public async Task<short> ReadInt16Async(CancellationToken cancellationToken = default) =>
+        BinaryPrimitives.ReadInt16LittleEndian(
+            await ReadBytesAsync(2, cancellationToken).ConfigureAwait(false)
+        );
+
+    public async Task<int> ReadInt32Async(CancellationToken cancellationToken = default) =>
+        BinaryPrimitives.ReadInt32LittleEndian(
+            await ReadBytesAsync(4, cancellationToken).ConfigureAwait(false)
+        );
+
+    public async Task<long> ReadInt64Async(CancellationToken cancellationToken = default) =>
+        BinaryPrimitives.ReadInt64LittleEndian(
+            await ReadBytesAsync(8, cancellationToken).ConfigureAwait(false)
+        );
+
+    public async Task<sbyte> ReadSByteAsync(CancellationToken cancellationToken = default) =>
+        (sbyte)await ReadByteAsync(cancellationToken).ConfigureAwait(false);
+
+    public async Task<ushort> ReadUInt16Async(CancellationToken cancellationToken = default) =>
+        BinaryPrimitives.ReadUInt16LittleEndian(
+            await ReadBytesAsync(2, cancellationToken).ConfigureAwait(false)
+        );
+
+    public async Task<uint> ReadUInt32Async(CancellationToken cancellationToken = default) =>
+        BinaryPrimitives.ReadUInt32LittleEndian(
+            await ReadBytesAsync(4, cancellationToken).ConfigureAwait(false)
+        );
+
+    public async Task<ulong> ReadUInt64Async(CancellationToken cancellationToken = default) =>
+        BinaryPrimitives.ReadUInt64LittleEndian(
+            await ReadBytesAsync(8, cancellationToken).ConfigureAwait(false)
+        );
+
+    public Task<ulong> ReadRarVIntAsync(
+        int maxBytes = 10,
+        CancellationToken cancellationToken = default
+    ) => DoReadRarVIntAsync((maxBytes - 1) * 7, cancellationToken);
+
+    private async Task<ulong> DoReadRarVIntAsync(int maxShift, CancellationToken cancellationToken)
+    {
+        var shift = 0;
+        ulong result = 0;
+        do
+        {
+            var b0 = await ReadByteAsync(cancellationToken).ConfigureAwait(false);
+            var b1 = ((uint)b0) & 0x7f;
+            ulong n = b1;
+            var shifted = n << shift;
+            if (n != shifted >> shift)
+            {
+                // overflow
+                break;
+            }
+            result |= shifted;
+            if (b0 == b1)
+            {
+                return result;
+            }
+            shift += 7;
+        } while (shift <= maxShift);
+
+        throw new FormatException("malformed vint");
+    }
+
+    public Task<uint> ReadRarVIntUInt32Async(
+        int maxBytes = 5,
+        CancellationToken cancellationToken = default
+    ) => DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken);
+
+    public async Task<ushort> ReadRarVIntUInt16Async(
+        int maxBytes = 3,
+        CancellationToken cancellationToken = default
+    ) =>
+        checked(
+            (ushort)
+                await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken)
+                    .ConfigureAwait(false)
+        );
+
+    public async Task<byte> ReadRarVIntByteAsync(
+        int maxBytes = 2,
+        CancellationToken cancellationToken = default
+    ) =>
+        checked(
+            (byte)
+                await DoReadRarVIntUInt32Async((maxBytes - 1) * 7, cancellationToken)
+                    .ConfigureAwait(false)
+        );
+
+    private async Task<uint> DoReadRarVIntUInt32Async(
+        int maxShift,
+        CancellationToken cancellationToken
+    )
+    {
+        var shift = 0;
+        uint result = 0;
+        do
+        {
+            var b0 = await ReadByteAsync(cancellationToken).ConfigureAwait(false);
+            var b1 = ((uint)b0) & 0x7f;
+            var n = b1;
+            var shifted = n << shift;
+            if (n != shifted >> shift)
+            {
+                // overflow
+                break;
+            }
+            result |= shifted;
+            if (b0 == b1)
+            {
+                return result;
+            }
+            shift += 7;
+        } while (shift <= maxShift);
+
+        throw new FormatException("malformed vint");
+    }
 }

src/SharpCompress/IO/SharpCompressStream.cs

@@ -245,8 +245,7 @@ public class SharpCompressStream : Stream, IStreamStack
             {
                 return 0;
             }
-            int read;
-            read = Stream.Read(buffer, offset, count);
+            int read = Stream.Read(buffer, offset, count);
             _internalPosition += read;
             return read;
         }

src/SharpCompress/Readers/AbstractReader.cs

@@ -18,6 +18,7 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
 {
     private bool _completed;
     private IEnumerator<TEntry>? _entriesForCurrentReadStream;
+    private IAsyncEnumerator<TEntry>? _entriesForCurrentReadStreamAsync;
     private bool _wroteCurrentEntry;
 
     internal AbstractReader(ReaderOptions options, ArchiveType archiveType)
@@ -104,7 +105,9 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
         }
         if (_entriesForCurrentReadStream is null)
         {
-            return LoadStreamForReading(RequestInitialStream());
+            var loaded = await LoadStreamForReadingAsync(RequestInitialStream(), cancellationToken)
+                .ConfigureAwait(false);
+            return loaded;
         }
         if (!_wroteCurrentEntry)
         {
@@ -121,7 +124,10 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
 
     protected bool LoadStreamForReading(Stream stream)
     {
-        _entriesForCurrentReadStream?.Dispose();
+        if (_entriesForCurrentReadStream is not null)
+        {
+            _entriesForCurrentReadStream.Dispose();
+        }
         if (stream is null || !stream.CanRead)
         {
             throw new MultipartStreamRequiredException(
@@ -134,6 +140,30 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
         return _entriesForCurrentReadStream.MoveNext();
     }
 
+    protected virtual async Task<bool> LoadStreamForReadingAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (_entriesForCurrentReadStreamAsync is null)
+        {
+            throw new InvalidOperationException("Entries async enumerator is not initialized.");
+        }
+        _entriesForCurrentReadStreamAsync?.DisposeAsync();
+        if (stream is null || !stream.CanRead)
+        {
+            throw new MultipartStreamRequiredException(
+                "File is split into multiple archives: '"
+                    + Entry.Key
+                    + "'. A new readable stream is required.  Use Cancel if it was intended."
+            );
+        }
+        // Default implementation uses sync version
+        _entriesForCurrentReadStreamAsync = GetEntriesAsync(stream, cancellationToken)
+            .GetAsyncEnumerator(cancellationToken);
+        return await _entriesForCurrentReadStreamAsync.MoveNextAsync();
+    }
+
     protected virtual Stream RequestInitialStream() =>
         Volume.NotNull("Volume isn't loaded.").Stream;
 
@@ -142,6 +172,11 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
 
     protected abstract IEnumerable<TEntry> GetEntries(Stream stream);
 
+    protected abstract IAsyncEnumerable<TEntry> GetEntriesAsync(
+        Stream stream,
+        CancellationToken cancellationToken = default
+    );
+
     #region Entry Skip/Write
 
     private void SkipEntry()
@@ -268,11 +303,11 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
     internal async Task WriteAsync(Stream writeStream, CancellationToken cancellationToken)
     {
 #if NETFRAMEWORK || NETSTANDARD2_0
-        using Stream s = OpenEntryStream();
+        using Stream s = await OpenEntryStreamAsync(cancellationToken).ConfigureAwait(false);
         var sourceStream = WrapWithProgress(s, Entry);
         await sourceStream.CopyToAsync(writeStream, 81920, cancellationToken).ConfigureAwait(false);
 #else
-        await using Stream s = OpenEntryStream();
+        await using Stream s = await OpenEntryStreamAsync(cancellationToken).ConfigureAwait(false);
         var sourceStream = WrapWithProgress(s, Entry);
         await sourceStream.CopyToAsync(writeStream, 81920, cancellationToken).ConfigureAwait(false);
 #endif
@@ -347,9 +382,16 @@ public abstract class AbstractReader<TEntry, TVolume> : IReader
     protected virtual EntryStream GetEntryStream() =>
         CreateEntryStream(Entry.Parts.First().GetCompressedStream());
 
-    protected virtual Task<EntryStream> GetEntryStreamAsync(
+    protected virtual async Task<EntryStream> GetEntryStreamAsync(
         CancellationToken cancellationToken = default
-    ) => Task.FromResult(GetEntryStream());
+    )
+    {
+        var stream = await Entry
+            .Parts.First()
+            .GetCompressedStreamAsync(cancellationToken)
+            .ConfigureAwait(false);
+        return CreateEntryStream(stream);
+    }
 
     #endregion
 

src/SharpCompress/Readers/Arc/ArcReader.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Arc;
@@ -37,5 +38,20 @@ namespace SharpCompress.Readers.Arc
                 yield return new ArcEntry(new ArcFilePart(header, stream));
             }
         }
+
+        protected override async IAsyncEnumerable<ArcEntry> GetEntriesAsync(
+            Stream stream,
+            [System.Runtime.CompilerServices.EnumeratorCancellation]
+                CancellationToken cancellationToken = default
+        )
+        {
+            ArcEntryHeader headerReader = new ArcEntryHeader(Options.ArchiveEncoding);
+            ArcEntryHeader? header;
+            while ((header = headerReader.ReadHeader(stream)) != null)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                yield return new ArcEntry(new ArcFilePart(header, stream));
+            }
+        }
     }
 }

src/SharpCompress/Readers/Arj/ArjReader.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using SharpCompress.Common;
 using SharpCompress.Common.Arj;
 using SharpCompress.Common.Arj.Headers;
@@ -85,5 +86,46 @@ namespace SharpCompress.Readers.Arj
 
         protected virtual IEnumerable<FilePart> CreateFilePartEnumerableForCurrentEntry() =>
             Entry.Parts;
+
+        protected override async IAsyncEnumerable<ArjEntry> GetEntriesAsync(
+            Stream stream,
+            [System.Runtime.CompilerServices.EnumeratorCancellation]
+                CancellationToken cancellationToken = default
+        )
+        {
+            var encoding = new ArchiveEncoding();
+            var mainHeaderReader = new ArjMainHeader(encoding);
+            var localHeaderReader = new ArjLocalHeader(encoding);
+
+            var mainHeader = mainHeaderReader.Read(stream);
+            if (mainHeader?.IsVolume == true)
+            {
+                throw new MultiVolumeExtractionException(
+                    "Multi volumes are currently not supported"
+                );
+            }
+            if (mainHeader?.IsGabled == true)
+            {
+                throw new CryptographicException(
+                    "Password protected archives are currently not supported"
+                );
+            }
+
+            if (_volume == null)
+            {
+                _volume = new ArjVolume(stream, Options, 0);
+                ValidateArchive(_volume);
+            }
+
+            while (true)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+                var localHeader = localHeaderReader.Read(stream);
+                if (localHeader == null)
+                    break;
+
+                yield return new ArjEntry(new ArjFilePart((ArjLocalHeader)localHeader, stream));
+            }
+        }
     }
 }

src/SharpCompress/Readers/Arj/MultiVolumeArjReader.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Arj;

src/SharpCompress/Readers/Arj/SingleVolumeArjReader.cs

@@ -1,31 +1,31 @@
 using System;
 using System.IO;
+using System.Threading;
 using SharpCompress.Common;
 using SharpCompress.Common.Arj;
 
-namespace SharpCompress.Readers.Arj
+namespace SharpCompress.Readers.Arj;
+
+internal class SingleVolumeArjReader : ArjReader
 {
-    internal class SingleVolumeArjReader : ArjReader
+    private readonly Stream _stream;
+
+    internal SingleVolumeArjReader(Stream stream, ReaderOptions options)
+        : base(options)
     {
-        private readonly Stream _stream;
+        stream.NotNull(nameof(stream));
+        _stream = stream;
+    }
 
-        internal SingleVolumeArjReader(Stream stream, ReaderOptions options)
-            : base(options)
+    protected override Stream RequestInitialStream() => _stream;
+
+    protected override void ValidateArchive(ArjVolume archive)
+    {
+        if (archive.IsMultiVolume)
         {
-            stream.NotNull(nameof(stream));
-            _stream = stream;
-        }
-
-        protected override Stream RequestInitialStream() => _stream;
-
-        protected override void ValidateArchive(ArjVolume archive)
-        {
-            if (archive.IsMultiVolume)
-            {
-                throw new MultiVolumeExtractionException(
-                    "Streamed archive is a Multi-volume archive. Use a different ArjReader method to extract."
-                );
-            }
+            throw new MultiVolumeExtractionException(
+                "Streamed archive is a Multi-volume archive. Use a different ArjReader method to extract."
+            );
         }
     }
 }

src/SharpCompress/Readers/GZip/GZipReader.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
 
@@ -30,4 +31,17 @@ public class GZipReader : AbstractReader<GZipEntry, GZipVolume>
 
     protected override IEnumerable<GZipEntry> GetEntries(Stream stream) =>
         GZipEntry.GetEntries(stream, Options);
+
+    protected override async IAsyncEnumerable<GZipEntry> GetEntriesAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        foreach (var entry in GZipEntry.GetEntries(stream, Options))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            yield return entry;
+        }
+    }
 }

src/SharpCompress/Readers/IReaderFactory.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Readers;
 
@@ -11,4 +13,17 @@ public interface IReaderFactory : Factories.IFactory
     /// <param name="options"></param>
     /// <returns></returns>
     IReader OpenReader(Stream stream, ReaderOptions? options);
+
+    /// <summary>
+    /// Opens a Reader asynchronously for Non-seeking usage
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    Task<IReader> OpenReaderAsync(
+        Stream stream,
+        ReaderOptions? options,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Readers/Rar/RarReader.cs

@@ -2,6 +2,8 @@ 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.Rar;
 using SharpCompress.Compressors.Rar;
@@ -97,6 +99,20 @@ public abstract class RarReader : AbstractReader<RarReaderEntry, RarVolume>
         }
     }
 
+    protected override async IAsyncEnumerable<RarReaderEntry> GetEntriesAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        volume = new RarReaderVolume(stream, Options, 0);
+        await foreach (var fp in volume.ReadFilePartsAsync(cancellationToken).ConfigureAwait(false))
+        {
+            ValidateArchive(volume);
+            yield return new RarReaderEntry(volume.IsSolidArchive, fp);
+        }
+    }
+
     protected virtual IEnumerable<FilePart> CreateFilePartEnumerableForCurrentEntry() =>
         Entry.Parts;
 

src/SharpCompress/Readers/Rar/RarReaderVolume.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using SharpCompress.Common.Rar;
 using SharpCompress.Common.Rar.Headers;
 using SharpCompress.IO;
@@ -15,4 +16,8 @@ public class RarReaderVolume : RarVolume
         new NonSeekableStreamFilePart(markHeader, fileHeader, Index);
 
     internal override IEnumerable<RarFilePart> ReadFileParts() => GetVolumeFileParts();
+
+    internal override IAsyncEnumerable<RarFilePart> ReadFilePartsAsync(
+        CancellationToken cancellationToken = default
+    ) => GetVolumeFilePartsAsync(cancellationToken);
 }

src/SharpCompress/Readers/ReaderFactory.cs

@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Factories;
 using SharpCompress.IO;
@@ -15,12 +17,46 @@ public static class ReaderFactory
         return Open(new FileInfo(filePath), options);
     }
 
+    /// <summary>
+    /// Opens a Reader from a filepath asynchronously
+    /// </summary>
+    /// <param name="filePath"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public static Task<IReader> OpenAsync(
+        string filePath,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        filePath.NotNullOrEmpty(nameof(filePath));
+        return OpenAsync(new FileInfo(filePath), options, cancellationToken);
+    }
+
     public static IReader Open(FileInfo fileInfo, ReaderOptions? options = null)
     {
         options ??= new ReaderOptions { LeaveStreamOpen = false };
         return Open(fileInfo.OpenRead(), options);
     }
 
+    /// <summary>
+    /// Opens a Reader from a FileInfo asynchronously
+    /// </summary>
+    /// <param name="fileInfo"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public static Task<IReader> OpenAsync(
+        FileInfo fileInfo,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        options ??= new ReaderOptions { LeaveStreamOpen = false };
+        return OpenAsync(fileInfo.OpenRead(), options, cancellationToken);
+    }
+
     /// <summary>
     /// Opens a Reader for Non-seeking usage
     /// </summary>
@@ -73,4 +109,84 @@ public static class ReaderFactory
             "Cannot determine compressed stream type.  Supported Reader Formats: Arc, Arj, Zip, GZip, BZip2, Tar, Rar, LZip, XZ, ZStandard"
         );
     }
+
+    /// <summary>
+    /// Opens a Reader for Non-seeking usage asynchronously
+    /// </summary>
+    /// <param name="stream"></param>
+    /// <param name="options"></param>
+    /// <param name="cancellationToken"></param>
+    /// <returns></returns>
+    public static async Task<IReader> OpenAsync(
+        Stream stream,
+        ReaderOptions? options = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        stream.NotNull(nameof(stream));
+        options ??= new ReaderOptions() { LeaveStreamOpen = false };
+
+        var bStream = new SharpCompressStream(stream, bufferSize: options.BufferSize);
+
+        long pos = ((IStreamStack)bStream).GetPosition();
+
+        var factories = Factories.Factory.Factories.OfType<Factories.Factory>();
+
+        Factory? testedFactory = null;
+
+        if (!string.IsNullOrWhiteSpace(options.ExtensionHint))
+        {
+            testedFactory = factories.FirstOrDefault(a =>
+                a.GetSupportedExtensions()
+                    .Contains(options.ExtensionHint, StringComparer.CurrentCultureIgnoreCase)
+            );
+            if (testedFactory is IReaderFactory readerFactory)
+            {
+                ((IStreamStack)bStream).StackSeek(pos);
+                if (
+                    await testedFactory.IsArchiveAsync(
+                        bStream,
+                        options.Password,
+                        options.BufferSize,
+                        cancellationToken
+                    )
+                )
+                {
+                    ((IStreamStack)bStream).StackSeek(pos);
+                    return await readerFactory
+                        .OpenReaderAsync(bStream, options, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+            }
+            ((IStreamStack)bStream).StackSeek(pos);
+        }
+
+        foreach (var factory in factories)
+        {
+            if (testedFactory == factory)
+            {
+                continue; // Already tested above
+            }
+            ((IStreamStack)bStream).StackSeek(pos);
+            if (
+                factory is IReaderFactory readerFactory
+                && await factory.IsArchiveAsync(
+                    bStream,
+                    options.Password,
+                    options.BufferSize,
+                    cancellationToken
+                )
+            )
+            {
+                ((IStreamStack)bStream).StackSeek(pos);
+                return await readerFactory
+                    .OpenReaderAsync(bStream, options, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+        }
+
+        throw new InvalidFormatException(
+            "Cannot determine compressed stream type.  Supported Reader Formats: Arc, Arj, Zip, GZip, BZip2, Tar, Rar, LZip, XZ, ZStandard"
+        );
+    }
 }

src/SharpCompress/Readers/Tar/TarReader.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using SharpCompress.Archives.GZip;
 using SharpCompress.Archives.Tar;
 using SharpCompress.Common;
@@ -124,4 +125,24 @@ public class TarReader : AbstractReader<TarEntry, TarVolume>
             compressionType,
             Options.ArchiveEncoding
         );
+
+    protected override async IAsyncEnumerable<TarEntry> GetEntriesAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        foreach (
+            var entry in TarEntry.GetEntries(
+                StreamingMode.Streaming,
+                stream,
+                compressionType,
+                Options.ArchiveEncoding
+            )
+        )
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            yield return entry;
+        }
+    }
 }

src/SharpCompress/Readers/Zip/ZipReader.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
+using System.Threading;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
@@ -91,4 +92,40 @@ public class ZipReader : AbstractReader<ZipEntry, ZipVolume>
             }
         }
     }
+
+    protected override async IAsyncEnumerable<ZipEntry> GetEntriesAsync(
+        Stream stream,
+        [System.Runtime.CompilerServices.EnumeratorCancellation]
+            CancellationToken cancellationToken = default
+    )
+    {
+        await foreach (var h in _headerFactory.ReadStreamHeaderAsync(stream, cancellationToken))
+        {
+            if (h != null)
+            {
+                switch (h.ZipHeaderType)
+                {
+                    case ZipHeaderType.LocalEntry:
+                        {
+                            yield return new ZipEntry(
+                                new StreamingZipFilePart((LocalEntryHeader)h, stream)
+                            );
+                        }
+                        break;
+                    case ZipHeaderType.DirectoryEntry:
+                        // DirectoryEntry headers in the central directory are intentionally skipped.
+                        // In streaming mode, we can only read forward, and DirectoryEntry headers
+                        // reference LocalEntry headers that have already been processed. The file
+                        // data comes from LocalEntry headers, not DirectoryEntry headers.
+                        // For multi-volume ZIPs where file data spans multiple files, use ZipArchive
+                        // instead, which requires seekable streams.
+                        break;
+                    case ZipHeaderType.DirectoryEnd:
+                    {
+                        yield break;
+                    }
+                }
+            }
+        }
+    }
 }

src/SharpCompress/Utility.cs

@@ -406,6 +406,33 @@ internal static class Utility
         return (total >= buffer.Length);
     }
 
+    public static async Task<bool> ReadFullyAsync(
+        this Stream stream,
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var total = 0;
+        int read;
+        while (
+            (
+                read = await stream
+                    .ReadAsync(buffer, offset + total, count - total, cancellationToken)
+                    .ConfigureAwait(false)
+            ) > 0
+        )
+        {
+            total += read;
+            if (total >= count)
+            {
+                return true;
+            }
+        }
+        return (total >= count);
+    }
+
     public static string TrimNulls(this string source) => source.Replace('\0', ' ').Trim();
 
     /// <summary>

src/SharpCompress/Writers/IWriterFactory.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Factories;
 
 namespace SharpCompress.Writers;
@@ -6,4 +8,10 @@ namespace SharpCompress.Writers;
 public interface IWriterFactory : IFactory
 {
     IWriter Open(Stream stream, WriterOptions writerOptions);
+
+    Task<IWriter> OpenAsync(
+        Stream stream,
+        WriterOptions writerOptions,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Writers/WriterFactory.cs

@@ -1,6 +1,8 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 
 namespace SharpCompress.Writers;
@@ -20,4 +22,33 @@ public static class WriterFactory
 
         throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType);
     }
+
+    /// <summary>
+    /// Opens a Writer asynchronously.
+    /// </summary>
+    /// <param name="stream">The stream to write to.</param>
+    /// <param name="archiveType">The archive type.</param>
+    /// <param name="writerOptions">Writer options.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task that returns an IWriter.</returns>
+    public static async Task<IWriter> OpenAsync(
+        Stream stream,
+        ArchiveType archiveType,
+        WriterOptions writerOptions,
+        CancellationToken cancellationToken = default
+    )
+    {
+        var factory = Factories
+            .Factory.Factories.OfType<IWriterFactory>()
+            .FirstOrDefault(item => item.KnownArchiveType == archiveType);
+
+        if (factory != null)
+        {
+            return await factory
+                .OpenAsync(stream, writerOptions, cancellationToken)
+                .ConfigureAwait(false);
+        }
+
+        throw new NotSupportedException("Archive Type does not have a Writer: " + archiveType);
+    }
 }

tests/SharpCompress.Test/Arc/ArcReaderAsyncTests.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using SharpCompress.Common;
+using Xunit;
+
+namespace SharpCompress.Test.Arc;
+
+public class ArcReaderAsyncTests : ReaderTests
+{
+    public ArcReaderAsyncTests()
+    {
+        UseExtensionInsteadOfNameToVerify = true;
+        UseCaseInsensitiveToVerify = true;
+    }
+
+    [Fact]
+    public async Task Arc_Uncompressed_Read_Async() =>
+        await ReadAsync("Arc.uncompressed.arc", CompressionType.None);
+
+    [Fact]
+    public async Task Arc_Squeezed_Read_Async() => await ReadAsync("Arc.squeezed.arc");
+
+    [Fact]
+    public async Task Arc_Crunched_Read_Async() => await ReadAsync("Arc.crunched.arc");
+}

tests/SharpCompress.Test/Arc/ArcReaderTests.cs

@@ -1,12 +1,5 @@
 using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using SharpCompress.Common;
-using SharpCompress.Readers;
-using SharpCompress.Readers.Arc;
 using Xunit;
 
 namespace SharpCompress.Test.Arc

tests/SharpCompress.Test/Mocks/AsyncOnlyStream.cs

@@ -0,0 +1,70 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace SharpCompress.Test.Mocks;
+
+public class AsyncOnlyStream : Stream
+{
+    private readonly Stream _stream;
+
+    public AsyncOnlyStream(Stream stream)
+    {
+        _stream = stream;
+        // Console.WriteLine("AsyncOnlyStream created");
+    }
+
+    public override bool CanRead => _stream.CanRead;
+    public override bool CanSeek => _stream.CanSeek;
+    public override bool CanWrite => _stream.CanWrite;
+    public override long Length => _stream.Length;
+    public override long Position
+    {
+        get => _stream.Position;
+        set => _stream.Position = value;
+    }
+
+    public override void Flush() => _stream.Flush();
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        throw new NotSupportedException("Synchronous Read is not supported");
+    }
+
+    public override Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    )
+    {
+        return _stream.ReadAsync(buffer, offset, count, cancellationToken);
+    }
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    )
+    {
+        return _stream.ReadAsync(buffer, cancellationToken);
+    }
+#endif
+
+    public override long Seek(long offset, SeekOrigin origin) => _stream.Seek(offset, origin);
+
+    public override void SetLength(long value) => _stream.SetLength(value);
+
+    public override void Write(byte[] buffer, int offset, int count) =>
+        _stream.Write(buffer, offset, count);
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _stream.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+}

tests/SharpCompress.Test/Mocks/TestStream.cs

@@ -1,4 +1,7 @@
-using System.IO;
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Test.Mocks;
 
@@ -35,6 +38,20 @@ public class TestStream(Stream stream, bool read, bool write, bool seek) : Strea
     public override int Read(byte[] buffer, int offset, int count) =>
         stream.Read(buffer, offset, count);
 
+    public override Task<int> ReadAsync(
+        byte[] buffer,
+        int offset,
+        int count,
+        CancellationToken cancellationToken
+    ) => stream.ReadAsync(buffer, offset, count, cancellationToken);
+
+#if !NETFRAMEWORK && !NETSTANDARD2_0
+    public override ValueTask<int> ReadAsync(
+        Memory<byte> buffer,
+        CancellationToken cancellationToken = default
+    ) => stream.ReadAsync(buffer, cancellationToken);
+#endif
+
     public override long Seek(long offset, SeekOrigin origin) => stream.Seek(offset, origin);
 
     public override void SetLength(long value) => stream.SetLength(value);

tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs

@@ -7,6 +7,7 @@ using SharpCompress.Archives.Rar;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Rar;
+using SharpCompress.Test.Mocks;
 using Xunit;
 
 namespace SharpCompress.Test.Rar;
@@ -45,7 +46,7 @@ public class RarReaderAsyncTests : ReaderTests
             )
         )
         {
-            while (reader.MoveToNextEntry())
+            while (await reader.MoveToNextEntryAsync())
             {
                 await reader.WriteEntryToDirectoryAsync(
                     SCRATCH_FILES_PATH,
@@ -73,12 +74,13 @@ public class RarReaderAsyncTests : ReaderTests
                 var reader = RarReader.Open(
                     archives
                         .Select(s => Path.Combine(TEST_ARCHIVES_PATH, s))
-                        .Select(p => File.OpenRead(p)),
+                        .Select(p => File.OpenRead(p))
+                        .Select(x => new AsyncOnlyStream(x)),
                     new ReaderOptions { Password = "test" }
                 )
             )
             {
-                while (reader.MoveToNextEntry())
+                while (await reader.MoveToNextEntryAsync())
                 {
                     await reader.WriteEntryToDirectoryAsync(
                         SCRATCH_FILES_PATH,
@@ -123,10 +125,11 @@ public class RarReaderAsyncTests : ReaderTests
         var streams = archives
             .Select(s => Path.Combine(SCRATCH2_FILES_PATH, s))
             .Select(File.OpenRead)
+            .Select(x => new AsyncOnlyStream(x))
             .ToList();
         using (var reader = RarReader.Open(streams))
         {
-            while (reader.MoveToNextEntry())
+            while (await reader.MoveToNextEntryAsync())
             {
                 await reader.WriteEntryToDirectoryAsync(
                     SCRATCH_FILES_PATH,
@@ -204,7 +207,7 @@ public class RarReaderAsyncTests : ReaderTests
     private async Task DoRar_Entry_Stream_Async(string filename)
     {
         using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)))
-        using (var reader = ReaderFactory.Open(stream))
+        using (var reader = await ReaderFactory.OpenAsync(stream))
         {
             while (await reader.MoveToNextEntryAsync())
             {
@@ -248,9 +251,14 @@ public class RarReaderAsyncTests : ReaderTests
         using (
             var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.Audio_program.rar"))
         )
-        using (var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true }))
+        using (
+            var reader = await ReaderFactory.OpenAsync(
+                stream,
+                new ReaderOptions { LookForHeader = true }
+            )
+        )
         {
-            while (reader.MoveToNextEntry())
+            while (await reader.MoveToNextEntryAsync())
             {
                 Assert.Equal(CompressionType.Rar, reader.Entry.CompressionType);
                 await reader.WriteEntryToDirectoryAsync(
@@ -271,7 +279,7 @@ public class RarReaderAsyncTests : ReaderTests
         using (var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.jpeg.jpg")))
         using (var reader = RarReader.Open(stream, new ReaderOptions { LookForHeader = true }))
         {
-            while (reader.MoveToNextEntry())
+            while (await reader.MoveToNextEntryAsync())
             {
                 Assert.Equal(CompressionType.Rar, reader.Entry.CompressionType);
                 await reader.WriteEntryToDirectoryAsync(
@@ -310,8 +318,11 @@ public class RarReaderAsyncTests : ReaderTests
     private async Task DoRar_Solid_Skip_Reader_Async(string filename)
     {
         using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename));
-        using var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true });
-        while (reader.MoveToNextEntry())
+        using var reader = await ReaderFactory.OpenAsync(
+            stream,
+            new ReaderOptions { LookForHeader = true }
+        );
+        while (await reader.MoveToNextEntryAsync())
         {
             if (reader.Entry.Key.NotNull().Contains("jpg"))
             {
@@ -332,9 +343,14 @@ public class RarReaderAsyncTests : ReaderTests
 
     private async Task DoRar_Reader_Skip_Async(string filename)
     {
-        using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename));
-        using var reader = ReaderFactory.Open(stream, new ReaderOptions { LookForHeader = true });
-        while (reader.MoveToNextEntry())
+        using var stream = new AsyncOnlyStream(
+            File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename))
+        );
+        using var reader = await ReaderFactory.OpenAsync(
+            stream,
+            new ReaderOptions { LookForHeader = true }
+        );
+        while (await reader.MoveToNextEntryAsync())
         {
             if (reader.Entry.Key.NotNull().Contains("jpg"))
             {
@@ -354,8 +370,11 @@ public class RarReaderAsyncTests : ReaderTests
     )
     {
         testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive);
-        using Stream stream = File.OpenRead(testArchive);
-        using var reader = ReaderFactory.Open(stream, readerOptions ?? new ReaderOptions());
+        using Stream stream = new AsyncOnlyStream(File.OpenRead(testArchive));
+        using var reader = await ReaderFactory.OpenAsync(
+            stream,
+            readerOptions ?? new ReaderOptions()
+        );
         while (await reader.MoveToNextEntryAsync())
         {
             if (!reader.Entry.IsDirectory)

tests/SharpCompress.Test/ReaderTests.cs

@@ -112,7 +112,7 @@ public abstract class ReaderTests : TestBase
 
     protected async Task ReadAsync(
         string testArchive,
-        CompressionType expectedCompression,
+        CompressionType? expectedCompression = null,
         ReaderOptions? options = null,
         CancellationToken cancellationToken = default
     )
@@ -131,7 +131,7 @@ public abstract class ReaderTests : TestBase
 
     private async Task ReadImplAsync(
         string testArchive,
-        CompressionType expectedCompression,
+        CompressionType? expectedCompression,
         ReaderOptions options,
         CancellationToken cancellationToken = default
     )
@@ -158,7 +158,7 @@ public abstract class ReaderTests : TestBase
 
     public async Task UseReaderAsync(
         IReader reader,
-        CompressionType expectedCompression,
+        CompressionType? expectedCompression,
         CancellationToken cancellationToken = default
     )
     {
@@ -166,7 +166,11 @@ public abstract class ReaderTests : TestBase
         {
             if (!reader.Entry.IsDirectory)
             {
-                Assert.Equal(expectedCompression, reader.Entry.CompressionType);
+                if (expectedCompression.HasValue)
+                {
+                    Assert.Equal(expectedCompression, reader.Entry.CompressionType);
+                }
+
                 await reader.WriteEntryToDirectoryAsync(
                     SCRATCH_FILES_PATH,
                     new ExtractionOptions { ExtractFullPath = true, Overwrite = true },

tests/SharpCompress.Test/Streams/LzmaStreamAsyncTests.cs

@@ -3,6 +3,7 @@ using System.Buffers;
 using System.IO;
 using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA;
+using SharpCompress.Test.Mocks;
 using Xunit;
 
 namespace SharpCompress.Test.Streams;
@@ -14,7 +15,7 @@ public class LzmaStreamAsyncTests
     {
         var properties = new byte[] { 0x01 };
         var compressedData = new byte[] { 0x01, 0x00, 0x00, 0x58, 0x00 };
-        var lzma2Stream = new MemoryStream(compressedData);
+        var lzma2Stream = new AsyncOnlyStream(new MemoryStream(compressedData));
 
         var decompressor = new LzmaStream(properties, lzma2Stream, 5, 1);
         var buffer = new byte[1];

tests/SharpCompress.Test/Streams/RewindableStreamAsyncTest.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using SharpCompress.IO;
+using SharpCompress.Test.Mocks;
 using Xunit;
 
 namespace SharpCompress.Test.Streams;
@@ -10,7 +11,7 @@ public class RewindableStreamAsyncTest
     [Fact]
     public async Task TestRewindAsync()
     {
-        var ms = new MemoryStream();
+        var ms = new AsyncOnlyStream(new MemoryStream());
         var bw = new BinaryWriter(ms);
         bw.Write(1);
         bw.Write(2);
@@ -48,7 +49,7 @@ public class RewindableStreamAsyncTest
     [Fact]
     public async Task TestIncompleteRewindAsync()
     {
-        var ms = new MemoryStream();
+        var ms = new AsyncOnlyStream(new MemoryStream());
         var bw = new BinaryWriter(ms);
         bw.Write(1);
         bw.Write(2);

tests/SharpCompress.Test/Streams/SharpCompressStreamAsyncTests.cs

@@ -6,6 +6,7 @@ using System.Text;
 using System.Threading.Tasks;
 using SharpCompress.Compressors.LZMA;
 using SharpCompress.IO;
+using SharpCompress.Test.Mocks;
 using Xunit;
 
 namespace SharpCompress.Test.Streams;
@@ -22,6 +23,7 @@ public class SharpCompressStreamAsyncTests
                 bw.Write(i);
             }
         }
+        ms.Flush();
         ms.Position = 0;
     }
 
@@ -30,11 +32,12 @@ public class SharpCompressStreamAsyncTests
     {
         byte[] data = new byte[0x100000];
         byte[] test = new byte[0x1000];
-        using (MemoryStream ms = new MemoryStream(data))
+        using (var ms = new MemoryStream(data))
         {
             CreateData(ms);
 
-            using (SharpCompressStream scs = new SharpCompressStream(ms, true, false, 0x10000))
+            using var aos = new AsyncOnlyStream(ms);
+            using (SharpCompressStream scs = new SharpCompressStream(aos, true, false, 0x10000))
             {
                 scs.Seek(0x1000, SeekOrigin.Begin);
                 Assert.Equal(0x1000, scs.Position); // position in the SharpCompressionStream
@@ -63,7 +66,8 @@ public class SharpCompressStreamAsyncTests
         {
             CreateData(ms);
 
-            using (SharpCompressStream scs = new SharpCompressStream(ms, true, false, 0x10000))
+            using var aos = new AsyncOnlyStream(ms);
+            using (SharpCompressStream scs = new SharpCompressStream(aos, true, false, 0x10000))
             {
                 IStreamStack stack = (IStreamStack)scs;
 
@@ -99,7 +103,8 @@ public class SharpCompressStreamAsyncTests
         {
             CreateData(ms);
 
-            using (SharpCompressStream scs = new SharpCompressStream(ms, true, false, 0x10000))
+            using var aos = new AsyncOnlyStream(ms);
+            using (SharpCompressStream scs = new SharpCompressStream(aos, true, false, 0x10000))
             {
                 // Read first chunk
                 await scs.ReadAsync(test1, 0, test1.Length);
@@ -123,7 +128,8 @@ public class SharpCompressStreamAsyncTests
         {
             CreateData(ms);
 
-            using (SharpCompressStream scs = new SharpCompressStream(ms, true, false, 0x10000))
+            using var aos = new AsyncOnlyStream(ms);
+            using (SharpCompressStream scs = new SharpCompressStream(aos, true, false, 0x10000))
             {
                 for (int i = 0; i < 10; i++)
                 {

tests/SharpCompress.Test/Streams/ZLibBaseStreamAsyncTests.cs

@@ -5,6 +5,7 @@ using AwesomeAssertions;
 using SharpCompress.Compressors;
 using SharpCompress.Compressors.Deflate;
 using SharpCompress.IO;
+using SharpCompress.Test.Mocks;
 using Xunit;
 
 namespace SharpCompress.Test.Streams;
@@ -40,7 +41,8 @@ public class ZLibBaseStreamAsyncTests
         var buf = new byte[plainData.Length * 2];
 
         var plainStream1 = new MemoryStream(plainData);
-        var compressor1 = new DeflateStream(plainStream1, CompressionMode.Compress);
+        using var aos = new AsyncOnlyStream(plainStream1);
+        var compressor1 = new DeflateStream(aos, CompressionMode.Compress);
         // This is enough to read the entire data
         var realCompressedSize = await compressor1
             .ReadAsync(buf, 0, plainData.Length * 2)
@@ -67,14 +69,16 @@ public class ZLibBaseStreamAsyncTests
         var bytes = Encoding.ASCII.GetBytes(message);
 
         using var inputStream = new MemoryStream(bytes);
+        using var aos = new AsyncOnlyStream(inputStream);
         using var compressedStream = new MemoryStream();
-        using var byteBufferStream = new BufferedStream(inputStream); // System.IO
+        using var byteBufferStream = new BufferedStream(aos); // System.IO
         await CompressAsync(byteBufferStream, compressedStream, compressionLevel: 1)
             .ConfigureAwait(false);
         compressedStream.Position = 0;
 
         using var decompressedStream = new MemoryStream();
-        await DecompressAsync(compressedStream, decompressedStream).ConfigureAwait(false);
+        using var aos2 = new AsyncOnlyStream(decompressedStream);
+        await DecompressAsync(compressedStream, aos2).ConfigureAwait(false);
 
         byteBufferStream.Position = 0;
         var result = Encoding.ASCII.GetString(

tests/SharpCompress.Test/WriterTests.cs

@@ -91,9 +91,10 @@ public class WriterTests : TestBase
                 SharpCompressStream.Create(stream, leaveOpen: true),
                 readerOptions
             );
-            reader.WriteAllToDirectory(
+            await reader.WriteAllToDirectoryAsync(
                 SCRATCH_FILES_PATH,
-                new ExtractionOptions { ExtractFullPath = true }
+                new ExtractionOptions { ExtractFullPath = true },
+                cancellationToken
             );
         }
         VerifyFiles();

tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs

@@ -1,7 +1,9 @@
 using System;
 using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using SharpCompress.Common;
+using SharpCompress.IO;
 using SharpCompress.Readers;
 using SharpCompress.Readers.Zip;
 using SharpCompress.Test.Mocks;
@@ -162,9 +164,11 @@ public class ZipReaderAsyncTests : ReaderTests
     public async Task Zip_Reader_Disposal_Test2_Async()
     {
         using var stream = new TestStream(
-            File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))
+            new AsyncOnlyStream(
+                File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip"))
+            )
         );
-        var reader = ReaderFactory.Open(stream);
+        var reader = await ReaderFactory.OpenAsync(stream);
         while (await reader.MoveToNextEntryAsync())
         {
             if (!reader.Entry.IsDirectory)
@@ -183,8 +187,8 @@ public class ZipReaderAsyncTests : ReaderTests
         await Assert.ThrowsAsync<NotSupportedException>(async () =>
         {
             using (
-                Stream stream = File.OpenRead(
-                    Path.Combine(TEST_ARCHIVES_PATH, "Zip.lzma.WinzipAES.zip")
+                Stream stream = new AsyncOnlyStream(
+                    File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.lzma.WinzipAES.zip"))
                 )
             )
             using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" }))
@@ -208,8 +212,8 @@ public class ZipReaderAsyncTests : ReaderTests
     public async Task Zip_Deflate_WinzipAES_Read_Async()
     {
         using (
-            Stream stream = File.OpenRead(
-                Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip")
+            Stream stream = new AsyncOnlyStream(
+                File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.WinzipAES.zip"))
             )
         )
         using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" }))
@@ -233,7 +237,11 @@ public class ZipReaderAsyncTests : ReaderTests
     public async Task Zip_Deflate_ZipCrypto_Read_Async()
     {
         var count = 0;
-        using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "zipcrypto.zip")))
+        using (
+            Stream stream = new AsyncOnlyStream(
+                File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "zipcrypto.zip"))
+            )
+        )
         using (var reader = ZipReader.Open(stream, new ReaderOptions { Password = "test" }))
         {
             while (await reader.MoveToNextEntryAsync())