On ongoing branch of making everything async

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Readers;
 using SharpCompress.Writers;
@@ -137,11 +139,11 @@ private bool DoesKeyMatchExisting(string key)
             return false;
         }
 
-        public void SaveTo(Stream stream, WriterOptions options)
+        public async Task SaveToAsync(Stream stream, WriterOptions options)
         {
             //reset streams of new entries
             newEntries.Cast<IWritableArchiveEntry>().ForEach(x => x.Stream.Seek(0, SeekOrigin.Begin));
-            SaveTo(stream, options, OldEntries, newEntries);
+            await SaveToAsync(stream, options, OldEntries, newEntries);
         }
 
         protected TEntry CreateEntry(string key, Stream source, long size, DateTime? modified,
@@ -157,7 +159,8 @@ protected TEntry CreateEntry(string key, Stream source, long size, DateTime? mod
         protected abstract TEntry CreateEntryInternal(string key, Stream source, long size, DateTime? modified,
                                                       bool closeStream);
 
-        protected abstract void SaveTo(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries);
+        protected abstract Task SaveToAsync(Stream stream, WriterOptions options, IEnumerable<TEntry> oldEntries, IEnumerable<TEntry> newEntries,
+                                            CancellationToken cancellationToken = default);
 
         public override void Dispose()
         {

src/SharpCompress/Archives/GZip/GZipArchive.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.GZip;
 using SharpCompress.Readers;
@@ -82,17 +84,15 @@ public static bool IsGZipFile(FileInfo fileInfo)
             return IsGZipFile(stream);
         }
 
-        public void SaveTo(string filePath)
+        public Task SaveToAsync(string filePath)
         {
-            SaveTo(new FileInfo(filePath));
+            return SaveToAsync(new FileInfo(filePath));
         }
 
-        public void SaveTo(FileInfo fileInfo)
+        public async Task SaveToAsync(FileInfo fileInfo)
         {
-            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
-            {
-                SaveTo(stream, new WriterOptions(CompressionType.GZip));
-            }
+            using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+            await SaveToAsync(stream, new WriterOptions(CompressionType.GZip));
         }
 
         public static bool IsGZipFile(Stream stream)
@@ -139,24 +139,22 @@ protected override GZipArchiveEntry CreateEntryInternal(string filePath, Stream
             return new GZipWritableArchiveEntry(this, source, filePath, size, modified, closeStream);
         }
 
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<GZipArchiveEntry> oldEntries,
-                                       IEnumerable<GZipArchiveEntry> newEntries)
+        protected override async Task SaveToAsync(Stream stream, WriterOptions options,
+                                            IEnumerable<GZipArchiveEntry> oldEntries,
+                                            IEnumerable<GZipArchiveEntry> newEntries, 
+                                            CancellationToken cancellationToken = default)
         {
             if (Entries.Count > 1)
             {
                 throw new InvalidOperationException("Only one entry is allowed in a GZip Archive");
             }
-            using (var writer = new GZipWriter(stream, new GZipWriterOptions(options)))
+
+            await using var writer = new GZipWriter(stream, new GZipWriterOptions(options));
+            foreach (var entry in oldEntries.Concat(newEntries)
+                                            .Where(x => !x.IsDirectory))
             {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
-                    }
-                }
+                await using var entryStream = entry.OpenEntryStream();
+                await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
             }
         }
 

src/SharpCompress/Archives/IWritableArchive.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives
@@ -10,7 +11,7 @@ public interface IWritableArchive : IArchive
 
         IArchiveEntry AddEntry(string key, Stream source, bool closeStream, long size = 0, DateTime? modified = null);
 
-        void SaveTo(Stream stream, WriterOptions options);
+        Task SaveToAsync(Stream stream, WriterOptions options);
 
         /// <summary>
         /// Use this to pause entry rebuilding when adding large collections of entries.  Dispose when complete.  A  using statement is recommended.

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 using SharpCompress.Writers;
 
 namespace SharpCompress.Archives
@@ -18,17 +19,15 @@ public static void AddEntry(this IWritableArchive writableArchive,
                                      fileInfo.LastWriteTime);
         }
 
-        public static void SaveTo(this IWritableArchive writableArchive, string filePath, WriterOptions options)
+        public static Task SaveToAsync(this IWritableArchive writableArchive, string filePath, WriterOptions options)
         {
-            writableArchive.SaveTo(new FileInfo(filePath), options);
+            return writableArchive.SaveToAsync(new FileInfo(filePath), options);
         }
 
-        public static void SaveTo(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options)
+        public static async Task SaveToAsync(this IWritableArchive writableArchive, FileInfo fileInfo, WriterOptions options)
         {
-            using (var stream = fileInfo.Open(FileMode.Create, FileAccess.Write))
-            {
-                writableArchive.SaveTo(stream, options);
-            }
+            await using var stream = fileInfo.Open(FileMode.Create, FileAccess.Write);
+            await writableArchive.SaveToAsync(stream, options);
         }
 
         public static void AddAllFromDirectory(

src/SharpCompress/Archives/Tar/TarArchive.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Tar;
 using SharpCompress.Common.Tar.Headers;
@@ -59,10 +61,9 @@ public static bool IsTarFile(FileInfo fileInfo)
             {
                 return false;
             }
-            using (Stream stream = fileInfo.OpenRead())
-            {
-                return IsTarFile(stream);
-            }
+
+            using Stream stream = fileInfo.OpenRead();
+            return IsTarFile(stream);
         }
 
         public static bool IsTarFile(Stream stream)
@@ -170,20 +171,17 @@ protected override TarArchiveEntry CreateEntryInternal(string filePath, Stream s
                                                closeStream);
         }
 
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<TarArchiveEntry> oldEntries,
-                                       IEnumerable<TarArchiveEntry> newEntries)
+        protected override async Task SaveToAsync(Stream stream, WriterOptions options,
+                                            IEnumerable<TarArchiveEntry> oldEntries,
+                                            IEnumerable<TarArchiveEntry> newEntries,
+                                            CancellationToken cancellationToken = default)
         {
-            using (var writer = new TarWriter(stream, new TarWriterOptions(options)))
+            await using var writer = new TarWriter(stream, new TarWriterOptions(options));
+            foreach (var entry in oldEntries.Concat(newEntries)
+                                            .Where(x => !x.IsDirectory))
             {
-                foreach (var entry in oldEntries.Concat(newEntries)
-                                                .Where(x => !x.IsDirectory))
-                {
-                    using (var entryStream = entry.OpenEntryStream())
-                    {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime, entry.Size);
-                    }
-                }
+                await using var entryStream = entry.OpenEntryStream();
+                await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
             }
         }
 

src/SharpCompress/Archives/Zip/ZipArchive.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using SharpCompress.Common;
 using SharpCompress.Common.Zip;
 using SharpCompress.Common.Zip.Headers;
@@ -163,23 +165,24 @@ protected override IEnumerable<ZipArchiveEntry> LoadEntries(IEnumerable<ZipVolum
             }
         }
 
-        public void SaveTo(Stream stream)
+        public Task SaveToAsync(Stream stream)
         {
-            SaveTo(stream, new WriterOptions(CompressionType.Deflate));
+            return SaveToAsync(stream, new WriterOptions(CompressionType.Deflate));
         }
 
-        protected override void SaveTo(Stream stream, WriterOptions options,
-                                       IEnumerable<ZipArchiveEntry> oldEntries,
-                                       IEnumerable<ZipArchiveEntry> newEntries)
+        protected override async Task SaveToAsync(Stream stream, WriterOptions options,
+                                            IEnumerable<ZipArchiveEntry> oldEntries,
+                                            IEnumerable<ZipArchiveEntry> newEntries,
+                                            CancellationToken cancellationToken = default)
         {
-            using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
+            await using (var writer = new ZipWriter(stream, new ZipWriterOptions(options)))
             {
                 foreach (var entry in oldEntries.Concat(newEntries)
                                                 .Where(x => !x.IsDirectory))
                 {
-                    using (var entryStream = entry.OpenEntryStream())
+                    await using (var entryStream = entry.OpenEntryStream())
                     {
-                        writer.Write(entry.Key, entryStream, entry.LastModifiedTime);
+                        await writer.WriteAsync(entry.Key, entryStream, entry.LastModifiedTime, cancellationToken);
                     }
                 }
             }

src/SharpCompress/Common/ExtractionMethods.cs

@@ -1,5 +1,7 @@
 using System;
 using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common
 {
@@ -8,10 +10,11 @@ internal static class ExtractionMethods
         /// <summary>
         /// Extract to specific directory, retaining filename
         /// </summary>
-        public static void WriteEntryToDirectory(IEntry entry,
+        public static async ValueTask WriteEntryToDirectoryAsync(IEntry entry,
                                                  string destinationDirectory,
                                                  ExtractionOptions? options,
-                                                 Action<string, ExtractionOptions?> write)
+                                                 Func<string, ExtractionOptions?, CancellationToken, ValueTask> write,
+                                                 CancellationToken cancellationToken = default)
         {
             string destinationFileName;
             string file = Path.GetFileName(entry.Key);
@@ -52,19 +55,20 @@ public static void WriteEntryToDirectory(IEntry entry,
                 {
                     throw new ExtractionException("Entry is trying to write a file outside of the destination directory.");
                 }
-                write(destinationFileName, options);
+                await write(destinationFileName, options, cancellationToken);
             }
             else if (options.ExtractFullPath && !Directory.Exists(destinationFileName))
             {
                 Directory.CreateDirectory(destinationFileName);
             }
         }
 
-        public static void WriteEntryToFile(IEntry entry, string destinationFileName,
+        public static async ValueTask WriteEntryToFileAsync(IEntry entry, string destinationFileName,
                                             ExtractionOptions? options,
-                                            Action<string, FileMode> openAndWrite)
+                                            Func<string, FileMode, CancellationToken, ValueTask> openAndWrite,
+                                            CancellationToken cancellationToken = default)
         {
-            if (entry.LinkTarget != null)
+            if (entry.LinkTarget is not null)
             {
                 if (options?.WriteSymbolicLink is null)
                 {
@@ -85,7 +89,7 @@ public static void WriteEntryToFile(IEntry entry, string destinationFileName,
                     fm = FileMode.CreateNew;
                 }
 
-                openAndWrite(destinationFileName, fm);
+                await openAndWrite(destinationFileName, fm, cancellationToken);
                 entry.PreserveExtractionOptions(destinationFileName, options);
             }
         }

src/SharpCompress/Common/GZip/GZipEntry.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Threading.Tasks;
 
 namespace SharpCompress.Common.GZip
 {
@@ -41,8 +42,9 @@ internal GZipEntry(GZipFilePart filePart)
 
         internal override IEnumerable<FilePart> Parts => _filePart.AsEnumerable<FilePart>();
 
-        internal static IEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
+        internal static async IAsyncEnumerable<GZipEntry> GetEntries(Stream stream, OptionsBase options)
         {
+            await Task.CompletedTask;
             yield return new GZipEntry(new GZipFilePart(stream, options.ArchiveEncoding));
         }
     }