Clean up Dispose{Async} implementations

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

@@ -188,10 +188,7 @@ public override Task FlushAsync(CancellationToken cancellationToken) =>
         // the substream is just 'a chunk' of the super-stream
         protected override void Dispose(bool disposing)
         {
-            if (disposing && !_isDisposed)
-            {
-                _isDisposed = true;
-            }
+            _isDisposed = true;
             base.Dispose(disposing);
         }
     }

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

@@ -54,8 +54,18 @@ public TarReader(Stream archiveStream, bool leaveOpen = false)
         /// <remarks>The <see cref="TarEntry.DataStream"/> property of any entry can be replaced with a new stream. If the user decides to replace it on a <see cref="TarEntry"/> instance that was obtained using a <see cref="TarReader"/>, the underlying stream gets disposed immediately, freeing the <see cref="TarReader"/> of origin from the responsibility of having to dispose it.</remarks>
         public void Dispose()
         {
-            Dispose(disposing: true);
-            GC.SuppressFinalize(this);
+            if (!_isDisposed)
+            {
+                _isDisposed = true;
+
+                if (!_leaveOpen && _dataStreamsToDispose?.Count > 0)
+                {
+                    foreach (Stream s in _dataStreamsToDispose)
+                    {
+                        s.Dispose();
+                    }
+                }
+            }
         }
 
         /// <summary>
@@ -64,8 +74,18 @@ public void Dispose()
         /// <remarks>The <see cref="TarEntry.DataStream"/> property of any entry can be replaced with a new stream. If the user decides to replace it on a <see cref="TarEntry"/> instance that was obtained using a <see cref="TarReader"/>, the underlying stream gets disposed immediately, freeing the <see cref="TarReader"/> of origin from the responsibility of having to dispose it.</remarks>
         public async ValueTask DisposeAsync()
         {
-            await DisposeAsync(disposing: true).ConfigureAwait(false);
-            GC.SuppressFinalize(this);
+            if (!_isDisposed)
+            {
+                _isDisposed = true;
+
+                if (!_leaveOpen && _dataStreamsToDispose?.Count > 0)
+                {
+                    foreach (Stream s in _dataStreamsToDispose)
+                    {
+                        await s.DisposeAsync().ConfigureAwait(false);
+                    }
+                }
+            }
         }
 
         /// <summary>
@@ -249,52 +269,6 @@ internal async ValueTask AdvanceDataStreamIfNeededAsync(CancellationToken cancel
             }
         }
 
-        // Disposes the current instance.
-        // If 'disposing' is 'false', the method was called from the finalizer.
-        private void Dispose(bool disposing)
-        {
-            if (disposing && !_isDisposed)
-            {
-                try
-                {
-                    if (!_leaveOpen && _dataStreamsToDispose?.Count > 0)
-                    {
-                        foreach (Stream s in _dataStreamsToDispose)
-                        {
-                            s.Dispose();
-                        }
-                    }
-                }
-                finally
-                {
-                    _isDisposed = true;
-                }
-            }
-        }
-
-        // Asynchronously disposes the current instance.
-        // If 'disposing' is 'false', the method was called from the finalizer.
-        private async ValueTask DisposeAsync(bool disposing)
-        {
-            if (disposing && !_isDisposed)
-            {
-                try
-                {
-                    if (!_leaveOpen && _dataStreamsToDispose?.Count > 0)
-                    {
-                        foreach (Stream s in _dataStreamsToDispose)
-                        {
-                            await s.DisposeAsync().ConfigureAwait(false);
-                        }
-                    }
-                }
-                finally
-                {
-                    _isDisposed = true;
-                }
-            }
-        }
-
         // Asynchronously retrieves the next entry if one is found.
         private async ValueTask<TarEntry?> GetNextEntryInternalAsync(bool copyData, CancellationToken cancellationToken)
         {

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

@@ -84,17 +84,41 @@ public TarWriter(Stream archiveStream, TarEntryFormat format = TarEntryFormat.Pa
         /// </summary>
         public void Dispose()
         {
-            Dispose(disposing: true);
-            GC.SuppressFinalize(this);
+            if (!_isDisposed)
+            {
+                _isDisposed = true;
+
+                if (_wroteEntries)
+                {
+                    WriteFinalRecords();
+                }
+
+                if (!_leaveOpen)
+                {
+                    _archiveStream.Dispose();
+                }
+            }
         }
 
         /// <summary>
         /// Asynchronously disposes the current <see cref="TarWriter"/> instance, and closes the archive stream if the <c>leaveOpen</c> argument was set to <see langword="false"/> in the constructor.
         /// </summary>
         public async ValueTask DisposeAsync()
         {
-            await DisposeAsync(disposing: true).ConfigureAwait(false);
-            GC.SuppressFinalize(this);
+            if (!_isDisposed)
+            {
+                _isDisposed = true;
+
+                if (_wroteEntries)
+                {
+                    await WriteFinalRecordsAsync().ConfigureAwait(false);
+                }
+
+                if (!_leaveOpen)
+                {
+                    await _archiveStream.DisposeAsync().ConfigureAwait(false);
+                }
+            }
         }
 
         /// <summary>
@@ -241,58 +265,6 @@ public Task WriteEntryAsync(TarEntry entry, CancellationToken cancellationToken
             return WriteEntryAsyncInternal(entry, cancellationToken);
         }
 
-        // Disposes the current instance.
-        // If 'disposing' is 'false', the method was called from the finalizer.
-        private void Dispose(bool disposing)
-        {
-            if (disposing && !_isDisposed)
-            {
-                try
-                {
-                    if (_wroteEntries)
-                    {
-                        WriteFinalRecords();
-                    }
-
-
-                    if (!_leaveOpen)
-                    {
-                        _archiveStream.Dispose();
-                    }
-                }
-                finally
-                {
-                    _isDisposed = true;
-                }
-            }
-        }
-
-        // Asynchronously disposes the current instance.
-        // If 'disposing' is 'false', the method was called from the finalizer.
-        private async ValueTask DisposeAsync(bool disposing)
-        {
-            if (disposing && !_isDisposed)
-            {
-                try
-                {
-                    if (_wroteEntries)
-                    {
-                        await WriteFinalRecordsAsync().ConfigureAwait(false);
-                    }
-
-
-                    if (!_leaveOpen)
-                    {
-                        await _archiveStream.DisposeAsync().ConfigureAwait(false);
-                    }
-                }
-                finally
-                {
-                    _isDisposed = true;
-                }
-            }
-        }
-
         // Portion of the WriteEntry(entry) method that rents a buffer and writes to the archive.
         private void WriteEntryInternal(TarEntry entry)
         {