From 9dbe3c7aca4eceb3f21b421a667c2a5cb3cd47a8 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 14 May 2026 15:51:19 +0000 Subject: [PATCH 1/5] Initial plan From 2d5c2210e7a74299af195493c18e65c512d7af22 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 14 May 2026 16:06:09 +0000 Subject: [PATCH 2/5] Fix tar archive enumeration after fully reading entry streams Agent-Logs-Url: https://github.com/adamhathcock/sharpcompress/sessions/e5d578fd-e9cd-4c00-bbe7-2f77a394926c Co-authored-by: adamhathcock <527620+adamhathcock@users.noreply.github.com> --- .../Common/Tar/TarReadOnlySubStream.cs | 112 ++++++++++++++---- .../SharpCompress.Test/Tar/TarArchiveTests.cs | 57 +++++++++ 2 files changed, 144 insertions(+), 25 deletions(-) diff --git a/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs b/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs index 987751a34..bc3408dfe 100644 --- a/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs +++ b/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs @@ -1,5 +1,6 @@ using System; using System.IO; +using System.Threading.Tasks; namespace SharpCompress.Common.Tar; @@ -8,6 +9,7 @@ internal class TarReadOnlySubStream : Stream private readonly Stream _stream; private bool _isDisposed; + private bool _isPositionedAtNextEntry; private long _amountRead; public TarReadOnlySubStream(Stream stream, long bytesToRead, bool useSyncOverAsyncDispose) @@ -27,27 +29,17 @@ protected override void Dispose(bool disposing) _isDisposed = true; if (disposing) { - // Ensure we read all remaining blocks for this entry. - _stream.Skip(BytesLeftToRead); - _amountRead += BytesLeftToRead; - - // If the last block wasn't a full 512 bytes, skip the remaining padding bytes. - var bytesInLastBlock = _amountRead % 512; - - if (bytesInLastBlock != 0) + if (Utility.UseSyncOverAsyncDispose()) { - if (Utility.UseSyncOverAsyncDispose()) - { #pragma warning disable VSTHRD002 // Avoid problematic synchronous waits #pragma warning disable CA2012 - _stream.SkipAsync(512 - bytesInLastBlock).GetAwaiter().GetResult(); + AdvanceToNextHeaderAsync().GetAwaiter().GetResult(); #pragma warning restore CA2012 #pragma warning restore VSTHRD002 // Avoid problematic synchronous waits - } - else - { - _stream.Skip(512 - bytesInLastBlock); - } + } + else + { + AdvanceToNextHeader(); } } base.Dispose(disposing); @@ -63,24 +55,62 @@ public override async System.Threading.Tasks.ValueTask DisposeAsync() } _isDisposed = true; - // Ensure we read all remaining blocks for this entry. - await _stream.SkipAsync(BytesLeftToRead).ConfigureAwait(false); - _amountRead += BytesLeftToRead; + await AdvanceToNextHeaderAsync().ConfigureAwait(false); + + GC.SuppressFinalize(this); + await base.DisposeAsync().ConfigureAwait(false); + } +#endif + + private long BytesLeftToRead { get; set; } + + private void AdvanceToNextHeader() + { + if (_isPositionedAtNextEntry) + { + return; + } + + if (BytesLeftToRead > 0) + { + _stream.Skip(BytesLeftToRead); + _amountRead += BytesLeftToRead; + BytesLeftToRead = 0; + } - // If the last block wasn't a full 512 bytes, skip the remaining padding bytes. + // Tar entry data is padded to 512-byte blocks, so callers that read to EOF + // should still leave the shared archive stream positioned at the next header. var bytesInLastBlock = _amountRead % 512; + if (bytesInLastBlock != 0) + { + _stream.Skip(512 - bytesInLastBlock); + } + + _isPositionedAtNextEntry = true; + } + + private async ValueTask AdvanceToNextHeaderAsync() + { + if (_isPositionedAtNextEntry) + { + return; + } + + if (BytesLeftToRead > 0) + { + await _stream.SkipAsync(BytesLeftToRead).ConfigureAwait(false); + _amountRead += BytesLeftToRead; + BytesLeftToRead = 0; + } + var bytesInLastBlock = _amountRead % 512; if (bytesInLastBlock != 0) { await _stream.SkipAsync(512 - bytesInLastBlock).ConfigureAwait(false); } - GC.SuppressFinalize(this); - await base.DisposeAsync().ConfigureAwait(false); + _isPositionedAtNextEntry = true; } -#endif - - private long BytesLeftToRead { get; set; } public override bool CanRead => true; @@ -104,6 +134,11 @@ public override long Position public override int Read(byte[] buffer, int offset, int count) { + if (BytesLeftToRead <= 0) + { + AdvanceToNextHeader(); + return 0; + } if (BytesLeftToRead < count) { count = (int)BytesLeftToRead; @@ -113,6 +148,10 @@ public override int Read(byte[] buffer, int offset, int count) { BytesLeftToRead -= read; _amountRead += read; + if (BytesLeftToRead == 0) + { + AdvanceToNextHeader(); + } } return read; } @@ -121,6 +160,7 @@ public override int ReadByte() { if (BytesLeftToRead <= 0) { + AdvanceToNextHeader(); return -1; } var value = _stream.ReadByte(); @@ -128,6 +168,10 @@ public override int ReadByte() { --BytesLeftToRead; ++_amountRead; + if (BytesLeftToRead == 0) + { + AdvanceToNextHeader(); + } } return value; } @@ -139,6 +183,11 @@ public override async System.Threading.Tasks.Task ReadAsync( System.Threading.CancellationToken cancellationToken ) { + if (BytesLeftToRead <= 0) + { + await AdvanceToNextHeaderAsync().ConfigureAwait(false); + return 0; + } if (BytesLeftToRead < count) { count = (int)BytesLeftToRead; @@ -150,6 +199,10 @@ System.Threading.CancellationToken cancellationToken { BytesLeftToRead -= read; _amountRead += read; + if (BytesLeftToRead == 0) + { + await AdvanceToNextHeaderAsync().ConfigureAwait(false); + } } return read; } @@ -160,6 +213,11 @@ public override async System.Threading.Tasks.ValueTask ReadAsync( System.Threading.CancellationToken cancellationToken = default ) { + if (BytesLeftToRead <= 0) + { + await AdvanceToNextHeaderAsync().ConfigureAwait(false); + return 0; + } if (BytesLeftToRead < buffer.Length) { buffer = buffer.Slice(0, (int)BytesLeftToRead); @@ -169,6 +227,10 @@ public override async System.Threading.Tasks.ValueTask ReadAsync( { BytesLeftToRead -= read; _amountRead += read; + if (BytesLeftToRead == 0) + { + await AdvanceToNextHeaderAsync().ConfigureAwait(false); + } } return read; } diff --git a/tests/SharpCompress.Test/Tar/TarArchiveTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveTests.cs index 008bb1450..e516e11f6 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveTests.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; @@ -312,6 +313,62 @@ public void Tar_Read_One_At_A_Time() Assert.Equal(2, numberOfEntries); } + [Fact] + public void Tar_Read_One_At_A_Time_Without_Disposing_Entry_Stream() + { + var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 }; + var tarWriterOptions = new TarWriterOptions(CompressionType.None, true) + { + ArchiveEncoding = archiveEncoding, + }; + var testBytes = Encoding.UTF8.GetBytes("This is a test."); + + using var memoryStream = new MemoryStream(); + using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions)) + using (var testFileStream = new MemoryStream(testBytes)) + { + tarWriter.Write("file0.txt", testFileStream); + testFileStream.Position = 0; + tarWriter.Write("file1.txt", testFileStream); + tarWriter.WriteDirectory("folder0", null); + testFileStream.Position = 0; + tarWriter.Write("folder0/file_in_folder0.txt", testFileStream); + } + + memoryStream.Position = 0; + + var entryKeys = new List(); + var openEntryStreams = new List(); + + using (var archive = ArchiveFactory.OpenArchive(memoryStream)) + { + foreach (var entry in archive.Entries) + { + entryKeys.Add(entry.Key); + if (entry.IsDirectory) + { + continue; + } + + var tarEntryStream = entry.OpenEntryStream(); + openEntryStreams.Add(tarEntryStream); + + using var testFileStream = new MemoryStream(); + tarEntryStream.CopyTo(testFileStream); + Assert.Equal(testBytes.Length, testFileStream.Length); + } + + Assert.Equal(4, archive.Entries.Count()); + } + + openEntryStreams.ForEach(stream => stream.Dispose()); + + Assert.Equal( + ["file0.txt", "file1.txt", "folder0/", "folder0/file_in_folder0.txt"], + entryKeys + ); + } + [Fact] public void Tar_Detect_Test() { From ee64868919129a7910a219d7c174b9b5660ccd76 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 29 May 2026 11:58:38 +0000 Subject: [PATCH 3/5] Add tar reader regression tests --- .../Tar/TarArchiveAsyncTests.cs | 62 +++++++++++++++++++ .../Tar/TarReaderAsyncTests.cs | 58 +++++++++++++++++ .../SharpCompress.Test/Tar/TarReaderTests.cs | 56 +++++++++++++++++ 3 files changed, 176 insertions(+) diff --git a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs index b9b7d6eb3..c6decdd5f 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; @@ -275,4 +276,65 @@ public async ValueTask Tar_Read_One_At_A_Time_Async() Assert.Equal(2, numberOfEntries); } + + [Fact] + public async ValueTask Tar_Read_One_At_A_Time_Without_Disposing_Entry_Stream_Async() + { + var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 }; + var tarWriterOptions = new TarWriterOptions(CompressionType.None, true) + { + ArchiveEncoding = archiveEncoding, + }; + var testBytes = Encoding.UTF8.GetBytes("This is a test."); + + using var memoryStream = new MemoryStream(); + using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions)) + using (var testFileStream = new MemoryStream(testBytes)) + { + await tarWriter.WriteAsync("file0.txt", testFileStream, null); + testFileStream.Position = 0; + await tarWriter.WriteAsync("file1.txt", testFileStream, null); + tarWriter.WriteDirectory("folder0", null); + testFileStream.Position = 0; + await tarWriter.WriteAsync("folder0/file_in_folder0.txt", testFileStream, null); + } + + memoryStream.Position = 0; + + var entryKeys = new List(); + var openEntryStreams = new List(); + + await using ( + var archive = await TarArchive.OpenAsyncArchive( + new AsyncOnlyStream(memoryStream), + ReaderOptions.ForExternalStream + ) + ) + { + await foreach (var entry in archive.EntriesAsync) + { + entryKeys.Add(entry.Key); + if (entry.IsDirectory) + { + continue; + } + + var tarEntryStream = await entry.OpenEntryStreamAsync(); + openEntryStreams.Add(tarEntryStream); + + using var testFileStream = new MemoryStream(); + await tarEntryStream.CopyToAsync(testFileStream); + Assert.Equal(testBytes.Length, testFileStream.Length); + } + + Assert.Equal(4, await archive.EntriesAsync.CountAsync()); + } + + openEntryStreams.ForEach(stream => stream.Dispose()); + + Assert.Equal( + ["file0.txt", "file1.txt", "folder0/", "folder0/file_in_folder0.txt"], + entryKeys + ); + } } diff --git a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs index 34ceac02f..e42bcc13c 100644 --- a/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarReaderAsyncTests.cs @@ -1,12 +1,14 @@ using System; using System.Collections.Generic; using System.IO; +using System.Text; using System.Threading.Tasks; using SharpCompress.Common; using SharpCompress.Factories; using SharpCompress.Readers; using SharpCompress.Readers.Tar; using SharpCompress.Test.Mocks; +using SharpCompress.Writers.Tar; using Xunit; namespace SharpCompress.Test.Tar; @@ -199,6 +201,62 @@ await reader.MoveToNextEntryAsync() ); } + [Fact] + public async ValueTask Tar_Read_One_At_A_Time_Without_Disposing_Entry_Stream_Async() + { + var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 }; + var tarWriterOptions = new TarWriterOptions(CompressionType.None, true) + { + ArchiveEncoding = archiveEncoding, + }; + var testBytes = Encoding.UTF8.GetBytes("This is a test."); + + using var memoryStream = new MemoryStream(); + using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions)) + using (var testFileStream = new MemoryStream(testBytes)) + { + await tarWriter.WriteAsync("file0.txt", testFileStream, null); + testFileStream.Position = 0; + await tarWriter.WriteAsync("file1.txt", testFileStream, null); + tarWriter.WriteDirectory("folder0", null); + testFileStream.Position = 0; + await tarWriter.WriteAsync("folder0/file_in_folder0.txt", testFileStream, null); + } + + memoryStream.Position = 0; + + var entryKeys = new List(); + var openEntryStreams = new List(); + + await using ( + var reader = await TarReader.OpenAsyncReader(new AsyncOnlyStream(memoryStream)) + ) + { + while (await reader.MoveToNextEntryAsync()) + { + entryKeys.Add(reader.Entry.Key); + if (reader.Entry.IsDirectory) + { + continue; + } + + var entryStream = await reader.OpenEntryStreamAsync(); + openEntryStreams.Add(entryStream); + + using var testFileStream = new MemoryStream(); + await entryStream.CopyToAsync(testFileStream); + Assert.Equal(testBytes.Length, testFileStream.Length); + } + } + + openEntryStreams.ForEach(stream => stream.Dispose()); + + Assert.Equal( + ["file0.txt", "file1.txt", "folder0/", "folder0/file_in_folder0.txt"], + entryKeys + ); + } + [Fact] public async ValueTask Tar_Corrupted_Async() { diff --git a/tests/SharpCompress.Test/Tar/TarReaderTests.cs b/tests/SharpCompress.Test/Tar/TarReaderTests.cs index d34cc68b7..819155a5c 100644 --- a/tests/SharpCompress.Test/Tar/TarReaderTests.cs +++ b/tests/SharpCompress.Test/Tar/TarReaderTests.cs @@ -1,12 +1,14 @@ using System; using System.Collections.Generic; using System.IO; +using System.Text; using SharpCompress.Common; using SharpCompress.Compressors.BZip2; using SharpCompress.Factories; using SharpCompress.Readers; using SharpCompress.Readers.Tar; using SharpCompress.Test.Mocks; +using SharpCompress.Writers.Tar; using Xunit; namespace SharpCompress.Test.Tar; @@ -231,6 +233,60 @@ public void Tar_Broken_Stream() Assert.Throws(() => reader.MoveToNextEntry()); } + [Fact] + public void Tar_Read_One_At_A_Time_Without_Disposing_Entry_Stream() + { + var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 }; + var tarWriterOptions = new TarWriterOptions(CompressionType.None, true) + { + ArchiveEncoding = archiveEncoding, + }; + var testBytes = Encoding.UTF8.GetBytes("This is a test."); + + using var memoryStream = new MemoryStream(); + using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions)) + using (var testFileStream = new MemoryStream(testBytes)) + { + tarWriter.Write("file0.txt", testFileStream, null); + testFileStream.Position = 0; + tarWriter.Write("file1.txt", testFileStream, null); + tarWriter.WriteDirectory("folder0", null); + testFileStream.Position = 0; + tarWriter.Write("folder0/file_in_folder0.txt", testFileStream, null); + } + + memoryStream.Position = 0; + + var entryKeys = new List(); + var openEntryStreams = new List(); + + using (var reader = TarReader.OpenReader(memoryStream)) + { + while (reader.MoveToNextEntry()) + { + entryKeys.Add(reader.Entry.Key); + if (reader.Entry.IsDirectory) + { + continue; + } + + var entryStream = reader.OpenEntryStream(); + openEntryStreams.Add(entryStream); + + using var testFileStream = new MemoryStream(); + entryStream.CopyTo(testFileStream); + Assert.Equal(testBytes.Length, testFileStream.Length); + } + } + + openEntryStreams.ForEach(stream => stream.Dispose()); + + Assert.Equal( + ["file0.txt", "file1.txt", "folder0/", "folder0/file_in_folder0.txt"], + entryKeys + ); + } + [Fact] public void Tar_Corrupted() { From 7a6a8d53f984e098e3003338c989b2059c94cd9c Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Fri, 29 May 2026 15:11:39 +0100 Subject: [PATCH 4/5] Fix merge --- src/SharpCompress/Common/Tar/TarFilePart.cs | 8 ++------ src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs | 7 +------ src/SharpCompress/Common/Tar/TarHeaderFactory.cs | 3 +-- src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs | 2 +- tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs | 3 +++ 5 files changed, 8 insertions(+), 15 deletions(-) diff --git a/src/SharpCompress/Common/Tar/TarFilePart.cs b/src/SharpCompress/Common/Tar/TarFilePart.cs index 15b76d141..4c32865c4 100644 --- a/src/SharpCompress/Common/Tar/TarFilePart.cs +++ b/src/SharpCompress/Common/Tar/TarFilePart.cs @@ -25,7 +25,7 @@ internal override Stream GetCompressedStream() if (_seekableStream != null) { _seekableStream.Position = Header.DataStartPosition ?? 0; - return new TarReadOnlySubStream(_seekableStream, Header.Size, false); + return new TarReadOnlySubStream(_seekableStream, Header.Size); } return Header.PackedStream.NotNull(); } @@ -36,13 +36,9 @@ internal override Stream GetCompressedStream() { if (_seekableStream != null) { - var useSyncOverAsync = false; -#if LEGACY_DOTNET - useSyncOverAsync = true; -#endif _seekableStream.Position = Header.DataStartPosition ?? 0; return new ValueTask( - new TarReadOnlySubStream(_seekableStream, Header.Size, useSyncOverAsync) + new TarReadOnlySubStream(_seekableStream, Header.Size) ); } return new ValueTask(Header.PackedStream.NotNull()); diff --git a/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs b/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs index 772a56651..460be1cc0 100644 --- a/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs +++ b/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs @@ -44,14 +44,9 @@ IArchiveEncoding archiveEncoding break; case StreamingMode.Streaming: { - var useSyncOverAsync = false; -#if LEGACY_DOTNET - useSyncOverAsync = true; -#endif header.PackedStream = new TarReadOnlySubStream( stream, - header.Size, - useSyncOverAsync + header.Size ); } break; diff --git a/src/SharpCompress/Common/Tar/TarHeaderFactory.cs b/src/SharpCompress/Common/Tar/TarHeaderFactory.cs index df71351e9..6053fa106 100644 --- a/src/SharpCompress/Common/Tar/TarHeaderFactory.cs +++ b/src/SharpCompress/Common/Tar/TarHeaderFactory.cs @@ -40,8 +40,7 @@ IArchiveEncoding archiveEncoding { header.PackedStream = new TarReadOnlySubStream( stream, - header.Size, - false + header.Size ); } break; diff --git a/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs b/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs index bc3408dfe..86594f63d 100644 --- a/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs +++ b/src/SharpCompress/Common/Tar/TarReadOnlySubStream.cs @@ -12,7 +12,7 @@ internal class TarReadOnlySubStream : Stream private bool _isPositionedAtNextEntry; private long _amountRead; - public TarReadOnlySubStream(Stream stream, long bytesToRead, bool useSyncOverAsyncDispose) + public TarReadOnlySubStream(Stream stream, long bytesToRead) { _stream = stream; BytesLeftToRead = bytesToRead; diff --git a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs index d199e09d9..28947e97d 100644 --- a/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs +++ b/tests/SharpCompress.Test/Tar/TarArchiveAsyncTests.cs @@ -416,6 +416,9 @@ public async ValueTask Tar_PaxGlobalHeader_Link_Archive_Async() Assert.Equal(4100, localOverrideLink.UserID); Assert.Equal(5100, localOverrideLink.GroupId); Assert.Equal(Convert.ToInt64("777", 8), localOverrideLink.Mode); + } + + [Fact] public async ValueTask Tar_Read_One_At_A_Time_Without_Disposing_Entry_Stream_Async() { var archiveEncoding = new ArchiveEncoding { Default = Encoding.UTF8 }; From 0f6f1f2b53d0253788fec2d1d7da9dc089cbc2fe Mon Sep 17 00:00:00 2001 From: Adam Hathcock Date: Fri, 29 May 2026 15:37:14 +0100 Subject: [PATCH 5/5] fmt --- src/SharpCompress/Common/Tar/TarFilePart.cs | 4 +--- src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs | 5 +---- src/SharpCompress/Common/Tar/TarHeaderFactory.cs | 5 +---- 3 files changed, 3 insertions(+), 11 deletions(-) diff --git a/src/SharpCompress/Common/Tar/TarFilePart.cs b/src/SharpCompress/Common/Tar/TarFilePart.cs index 4c32865c4..eb2f4f337 100644 --- a/src/SharpCompress/Common/Tar/TarFilePart.cs +++ b/src/SharpCompress/Common/Tar/TarFilePart.cs @@ -37,9 +37,7 @@ internal override Stream GetCompressedStream() if (_seekableStream != null) { _seekableStream.Position = Header.DataStartPosition ?? 0; - return new ValueTask( - new TarReadOnlySubStream(_seekableStream, Header.Size) - ); + return new ValueTask(new TarReadOnlySubStream(_seekableStream, Header.Size)); } return new ValueTask(Header.PackedStream.NotNull()); } diff --git a/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs b/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs index 460be1cc0..c011abd25 100644 --- a/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs +++ b/src/SharpCompress/Common/Tar/TarHeaderFactory.Async.cs @@ -44,10 +44,7 @@ IArchiveEncoding archiveEncoding break; case StreamingMode.Streaming: { - header.PackedStream = new TarReadOnlySubStream( - stream, - header.Size - ); + header.PackedStream = new TarReadOnlySubStream(stream, header.Size); } break; default: diff --git a/src/SharpCompress/Common/Tar/TarHeaderFactory.cs b/src/SharpCompress/Common/Tar/TarHeaderFactory.cs index 6053fa106..c95efaef5 100644 --- a/src/SharpCompress/Common/Tar/TarHeaderFactory.cs +++ b/src/SharpCompress/Common/Tar/TarHeaderFactory.cs @@ -38,10 +38,7 @@ IArchiveEncoding archiveEncoding break; case StreamingMode.Streaming: { - header.PackedStream = new TarReadOnlySubStream( - stream, - header.Size - ); + header.PackedStream = new TarReadOnlySubStream(stream, header.Size); } break; default: