src: Move Format property from TarReader to TarEntry

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarEntry.cs

@@ -60,6 +60,11 @@ internal TarEntry(TarEntryType entryType, TarEntryFormat format, string entryNam
         /// </summary>
         public TarEntryType EntryType => _header._typeFlag;
 
+        /// <summary>
+        /// The format of the entry.
+        /// </summary>
+        public TarEntryFormat Format => _header._format;
+
         /// <summary>
         /// The ID of the group that owns the file represented by this entry.
         /// </summary>

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHelpers.cs

@@ -179,7 +179,7 @@ internal static int SkipBlockAlignmentPadding(Stream archiveStream, long size)
 
         // Throws if the specified entry type is not supported for the specified format.
         // If 'invokingFromWriteEntry' is true, an incompatible 'Regular File' entry type is allowed. It will be converted to the compatible version before writing.
-        internal static void VerifyEntryTypeIsSupported(TarEntryType entryType, TarEntryFormat archiveFormat, bool invokingFromWriteEntry = false)
+        internal static void VerifyEntryTypeIsSupported(TarEntryType entryType, TarEntryFormat archiveFormat)
         {
             switch (archiveFormat)
             {
@@ -192,10 +192,6 @@ TarEntryType.V7RegularFile or
                     {
                         return;
                     }
-                    if (invokingFromWriteEntry && entryType is TarEntryType.RegularFile)
-                    {
-                        return;
-                    }
                     break;
 
                 case TarEntryFormat.Ustar:
@@ -210,10 +206,6 @@ TarEntryType.RegularFile or
                     {
                         return;
                     }
-                    if (invokingFromWriteEntry && entryType is TarEntryType.V7RegularFile)
-                    {
-                        return;
-                    }
                     break;
 
                 case TarEntryFormat.Pax:
@@ -231,10 +223,6 @@ TarEntryType.RegularFile or
                         // - GlobalExtendedAttributes
                         return;
                     }
-                    if (invokingFromWriteEntry && entryType is TarEntryType.V7RegularFile)
-                    {
-                        return;
-                    }
                     break;
 
                 case TarEntryFormat.Gnu:
@@ -260,10 +248,6 @@ TarEntryType.RegularFile or
                         // - LongPath
                         return;
                     }
-                    if (invokingFromWriteEntry && entryType is TarEntryType.V7RegularFile)
-                    {
-                        return;
-                    }
                     break;
 
                 case TarEntryFormat.Unknown:

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarReader.cs

@@ -41,17 +41,11 @@ public TarReader(Stream archiveStream, bool leaveOpen = false)
 
             _previouslyReadEntry = null;
             GlobalExtendedAttributes = null;
-            Format = TarEntryFormat.Unknown;
             _isDisposed = false;
             _readFirstEntry = false;
             _reachedEndMarkers = false;
         }
 
-        /// <summary>
-        /// The format of the archive. It is initially <see cref="TarEntryFormat.Unknown"/>. The archive format is detected after the first call to <see cref="GetNextEntry(bool)"/>.
-        /// </summary>
-        public TarEntryFormat Format { get; private set; }
-
         /// <summary>
         /// <para>If the archive format is <see cref="TarEntryFormat.Pax"/>, returns a read-only dictionary containing the string key-value pairs of the Global Extended Attributes in the first entry of the archive.</para>
         /// <para>If there is no Global Extended Attributes entry at the beginning of the archive, this returns an empty read-only dictionary.</para>
@@ -115,16 +109,10 @@ public void Dispose()
             {
                 if (!_readFirstEntry)
                 {
-                    Debug.Assert(Format == TarEntryFormat.Unknown);
-                    Format = header._format;
                     _readFirstEntry = true;
                 }
-                else if (header._format != Format)
-                {
-                    throw new FormatException(string.Format(SR.TarEntriesInDifferentFormats, header._format, Format));
-                }
 
-                TarEntry entry = Format switch
+                TarEntry entry = header._format switch
                 {
                     TarEntryFormat.Pax => new PaxTarEntry(header, this),
                     TarEntryFormat.Gnu => new GnuTarEntry(header, this),
@@ -227,11 +215,7 @@ private bool TryGetNextEntryHeader(out TarHeader header, bool copyData)
             Debug.Assert(!_reachedEndMarkers);
 
             header = default;
-
-            // Set the initial format that is expected to be retrieved when calling TarHeader.TryReadAttributes.
-            // If the archive format is set to unknown here, it means this is the first entry we read and the value will be changed as fields get discovered.
-            // If the archive format is initially detected as pax, then any subsequent entries detected as ustar will be assumed to be pax.
-            header._format = Format;
+            header._format = TarEntryFormat.Unknown;
 
             if (!header.TryGetNextHeader(_archiveStream, copyData))
             {
@@ -261,7 +245,6 @@ private bool TryGetNextEntryHeader(out TarHeader header, bool copyData)
                 catch (EndOfStreamException)
                 {
                     // Edge case: The only entry in the archive was a Global Extended Attributes entry
-                    Format = TarEntryFormat.Pax;
                     return false;
                 }
                 if (header._typeFlag == TarEntryType.GlobalExtendedAttributes)

src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarWriter.cs

@@ -20,6 +20,16 @@ public sealed partial class TarWriter : IDisposable
         private readonly Stream _archiveStream;
         private readonly IEnumerable<KeyValuePair<string, string>>? _globalExtendedAttributes;
 
+        /// <summary>
+        /// Initializes a <see cref="TarWriter"/> instance that can write tar entries to the specified stream and closes the <paramref name="archiveStream"/> upon disposal of this instance.
+        /// </summary>
+        /// <param name="archiveStream">The stream to write to.</param>
+        /// <remarks>When using this constructor, <see cref="TarEntryFormat.Pax"/> is used as the default format of the entries written to the archive using the <see cref="WriteEntry(string, string?)"/> method.</remarks>
+        public TarWriter(Stream archiveStream)
+            : this(archiveStream, TarEntryFormat.Pax, leaveOpen: false)
+        {
+        }
+
         /// <summary>
         /// Initializes a <see cref="TarWriter"/> instance that can write tar entries to the specified stream, optionally leave the stream open upon disposal of this instance, and can optionally add a Global Extended Attributes entry at the beginning of the archive. When using this constructor, the format of the resulting archive is <see cref="TarEntryFormat.Pax"/>.
         /// </summary>
@@ -33,17 +43,16 @@ public TarWriter(Stream archiveStream, IEnumerable<KeyValuePair<string, string>>
         }
 
         /// <summary>
-        /// Initializes a <see cref="TarWriter"/> instance that can write tar entries to the specified stream, optionally leave the stream open upon disposal of this instance, and can specify the format of the underlying archive.
+        /// Initializes a <see cref="TarWriter"/> instance that can write tar entries to the specified stream, optionally leaves the stream open upon disposal of this instance, and can optionally specify the preferred default format when writing entries using the <see cref="WriteEntry(string, string?)"/> method.
         /// </summary>
         /// <param name="archiveStream">The stream to write to.</param>
-        /// <param name="archiveFormat">The format of the archive.</param>
-        /// <param name="leaveOpen"><see langword="false"/> to dispose the <paramref name="archiveStream"/> when this instance is disposed; <see langword="true"/> to leave the stream open.</param>
-        /// <remarks><para>If the selected <paramref name="archiveFormat"/> is <see cref="TarEntryFormat.Pax"/>, no Global Extended Attributes entry is written. To write a PAX archive with a Global Extended Attributes entry inserted at the beginning of the archive, use the <see cref="TarWriter(Stream, IEnumerable{KeyValuePair{string, string}}?, bool)"/> constructor instead.</para>
-        /// <para>The recommended format is <see cref="TarEntryFormat.Pax"/> for its flexibility.</para></remarks>
+        /// <param name="archiveFormat">The preferred default format when writing entries to the archive using the <see cref="WriteEntry(string, string?)"/> method. The default value is <see cref="TarEntryFormat.Pax"/>.</param>
+        /// <param name="leaveOpen"><see langword="false"/> to dispose the <paramref name="archiveStream"/> when this instance is disposed; <see langword="true"/> to leave the stream open. The default is <see langword="false"/>.</param>
+        /// <remarks>The recommended format is <see cref="TarEntryFormat.Pax"/> for its flexibility.</remarks>
         /// <exception cref="ArgumentNullException"><paramref name="archiveStream"/> is <see langword="null"/>.</exception>
         /// <exception cref="IOException"><paramref name="archiveStream"/> is unwritable.</exception>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="archiveFormat"/> is either <see cref="TarEntryFormat.Unknown"/>, or not one of the other enum values.</exception>
-        public TarWriter(Stream archiveStream, TarEntryFormat archiveFormat, bool leaveOpen = false)
+        public TarWriter(Stream archiveStream, TarEntryFormat archiveFormat = TarEntryFormat.Pax, bool leaveOpen = false)
         {
             ArgumentNullException.ThrowIfNull(archiveStream);
 
@@ -67,7 +76,7 @@ public TarWriter(Stream archiveStream, TarEntryFormat archiveFormat, bool leaveO
         }
 
         /// <summary>
-        /// The format of the archive.
+        /// The preferred default format of the entries when writing entries to the archive using the <see cref="WriteEntry(string, string?)"/> method.
         /// </summary>
         public TarEntryFormat Format { get; private set; }
 
@@ -165,16 +174,14 @@ public void WriteEntry(TarEntry entry)
         {
             ThrowIfDisposed();
 
-            TarHelpers.VerifyEntryTypeIsSupported(entry.EntryType, Format, invokingFromWriteEntry: true);
-
             WriteGlobalExtendedAttributesEntryIfNeeded();
 
             byte[] rented = ArrayPool<byte>.Shared.Rent(minimumLength: TarHelpers.RecordSize);
             Span<byte> buffer = rented.AsSpan(0, TarHelpers.RecordSize); // minimumLength means the array could've been larger
             buffer.Clear(); // Rented arrays aren't clean
             try
             {
-                switch (Format)
+                switch (entry.Format)
                 {
                     case TarEntryFormat.V7:
                         entry._header.WriteAsV7(_archiveStream, buffer);