Async add entry

src/SharpCompress/Archives/AbstractWritableArchive.cs

@@ -89,7 +89,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
     public TEntry AddEntry(string key, Stream source, long size = 0, DateTime? modified = null) =>
         AddEntry(key, source, false, size, modified);
 
-    IArchiveEntry IWritableArchiveCommon.AddEntry(
+    IArchiveEntry IWritableArchive.AddEntry(
         string key,
         Stream source,
         bool closeStream,
@@ -97,7 +97,7 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         DateTime? modified
     ) => AddEntry(key, source, closeStream, size, modified);
 
-    IArchiveEntry IWritableArchiveCommon.AddDirectoryEntry(string key, DateTime? modified) =>
+    IArchiveEntry IWritableArchive.AddDirectoryEntry(string key, DateTime? modified) =>
         AddDirectoryEntry(key, modified);
 
     public TEntry AddEntry(
@@ -140,6 +140,65 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return false;
     }
 
+    private async ValueTask<bool> DoesKeyMatchExistingAsync(
+        string key,
+        CancellationToken cancellationToken
+    )
+    {
+        await foreach (
+            var entry in EntriesAsync.WithCancellation(cancellationToken).ConfigureAwait(false)
+        )
+        {
+            var path = entry.Key;
+            if (path is null)
+            {
+                continue;
+            }
+            var p = path.Replace('/', '\\');
+            if (p.Length > 0 && p[0] == '\\')
+            {
+                p = p.Substring(1);
+            }
+            return string.Equals(p, key, StringComparison.OrdinalIgnoreCase);
+        }
+        return false;
+    }
+    async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size,
+        DateTime? modified,
+    CancellationToken cancellationToken
+    ) => await AddEntryAsync(key, source, closeStream, size, modified, cancellationToken);
+
+    async ValueTask<IArchiveEntry> IWritableAsyncArchive.AddDirectoryEntryAsync(string key, DateTime? modified,
+                                                                                CancellationToken cancellationToken) =>
+        await AddDirectoryEntryAsync(key, modified, cancellationToken);
+
+    public async ValueTask<TEntry> AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateEntry(key, source, size, modified, closeStream);
+        newEntries.Add(entry);
+        RebuildModifiedCollection();
+        return entry;
+    }
+
     public TEntry AddDirectoryEntry(string key, DateTime? modified = null)
     {
         if (key.Length > 0 && key[0] is '/' or '\\')
@@ -156,6 +215,26 @@ public abstract class AbstractWritableArchive<TEntry, TVolume>
         return entry;
     }
 
+    public async ValueTask<TEntry> AddDirectoryEntryAsync(
+        string key,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    )
+    {
+        if (key.Length > 0 && key[0] is '/' or '\\')
+        {
+            key = key.Substring(1);
+        }
+        if (await DoesKeyMatchExistingAsync(key, cancellationToken).ConfigureAwait(false))
+        {
+            throw new ArchiveException("Cannot add entry with duplicate key: " + key);
+        }
+        var entry = CreateDirectoryEntry(key, modified);
+        newEntries.Add(entry);
+        RebuildModifiedCollection();
+        return entry;
+    }
+
     public void SaveTo(Stream stream, WriterOptions options)
     {
         //reset streams of new entries

src/SharpCompress/Archives/IWritableArchive.cs

@@ -18,6 +18,10 @@ public interface IWritableArchiveCommon
     /// Removes the specified entry from the archive.
     /// </summary>
     void RemoveEntry(IArchiveEntry entry);
+}
+
+public interface IWritableArchive : IArchive, IWritableArchiveCommon
+{
 
     IArchiveEntry AddEntry(
         string key,
@@ -28,10 +32,7 @@ public interface IWritableArchiveCommon
     );
 
     IArchiveEntry AddDirectoryEntry(string key, DateTime? modified = null);
-}
 
-public interface IWritableArchive : IArchive, IWritableArchiveCommon
-{
     /// <summary>
     /// Saves the archive to the specified stream using the given writer options.
     /// </summary>
@@ -48,4 +49,25 @@ public interface IWritableAsyncArchive : IAsyncArchive, IWritableArchiveCommon
         WriterOptions options,
         CancellationToken cancellationToken = default
     );
+
+    /// <summary>
+    /// Asynchronously adds an entry to the archive with the specified key, source stream, and options.
+    /// </summary>
+    ValueTask<IArchiveEntry> AddEntryAsync(
+        string key,
+        Stream source,
+        bool closeStream,
+        long size = 0,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    );
+
+    /// <summary>
+    /// Asynchronously adds a directory entry to the archive with the specified key and modification time.
+    /// </summary>
+    ValueTask<IArchiveEntry> AddDirectoryEntryAsync(
+        string key,
+        DateTime? modified = null,
+        CancellationToken cancellationToken = default
+    );
 }

src/SharpCompress/Archives/IWritableArchiveCommonExtensions.cs

@@ -1,59 +0,0 @@
-using System;
-using System.IO;
-
-namespace SharpCompress.Archives;
-
-public static class IWritableArchiveCommonExtensions
-{
-    extension(IWritableArchiveCommon writableArchive)
-    {
-        public void AddAllFromDirectory(
-            string filePath,
-            string searchPattern = "*.*",
-            SearchOption searchOption = SearchOption.AllDirectories
-        )
-        {
-            using (writableArchive.PauseEntryRebuilding())
-            {
-                foreach (
-                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
-                )
-                {
-                    var fileInfo = new FileInfo(path);
-                    writableArchive.AddEntry(
-                        path.Substring(filePath.Length),
-                        fileInfo.OpenRead(),
-                        true,
-                        fileInfo.Length,
-                        fileInfo.LastWriteTime
-                    );
-                }
-            }
-        }
-
-        public IArchiveEntry AddEntry(string key, string file) =>
-            writableArchive.AddEntry(key, new FileInfo(file));
-
-        public IArchiveEntry AddEntry(
-            string key,
-            Stream source,
-            long size = 0,
-            DateTime? modified = null
-        ) => writableArchive.AddEntry(key, source, false, size, modified);
-
-        public IArchiveEntry AddEntry(string key, FileInfo fileInfo)
-        {
-            if (!fileInfo.Exists)
-            {
-                throw new ArgumentException("FileInfo does not exist.");
-            }
-            return writableArchive.AddEntry(
-                key,
-                fileInfo.OpenRead(),
-                true,
-                fileInfo.Length,
-                fileInfo.LastWriteTime
-            );
-        }
-    }
-}

src/SharpCompress/Archives/IWritableArchiveExtensions.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using SharpCompress.Common;
 using SharpCompress.Writers;
@@ -8,6 +9,55 @@ public static class IWritableArchiveExtensions
 {
     extension(IWritableArchive writableArchive)
     {
+        public void AddAllFromDirectory(
+            string filePath,
+            string searchPattern = "*.*",
+            SearchOption searchOption = SearchOption.AllDirectories
+        )
+        {
+            using (writableArchive.PauseEntryRebuilding())
+            {
+                foreach (
+                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
+                )
+                {
+                    var fileInfo = new FileInfo(path);
+                    writableArchive.AddEntry(
+                        path.Substring(filePath.Length),
+                        fileInfo.OpenRead(),
+                        true,
+                        fileInfo.Length,
+                        fileInfo.LastWriteTime
+                    );
+                }
+            }
+        }
+
+        public IArchiveEntry AddEntry(string key, string file) =>
+            writableArchive.AddEntry(key, new FileInfo(file));
+
+        public IArchiveEntry AddEntry(
+            string key,
+            Stream source,
+            long size = 0,
+            DateTime? modified = null
+        ) => writableArchive.AddEntry(key, source, false, size, modified);
+
+        public IArchiveEntry AddEntry(string key, FileInfo fileInfo)
+        {
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("FileInfo does not exist.");
+            }
+            return writableArchive.AddEntry(
+                key,
+                fileInfo.OpenRead(),
+                true,
+                fileInfo.Length,
+                fileInfo.LastWriteTime
+            );
+        }
+
         public void SaveTo(string filePath, WriterOptions? options = null) =>
             writableArchive.SaveTo(new FileInfo(filePath), options ?? new(CompressionType.Deflate));
 

src/SharpCompress/Archives/IWritableAsyncArchiveExtensions.cs

@@ -1,3 +1,4 @@
+using System;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
@@ -8,8 +9,59 @@ namespace SharpCompress.Archives;
 
 public static class IWritableAsyncArchiveExtensions
 {
+
     extension(IWritableAsyncArchive writableArchive)
     {
+        public async ValueTask AddAllFromDirectoryAsync(
+            string filePath,
+            string searchPattern = "*.*",
+            SearchOption searchOption = SearchOption.AllDirectories
+        )
+        {
+            using (writableArchive.PauseEntryRebuilding())
+            {
+                foreach (
+                    var path in Directory.EnumerateFiles(filePath, searchPattern, searchOption)
+                )
+                {
+                    var fileInfo = new FileInfo(path);
+                    await writableArchive.AddEntryAsync(
+                        path.Substring(filePath.Length),
+                        fileInfo.OpenRead(),
+                        true,
+                        fileInfo.Length,
+                        fileInfo.LastWriteTime
+                    );
+                }
+            }
+        }
+
+        public ValueTask<IArchiveEntry> AddEntryAsync(string key, string file) =>
+            writableArchive.AddEntryAsync(key, new FileInfo(file));
+
+        public ValueTask<IArchiveEntry> AddEntryAsync(
+            string key,
+            Stream source,
+            long size = 0,
+            DateTime? modified = null
+        ) => writableArchive.AddEntryAsync(key, source, false, size, modified);
+
+        public ValueTask<IArchiveEntry> AddEntryAsync(string key, FileInfo fileInfo)
+        {
+            if (!fileInfo.Exists)
+            {
+                throw new ArgumentException("FileInfo does not exist.");
+            }
+            return writableArchive.AddEntryAsync(
+                key,
+                fileInfo.OpenRead(),
+                true,
+                fileInfo.Length,
+                fileInfo.LastWriteTime
+            );
+        }
+    
+
         public ValueTask SaveToAsync(
             string filePath,
             WriterOptions? options = null,