feat(IZipArchiveService): compatible with older versions

src/BootstrapBlazor.Server/Components/Samples/ZipArchives.razor

@@ -1,4 +1,4 @@
-@page "/zip-archive"
+@page "/zip-archive"
 @layout MainLayout
 @inject IStringLocalizer<ZipArchives> Localizer
 
@@ -13,10 +13,14 @@ private IZipArchiveService? ZipArchiveService { get; set; }</Pre>
 <p>@Localizer["ZipArchiveFileText"]</p>
 <Pre class="mb-3">Task&lt;Stream&gt; ArchiveAsync(IEnumerable&lt;string&gt; files, ArchiveOptions? options = null);
 
-Task ArchiveAsync(string archiveFileName, IEnumerable&lt;string&gt; files, ArchiveOptions? options = null);</Pre>
+Task ArchiveAsync(string archiveFile, IEnumerable&lt;string&gt; files, ArchiveOptions? options = null);
+
+Task&lt;Stream&gt; ArchiveAsync(IEnumerable&lt;ArchiveEntry&gt; entries, ArchiveOptions? options = null);
+
+Task ArchiveAsync(string archiveFile, IEnumerable&lt;ArchiveEntry&gt; entries, ArchiveOptions? options = null);</Pre>
 
 <p>@Localizer["ZipArchiveDirectoryText"]</p>
-<Pre class="mb-3">Task ArchiveDirectory(string archiveFileName, string directoryName, CompressionLevel compressionLevel = CompressionLevel.Optimal, bool includeBaseDirectory = false, Encoding? encoding = null);</Pre>
+<Pre class="mb-3">Task ArchiveDirectoryAsync(string archiveFile, string directoryName, CompressionLevel compressionLevel = CompressionLevel.Optimal, bool includeBaseDirectory = false, Encoding? encoding = null);</Pre>
 
 <p>@Localizer["ZipArchiveExtractText"]</p>
-<Pre class="mb-3">bool ExtractToDirectory(string archiveFile, string destinationDirectoryName, bool overwriteFiles = false, Encoding? encoding = null);</Pre>
+<Pre class="mb-3">Task&lt;bool&gt; ExtractToDirectoryAsync(string archiveFile, string destinationDirectoryName, bool overwriteFiles = false, Encoding? encoding = null);</Pre>

src/BootstrapBlazor/Services/DefaultZipArchiveService.cs

@@ -10,6 +10,24 @@ namespace BootstrapBlazor.Components;
 
 class DefaultZipArchiveService : IZipArchiveService
 {
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    public Task<Stream> ArchiveAsync(IEnumerable<string> files, ArchiveOptions? options = null) => ArchiveAsync(files.Select(f => new ArchiveEntry()
+    {
+        SourceFileName = f,
+        EntryName = Path.GetFileName(f),
+    }), options);
+
+    /// <summary>
+    /// <inheritdoc/>
+    /// </summary>
+    public Task ArchiveAsync(string archiveFile, IEnumerable<string> files, ArchiveOptions? options = null) => ArchiveAsync(archiveFile, files.Select(f => new ArchiveEntry()
+    {
+        SourceFileName = f,
+        EntryName = Path.GetFileName(f),
+    }), options);
+
     /// <summary>
     /// <inheritdoc/>
     /// </summary>
@@ -28,7 +46,7 @@ public async Task<Stream> ArchiveAsync(IEnumerable<ArchiveEntry> entries, Archiv
     /// </summary>
     public async Task ArchiveAsync(string archiveFile, IEnumerable<ArchiveEntry> entries, ArchiveOptions? options = null)
     {
-        using var stream = File.OpenWrite(archiveFile);
+        await using var stream = File.OpenWrite(archiveFile);
         await ArchiveFilesAsync(stream, entries, options);
     }
 
@@ -38,6 +56,11 @@ private static async Task ArchiveFilesAsync(Stream stream, IEnumerable<ArchiveEn
         using var archive = new ZipArchive(stream, options.Mode, options.LeaveOpen, options.Encoding);
         foreach (var f in entries)
         {
+            if (string.IsNullOrEmpty(f.EntryName))
+            {
+                continue;
+            }
+
             if (options.ReadStreamAsync != null)
             {
                 var entry = archive.CreateEntry(f.EntryName, options.CompressionLevel);
@@ -48,14 +71,13 @@ private static async Task ArchiveFilesAsync(Stream stream, IEnumerable<ArchiveEn
             else if (Directory.Exists(f.SourceFileName))
             {
                 var entryName = f.EntryName;
-                if (!string.IsNullOrEmpty(entryName))
+
+                if (!entryName.EndsWith('/'))
                 {
-                    if (!entryName.EndsWith('/'))
-                    {
-                        entryName = $"{entryName}/";
-                    }
-                    archive.CreateEntry(entryName, f.CompressionLevel ?? options.CompressionLevel);
+                    entryName = $"{entryName}/";
                 }
+
+                archive.CreateEntry(entryName, f.CompressionLevel ?? options.CompressionLevel);
             }
             else if (File.Exists(f.SourceFileName))
             {

src/BootstrapBlazor/Services/IZipArchiveService.cs

@@ -13,6 +13,22 @@ namespace BootstrapBlazor.Components;
 /// </summary>
 public interface IZipArchiveService
 {
+    /// <summary>
+    /// 将文件归档方法
+    /// </summary>
+    /// <param name="files">要归档的文件集合</param>
+    /// <param name="options">归档配置</param>
+    /// <returns>归档数据流</returns>
+    Task<Stream> ArchiveAsync(IEnumerable<string> files, ArchiveOptions? options = null);
+
+    /// <summary>
+    /// 将文件归档方法
+    /// </summary>
+    /// <param name="archiveFile">归档文件</param>
+    /// <param name="files">要归档的文件集合</param>
+    /// <param name="options">归档配置</param>
+    Task ArchiveAsync(string archiveFile, IEnumerable<string> files, ArchiveOptions? options = null);
+
     /// <summary>
     /// 将文件归档方法
     /// </summary>

test/UnitTest/Services/ZipArchiveServiceTest.cs

@@ -14,7 +14,7 @@ public async Task Archive_Ok()
     {
         var archService = Context.Services.GetRequiredService<IZipArchiveService>();
         var root = AppContext.BaseDirectory;
-        var files = new string[]
+        var files = new[]
         {
             Path.Combine(root, "1.txt"),
             Path.Combine(root, "2.txt")
@@ -28,16 +28,16 @@ public async Task Archive_Ok()
         {
             SourceFileName = i,
             EntryName = Path.GetFileName(i)
-        });
+        }).ToList();
         var stream = await archService.ArchiveAsync(items);
         Assert.NotNull(stream);
 
         stream = await archService.ArchiveAsync(items, new ArchiveOptions()
         {
-            CompressionLevel = System.IO.Compression.CompressionLevel.Optimal,
+            CompressionLevel = CompressionLevel.Optimal,
             Encoding = System.Text.Encoding.UTF8,
-            Mode = System.IO.Compression.ZipArchiveMode.Create,
-            ReadStreamAsync = f => Task.FromResult<Stream>(new MemoryStream("A"u8.ToArray()))
+            Mode = ZipArchiveMode.Create,
+            ReadStreamAsync = _ => Task.FromResult<Stream>(new MemoryStream("A"u8.ToArray()))
         });
         Assert.NotNull(stream);
 
@@ -93,8 +93,8 @@ public async Task ZipArchive_Ok()
             File.Delete(fileName);
         }
 
-        using var fs = File.OpenWrite(fileName);
-        using var zip = new ZipArchive(fs, ZipArchiveMode.Create);
+        await using var fs = File.OpenWrite(fileName);
+        await using var zip = new ZipArchive(fs, ZipArchiveMode.Create);
 
         var item = Path.Combine(AppContext.BaseDirectory, "test", "1.txt");
         zip.CreateEntry("text/");
@@ -111,7 +111,7 @@ public async Task ArchiveAsync_Ok()
         }
 
         var root = AppContext.BaseDirectory;
-        var files = new string[]
+        var files = new[]
         {
             Path.Combine(root, "archive_test", "test1", "1.txt"),
             Path.Combine(root, "archive_test", "test2", "2.txt")
@@ -130,30 +130,54 @@ public async Task ArchiveAsync_Ok()
         var archService = Context.Services.GetRequiredService<IZipArchiveService>();
         await archService.ArchiveAsync(fileName, new List<ArchiveEntry>()
         {
-            new ArchiveEntry()
+            new()
             {
                 SourceFileName = files[0],
                 EntryName = "test1/test.log"
             },
-            new ArchiveEntry()
+            new()
             {
                 SourceFileName = files[1],
                 EntryName = "test2/test.log",
                 CompressionLevel = CompressionLevel.Optimal
             },
-            new ArchiveEntry()
+            new()
             {
                 SourceFileName = Path.Combine(AppContext.BaseDirectory, "archive_test", "test1"),
                 EntryName = "test1",
             },
-            new ArchiveEntry()
+            new()
             {
                 SourceFileName = Path.Combine(AppContext.BaseDirectory, "archive_test", "test1"),
                 EntryName = "test2",
                 CompressionLevel = CompressionLevel.Optimal
+            },
+            new()
+            {
+                SourceFileName = files[1]
             }
         });
 
         Assert.True(File.Exists(fileName));
+
+        if (File.Exists(fileName))
+        {
+            File.Delete(fileName);
+        }
+        Assert.False(File.Exists(fileName));
+        await archService.ArchiveAsync(fileName, new List<string>()
+        {
+            Path.Combine(AppContext.BaseDirectory, "archive_test", "test1", "test.log"),
+            Path.Combine(AppContext.BaseDirectory, "archive_test", "test2", "test.log")
+        });
+        Assert.True(File.Exists(fileName));
+
+        await using var stream = await archService.ArchiveAsync(new List<string>()
+        {
+            Path.Combine(AppContext.BaseDirectory, "archive_test", "test1", "test.log"),
+            Path.Combine(AppContext.BaseDirectory, "archive_test", "test2", "test.log")
+        });
+        Assert.NotNull(stream);
+        Assert.True(stream.Length != 0);
     }
 }