From 38203fb950fbd35fca55a512d0f040e3ee3e5ca0 Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Mon, 12 Jan 2026 14:14:46 +0000 Subject: [PATCH] Fix async reader variable types - Remove double await on ReaderFactory.OpenAsync and use IAsyncReader - Removed 'await' keyword before ReaderFactory.OpenAsync() calls since the method returns IAsyncReader directly (not Task) - Changed ZipReader.Open() to ReaderFactory.OpenAsync() in Zip64AsyncTests.ReadForwardOnlyAsync() - Changed TarReader.Open() to ReaderFactory.OpenAsync() in TarReaderAsyncTests.Tar_BZip2_Entry_Stream_Async() - Fixed EntryStream disposal from 'await using' to 'using' since EntryStream doesn't implement IAsyncDisposable - These changes fix compilation errors where async methods were being called on IReader (synchronous) instead of IAsyncReader (asynchronous) --- src/SharpCompress/Archives/IArchiveFactory.cs | 5 +- .../Archives/IMultiArchiveFactory.cs | 5 +- .../Polyfills/AsyncEnumerableExtensions.cs | 99 ++++++++++++------- tests/SharpCompress.Test/GZip/AsyncTests.cs | 18 ++-- .../GZip/GZipArchiveAsyncTests.cs | 42 +++++--- .../GZip/GZipReaderAsyncTests.cs | 4 +- .../SharpCompress.Test/ProgressReportTests.cs | 5 +- .../Rar/RarReaderAsyncTests.cs | 10 +- tests/SharpCompress.Test/ReaderTests.cs | 2 +- .../Tar/TarReaderAsyncTests.cs | 10 +- tests/SharpCompress.Test/WriterTests.cs | 2 +- .../SharpCompress.Test/Zip/Zip64AsyncTests.cs | 35 ++++--- .../Zip/ZipArchiveAsyncTests.cs | 64 ++++++++---- .../Zip/ZipReaderAsyncTests.cs | 8 +- 14 files changed, 182 insertions(+), 127 deletions(-) diff --git a/src/SharpCompress/Archives/IArchiveFactory.cs b/src/SharpCompress/Archives/IArchiveFactory.cs index 3271f16d..b94128d6 100644 --- a/src/SharpCompress/Archives/IArchiveFactory.cs +++ b/src/SharpCompress/Archives/IArchiveFactory.cs @@ -32,10 +32,7 @@ public interface IArchiveFactory : IFactory /// /// An open, readable and seekable stream. /// reading options. - IAsyncArchive OpenAsync( - Stream stream, - ReaderOptions? readerOptions = null - ); + IAsyncArchive OpenAsync(Stream stream, ReaderOptions? readerOptions = null); /// /// Constructor with a FileInfo object to an existing file. diff --git a/src/SharpCompress/Archives/IMultiArchiveFactory.cs b/src/SharpCompress/Archives/IMultiArchiveFactory.cs index d74ffb4a..e0064cc0 100644 --- a/src/SharpCompress/Archives/IMultiArchiveFactory.cs +++ b/src/SharpCompress/Archives/IMultiArchiveFactory.cs @@ -33,10 +33,7 @@ public interface IMultiArchiveFactory : IFactory /// /// /// reading options. - IAsyncArchive OpenAsync( - IReadOnlyList streams, - ReaderOptions? readerOptions = null - ); + IAsyncArchive OpenAsync(IReadOnlyList streams, ReaderOptions? readerOptions = null); /// /// Constructor with IEnumerable Stream objects, multi and split support. diff --git a/src/SharpCompress/Polyfills/AsyncEnumerableExtensions.cs b/src/SharpCompress/Polyfills/AsyncEnumerableExtensions.cs index 1d4d9d5a..7ce90ded 100644 --- a/src/SharpCompress/Polyfills/AsyncEnumerableExtensions.cs +++ b/src/SharpCompress/Polyfills/AsyncEnumerableExtensions.cs @@ -39,7 +39,9 @@ public static class AsyncEnumerableExtensions return list; } - public static async IAsyncEnumerable CastAsync(this IAsyncEnumerable source) + public static async IAsyncEnumerable CastAsync( + this IAsyncEnumerable source + ) where TResult : class { await foreach (var item in source) @@ -62,49 +64,74 @@ public static class AsyncEnumerableExtensions return result; } - extension(IAsyncEnumerable source) + public static async ValueTask AllAsync( + this IAsyncEnumerable source, + Func predicate + ) { - public async ValueTask AllAsync(Func predicate) + await foreach (var item in source) { - await foreach (var item in source) + if (!predicate(item)) { - if (!predicate(item)) - { - return false; - } - } - - return true; - } - - public async IAsyncEnumerable WhereAsync(Func predicate) - { - await foreach (var item in source) - { - if (predicate(item)) - { - yield return item; - } + return false; } } - public async ValueTask FirstAsync() - { - await foreach (var item in source) - { - return item; - } - throw new InvalidOperationException("The source sequence is empty."); - } + return true; + } - public async ValueTask FirstOrDefaultAsync() - { - await foreach (var item in source) - { - return item; - } + public static IAsyncEnumerable Where( + this IAsyncEnumerable source, + Func predicate + ) + { + return WhereIterator(source, predicate); + } - return default; + private static async IAsyncEnumerable WhereIterator( + IAsyncEnumerable source, + Func predicate + ) + { + await foreach (var item in source) + { + if (predicate(item)) + { + yield return item; + } } } + + public static async IAsyncEnumerable WhereAsync( + this IAsyncEnumerable source, + Func predicate + ) + { + await foreach (var item in source) + { + if (predicate(item)) + { + yield return item; + } + } + } + + public static async ValueTask FirstAsync(this IAsyncEnumerable source) + { + await foreach (var item in source) + { + return item; + } + throw new InvalidOperationException("The source sequence is empty."); + } + + public static async ValueTask FirstOrDefaultAsync(this IAsyncEnumerable source) + { + await foreach (var item in source) + { + return item; + } + + return default; + } } diff --git a/tests/SharpCompress.Test/GZip/AsyncTests.cs b/tests/SharpCompress.Test/GZip/AsyncTests.cs index d000798e..fabdafc0 100644 --- a/tests/SharpCompress.Test/GZip/AsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/AsyncTests.cs @@ -26,7 +26,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); await reader.WriteAllToDirectoryAsync( SCRATCH_FILES_PATH, @@ -51,7 +51,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); while (await reader.MoveToNextEntryAsync()) { @@ -103,12 +103,8 @@ public class AsyncTests : TestBase #else await using (var stream = File.Create(outputPath)) #endif - await using ( - var writer = await WriterFactory.OpenAsync( - stream, - ArchiveType.Zip, - CompressionType.Deflate - ) + using ( + var writer = WriterFactory.OpenAsync(stream, ArchiveType.Zip, CompressionType.Deflate) ) { var testFile = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"); @@ -123,7 +119,7 @@ public class AsyncTests : TestBase // Verify the archive was created and contains the entry Assert.True(File.Exists(outputPath)); - await using var archive = await ZipArchive.OpenAsync(outputPath); + await using var archive = ZipArchive.OpenAsync(outputPath); Assert.Single(await archive.EntriesAsync.WhereAsync(e => !e.IsDirectory).ToListAsync()); } @@ -139,7 +135,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = await ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(stream), cancellationToken: cts.Token ); @@ -193,7 +189,7 @@ public class AsyncTests : TestBase #else await using var stream = File.OpenRead(testArchive); #endif - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); while (await reader.MoveToNextEntryAsync()) { diff --git a/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs index 004d4ba8..6b27aa50 100644 --- a/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipArchiveAsyncTests.cs @@ -47,17 +47,24 @@ public class GZipArchiveAsyncTests : ArchiveTests #else await using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz"))) #endif - await using (var archive = await GZipArchive.OpenAsync(stream)) { - var entry = await archive.EntriesAsync.FirstAsync(); - await entry.WriteToFileAsync(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); + IAsyncArchive archive = await GZipArchive.OpenAsync(stream); + try + { + var entry = await archive.EntriesAsync.FirstAsync(); + await entry.WriteToFileAsync(Path.Combine(SCRATCH_FILES_PATH, entry.Key.NotNull())); - var size = entry.Size; - var scratch = new FileInfo(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar")); - var test = new FileInfo(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); + var size = entry.Size; + var scratch = new FileInfo(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar")); + var test = new FileInfo(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")); - Assert.Equal(size, scratch.Length); - Assert.Equal(size, test.Length); + Assert.Equal(size, scratch.Length); + Assert.Equal(size, test.Length); + } + finally + { + archive.DisposeAsync().AsTask().Wait(); + } } CompareArchivesByPath( Path.Combine(SCRATCH_FILES_PATH, "Tar.tar"), @@ -74,11 +81,18 @@ public class GZipArchiveAsyncTests : ArchiveTests #else await using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); #endif - await using var archive = await GZipArchive.OpenAsync(stream); - await Assert.ThrowsAsync(() => - archive.AddEntry("jpg\\test.jpg", jpg) - ); - await archive.SaveToAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")); + IAsyncArchive archive = await GZipArchive.OpenAsync(stream); + try + { + await Assert.ThrowsAsync(() => + archive.AddEntry("jpg\\test.jpg", jpg) + ); + await archive.SaveToAsync(Path.Combine(SCRATCH_FILES_PATH, "Tar.tar.gz")); + } + finally + { + await archive.DisposeAsync(); + } } [Fact] @@ -95,7 +109,7 @@ public class GZipArchiveAsyncTests : ArchiveTests inputStream.Position = 0; } - await using var archive = GZipArchive.Open(inputStream); + using var archive = GZipArchive.Open(inputStream); var archiveEntry = archive.Entries.First(); MemoryStream tarStream; diff --git a/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs b/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs index befd1440..58f5d9dc 100644 --- a/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/GZip/GZipReaderAsyncTests.cs @@ -22,7 +22,7 @@ public class GZipReaderAsyncTests : ReaderTests { //read only as GZip item using Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.gz")); - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); while (await reader.MoveToNextEntryAsync()) { Assert.NotEqual(0, reader.Entry.Size); @@ -70,7 +70,7 @@ public class GZipReaderAsyncTests : ReaderTests bufferSize: options.BufferSize ); using var testStream = new TestStream(protectedStream); - await using (var reader = await ReaderFactory.OpenAsync(testStream, options, default)) + await using (var reader = ReaderFactory.OpenAsync(testStream, options, default)) { await UseReaderAsync(reader, expectedCompression); protectedStream.ThrowOnDispose = false; diff --git a/tests/SharpCompress.Test/ProgressReportTests.cs b/tests/SharpCompress.Test/ProgressReportTests.cs index 2f0dd802..f2c7121e 100644 --- a/tests/SharpCompress.Test/ProgressReportTests.cs +++ b/tests/SharpCompress.Test/ProgressReportTests.cs @@ -541,10 +541,7 @@ public class ProgressReportTests : TestBase var readerOptions = new ReaderOptions { Progress = progress }; await using ( - var reader = await ReaderFactory.OpenAsync( - new AsyncOnlyStream(archiveStream), - readerOptions - ) + var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(archiveStream), readerOptions) ) { while (await reader.MoveToNextEntryAsync()) diff --git a/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs b/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs index 6fd78314..0de82da5 100644 --- a/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Rar/RarReaderAsyncTests.cs @@ -205,7 +205,7 @@ public class RarReaderAsyncTests : ReaderTests private async ValueTask DoRar_Entry_Stream_Async(string filename) { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename))) - await using (var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream))) + await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream))) { while (await reader.MoveToNextEntryAsync()) { @@ -250,7 +250,7 @@ public class RarReaderAsyncTests : ReaderTests var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Rar.Audio_program.rar")) ) await using ( - var reader = await ReaderFactory.OpenAsync( + var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ) @@ -316,7 +316,7 @@ public class RarReaderAsyncTests : ReaderTests private async ValueTask DoRar_Solid_Skip_Reader_Async(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - await using var reader = await ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ); @@ -342,7 +342,7 @@ public class RarReaderAsyncTests : ReaderTests private async ValueTask DoRar_Reader_Skip_Async(string filename) { using var stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, filename)); - await using var reader = await ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ); @@ -367,7 +367,7 @@ public class RarReaderAsyncTests : ReaderTests { testArchive = Path.Combine(TEST_ARCHIVES_PATH, testArchive); using Stream stream = File.OpenRead(testArchive); - await using var reader = await ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(stream), readerOptions ?? new ReaderOptions() ); diff --git a/tests/SharpCompress.Test/ReaderTests.cs b/tests/SharpCompress.Test/ReaderTests.cs index 67c4371c..cb1dac03 100644 --- a/tests/SharpCompress.Test/ReaderTests.cs +++ b/tests/SharpCompress.Test/ReaderTests.cs @@ -146,7 +146,7 @@ public abstract class ReaderTests : TestBase ); using var testStream = new TestStream(protectedStream); await using ( - var reader = await ReaderFactory.OpenAsync( + var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(testStream), options, cancellationToken diff --git a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs index 4be59584..1a18f3ce 100644 --- a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs @@ -23,7 +23,7 @@ public class TarReaderAsyncTests : ReaderTests using Stream stream = new ForwardOnlyStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar")) ); - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); var x = 0; while (await reader.MoveToNextEntryAsync()) { @@ -73,7 +73,7 @@ public class TarReaderAsyncTests : ReaderTests public async ValueTask Tar_BZip2_Entry_Stream_Async() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar.bz2"))) - using (var reader = TarReader.Open(stream)) + await using (var reader = ReaderFactory.OpenAsync(stream)) { while (await reader.MoveToNextEntryAsync()) { @@ -184,7 +184,7 @@ public class TarReaderAsyncTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "Tar.tar"); using Stream stream = File.OpenRead(archiveFullPath); - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); var memoryStream = new MemoryStream(); Assert.True(await reader.MoveToNextEntryAsync()); @@ -201,7 +201,7 @@ public class TarReaderAsyncTests : ReaderTests { var archiveFullPath = Path.Combine(TEST_ARCHIVES_PATH, "TarCorrupted.tar"); using Stream stream = File.OpenRead(archiveFullPath); - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); var memoryStream = new MemoryStream(); Assert.True(await reader.MoveToNextEntryAsync()); @@ -220,7 +220,7 @@ public class TarReaderAsyncTests : ReaderTests using Stream stream = File.OpenRead( Path.Combine(TEST_ARCHIVES_PATH, "TarWithSymlink.tar.gz") ); - await using var reader = await ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(stream), new ReaderOptions { LookForHeader = true } ); diff --git a/tests/SharpCompress.Test/WriterTests.cs b/tests/SharpCompress.Test/WriterTests.cs index 984d3b91..9a6a43de 100644 --- a/tests/SharpCompress.Test/WriterTests.cs +++ b/tests/SharpCompress.Test/WriterTests.cs @@ -92,7 +92,7 @@ public class WriterTests : TestBase readerOptions.ArchiveEncoding.Default = encoding ?? Encoding.Default; - await using var reader = await ReaderFactory.OpenAsync( + await using var reader = ReaderFactory.OpenAsync( new AsyncOnlyStream(SharpCompressStream.Create(stream, leaveOpen: true)), readerOptions, cancellationToken diff --git a/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs b/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs index 2c943553..eab7e1c7 100644 --- a/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/Zip64AsyncTests.cs @@ -198,28 +198,31 @@ public class Zip64AsyncTests : WriterTests long size = 0; ZipEntry? prev = null; using (var fs = File.OpenRead(filename)) - using (var rd = ZipReader.Open(fs, new ReaderOptions { LookForHeader = false })) { - while (await rd.MoveToNextEntryAsync()) + var rd = ReaderFactory.OpenAsync(fs, new ReaderOptions { LookForHeader = false }); + await using (rd) { + while (await rd.MoveToNextEntryAsync()) + { #if NETFRAMEWORK || NETSTANDARD2_0 - using (var entryStream = await rd.OpenEntryStreamAsync()) - { - await entryStream.SkipEntryAsync(); - } + using (var entryStream = await rd.OpenEntryStreamAsync()) + { + await entryStream.SkipEntryAsync(); + } #else - await using (var entryStream = await rd.OpenEntryStreamAsync()) - { - await entryStream.SkipEntryAsync(); - } + await using (var entryStream = await rd.OpenEntryStreamAsync()) + { + await entryStream.SkipEntryAsync(); + } #endif - count++; - if (prev != null) - { - size += prev.Size; - } + count++; + if (prev != null) + { + size += prev.Size; + } - prev = rd.Entry; + prev = (ZipEntry)rd.Entry; + } } } diff --git a/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs index 41420f98..ffec6efc 100644 --- a/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipArchiveAsyncTests.cs @@ -3,6 +3,7 @@ using System.IO; using System.Linq; using System.Text; using System.Threading.Tasks; +using SharpCompress; using SharpCompress.Archives; using SharpCompress.Archives.Zip; using SharpCompress.Common; @@ -125,8 +126,9 @@ public class ZipArchiveAsyncTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip"); - using (var archive = ZipArchive.Open(unmodified)) + using (IArchive baseArchive = ZipArchive.Open(unmodified)) { + IWritableArchive archive = (IWritableArchive)baseArchive; var entry = archive.Entries.Single(x => x.Key.NotNull().EndsWith("jpg", StringComparison.OrdinalIgnoreCase) ); @@ -148,8 +150,9 @@ public class ZipArchiveAsyncTests : ArchiveTests var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.mod.zip"); var modified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - using (var archive = ZipArchive.Open(unmodified)) + using (IArchive baseArchive = ZipArchive.Open(unmodified)) { + IWritableArchive archive = (IWritableArchive)baseArchive; archive.AddEntry("jpg\\test.jpg", jpg); WriterOptions writerOptions = new ZipWriterOptions(CompressionType.Deflate); @@ -166,7 +169,7 @@ public class ZipArchiveAsyncTests : ArchiveTests var scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Zip.deflate.noEmptyDirs.zip"); var unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.noEmptyDirs.zip"); - using (var archive = ZipArchive.Create()) + using (ZipArchive archive = ZipArchive.Create()) { archive.DeflateCompressionLevel = CompressionLevel.BestSpeed; archive.AddAllFromDirectory(ORIGINAL_FILES_PATH); @@ -183,14 +186,21 @@ public class ZipArchiveAsyncTests : ArchiveTests public async ValueTask Zip_Deflate_Entry_Stream_Async() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) - await using (var archive = await ZipArchive.OpenAsync(new AsyncOnlyStream(stream))) { - await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) + IAsyncArchive archive = ZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + try { - await entry.WriteToDirectoryAsync( - SCRATCH_FILES_PATH, - new ExtractionOptions { ExtractFullPath = true, Overwrite = true } - ); + await foreach (var entry in archive.EntriesAsync.Where(entry => !entry.IsDirectory)) + { + await entry.WriteToDirectoryAsync( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true } + ); + } + } + finally + { + await archive.DisposeAsync(); } } VerifyFiles(); @@ -200,12 +210,19 @@ public class ZipArchiveAsyncTests : ArchiveTests public async ValueTask Zip_Deflate_Archive_WriteToDirectoryAsync() { using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) - await using (var archive = await ZipArchive.OpenAsync(new AsyncOnlyStream(stream))) { - await archive.WriteToDirectoryAsync( - SCRATCH_FILES_PATH, - new ExtractionOptions { ExtractFullPath = true, Overwrite = true } - ); + IAsyncArchive archive = ZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + try + { + await archive.WriteToDirectoryAsync( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true } + ); + } + finally + { + await archive.DisposeAsync(); + } } VerifyFiles(); } @@ -217,13 +234,20 @@ public class ZipArchiveAsyncTests : ArchiveTests var progress = new Progress(report => progressReports.Add(report)); using (Stream stream = File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.zip"))) - await using (var archive = await ZipArchive.OpenAsync(new AsyncOnlyStream(stream))) { - await archive.WriteToDirectoryAsync( - SCRATCH_FILES_PATH, - new ExtractionOptions { ExtractFullPath = true, Overwrite = true }, - progress - ); + IAsyncArchive archive = ZipArchive.OpenAsync(new AsyncOnlyStream(stream)); + try + { + await archive.WriteToDirectoryAsync( + SCRATCH_FILES_PATH, + new ExtractionOptions { ExtractFullPath = true, Overwrite = true }, + progress + ); + } + finally + { + await archive.DisposeAsync(); + } } VerifyFiles(); diff --git a/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs b/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs index 33a673f4..9d5f4da9 100644 --- a/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Zip/ZipReaderAsyncTests.cs @@ -20,7 +20,7 @@ public class ZipReaderAsyncTests : ReaderTests { var path = Path.Combine(TEST_ARCHIVES_PATH, "PrePostHeaders.zip"); using Stream stream = new ForwardOnlyStream(File.OpenRead(path)); - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); var count = 0; while (await reader.MoveToNextEntryAsync()) { @@ -65,7 +65,7 @@ public class ZipReaderAsyncTests : ReaderTests using Stream stream = new ForwardOnlyStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - await using var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); + await using var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream)); var x = 0; while (await reader.MoveToNextEntryAsync()) { @@ -144,7 +144,7 @@ public class ZipReaderAsyncTests : ReaderTests using var stream = new TestStream( File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ); - await using (var reader = await ReaderFactory.OpenAsync(new AsyncOnlyStream(stream))) + await using (var reader = ReaderFactory.OpenAsync(new AsyncOnlyStream(stream))) { while (await reader.MoveToNextEntryAsync()) { @@ -168,7 +168,7 @@ public class ZipReaderAsyncTests : ReaderTests File.OpenRead(Path.Combine(TEST_ARCHIVES_PATH, "Zip.deflate.dd.zip")) ) ); - await using var reader = await ReaderFactory.OpenAsync(stream); + await using var reader = ReaderFactory.OpenAsync(stream); while (await reader.MoveToNextEntryAsync()) { if (!reader.Entry.IsDirectory)