Eliminate closure allocation in ZipArchiveEntry

Also a couple of boolean fields removed from `WrappedStream` and their usage replaced with `_isDisposed` flag.

Author: Maxwe11

src/System.IO.Compression/src/System/IO/Compression/ZipArchiveEntry.cs

@@ -643,17 +643,21 @@ private CheckSumAndSizeWriteStream GetDataCompressor(Stream backingStream, Boole
             Boolean isIntermediateStream = true;
 
             Boolean leaveCompressorStreamOpenOnClose = leaveBackingStreamOpen && !isIntermediateStream;
-            CheckSumAndSizeWriteStream checkSumStream =
-                new CheckSumAndSizeWriteStream(compressorStream, backingStream, leaveCompressorStreamOpenOnClose,
-                    (Int64 initialPosition, Int64 currentPosition, UInt32 checkSum) =>
-                    {
-                        _crc32 = checkSum;
-                        _uncompressedSize = currentPosition;
-                        _compressedSize = backingStream.Position - initialPosition;
+            var checkSumStream = new CheckSumAndSizeWriteStream(
+                compressorStream, 
+                backingStream, 
+                leaveCompressorStreamOpenOnClose, 
+                this, 
+                onClose,
+                (Int64 initialPosition, Int64 currentPosition, UInt32 checkSum, Stream backing, ZipArchiveEntry thisRef, EventHandler closeHandler) =>
+                {
+                    thisRef._crc32 = checkSum;
+                    thisRef._uncompressedSize = currentPosition;
+                    thisRef._compressedSize = backing.Position - initialPosition;
 
-                        if (onClose != null)
-                            onClose(this, EventArgs.Empty);
-                    });
+                    if (closeHandler != null)
+                        closeHandler(thisRef, EventArgs.Empty);
+                });
 
             return checkSumStream;
         }
@@ -701,12 +705,13 @@ private Stream OpenInWriteMode()
                                                             (object o, EventArgs e) =>
                                                             {
                                                                 //release the archive stream
-                                                                _archive.ReleaseArchiveStream(this);
-                                                                _outstandingWriteStream = null;
+                                                                var entry = (ZipArchiveEntry)o;
+                                                                entry._archive.ReleaseArchiveStream(entry);
+                                                                entry._outstandingWriteStream = null;
                                                             });
             _outstandingWriteStream = new DirectToArchiveWriterStream(crcSizeStream, this);
 
-            return new WrappedStream(_outstandingWriteStream, (object o, EventArgs e) => _outstandingWriteStream.Dispose());
+            return new WrappedStream(baseStream: _outstandingWriteStream, closeBaseStream: true);
         }
 
         private Stream OpenInUpdateMode()
@@ -720,14 +725,13 @@ private Stream OpenInUpdateMode()
             _currentlyOpenForWrite = true;
             //always put it at the beginning for them
             UncompressedData.Seek(0, SeekOrigin.Begin);
-            return new WrappedStream(UncompressedData,
-                                     (object o, EventArgs e) =>
+            return new WrappedStream(UncompressedData, this, thisRef => 
                                      {
                                          //once they close, we know uncompressed length, but still not compressed length
                                          //so we don't fill in any size information
                                          //those fields get figured out when we call GetCompressor as we write it to
                                          //the actual archive
-                                         _currentlyOpenForWrite = false;
+                                         thisRef._currentlyOpenForWrite = false;
                                      });
         }
 

src/System.IO.Compression/src/System/IO/Compression/ZipCustomStreams.cs

@@ -11,32 +11,34 @@ internal class WrappedStream : Stream
         #region fields
 
         private readonly Stream _baseStream;
-        private readonly EventHandler _onClosed;
-        private Boolean _canRead, _canWrite, _canSeek;
-        private Boolean _isDisposed;
         private readonly Boolean _closeBaseStream;
 
+        // Delegate that will be invoked on stream disposing
+        private readonly Action<ZipArchiveEntry> _onClosed;
+
+        // Instance that will be passed to _onClose delegate
+        private readonly ZipArchiveEntry _zipArchiveEntry;
+        private Boolean _isDisposed;
+
         #endregion
 
         #region constructors
 
-        internal WrappedStream(Stream baseStream, Boolean canRead, Boolean canWrite, Boolean canSeek, EventHandler onClosed)
-            : this(baseStream, canRead, canWrite, canSeek, false, onClosed)
+        internal WrappedStream(Stream baseStream, Boolean closeBaseStream)
+            : this(baseStream, closeBaseStream, null, null)
         { }
 
-        internal WrappedStream(Stream baseStream, Boolean canRead, Boolean canWrite, Boolean canSeek, Boolean closeBaseStream, EventHandler onClosed)
+        private WrappedStream(Stream baseStream, Boolean closeBaseStream, ZipArchiveEntry entry, Action<ZipArchiveEntry> onClosed)
         {
             _baseStream = baseStream;
+            _closeBaseStream = closeBaseStream;
             _onClosed = onClosed;
-            _canRead = canRead;
-            _canSeek = canSeek;
-            _canWrite = canWrite;
+            _zipArchiveEntry = entry;
             _isDisposed = false;
-            _closeBaseStream = closeBaseStream;
         }
 
-        internal WrappedStream(Stream baseStream, EventHandler onClosed)
-            : this(baseStream, true, true, true, onClosed)
+        internal WrappedStream(Stream baseStream, ZipArchiveEntry entry, Action<ZipArchiveEntry> onClosed)
+            : this(baseStream, false, entry, onClosed)
         { }
 
         #endregion
@@ -68,11 +70,11 @@ public override long Position
             }
         }
 
-        public override bool CanRead { get { return _canRead && _baseStream.CanRead; } }
+        public override bool CanRead { get { return !_isDisposed && _baseStream.CanRead; } }
 
-        public override bool CanSeek { get { return _canSeek && _baseStream.CanSeek; } }
+        public override bool CanSeek { get { return !_isDisposed && _baseStream.CanSeek; } }
 
-        public override bool CanWrite { get { return _canWrite && _baseStream.CanWrite; } }
+        public override bool CanWrite { get { return !_isDisposed && _baseStream.CanWrite; } }
 
         #endregion
 
@@ -145,14 +147,11 @@ protected override void Dispose(bool disposing)
             if (disposing && !_isDisposed)
             {
                 if (_onClosed != null)
-                    _onClosed(this, null);
+                    _onClosed(_zipArchiveEntry);
 
                 if (_closeBaseStream)
                     _baseStream.Dispose();
 
-                _canRead = false;
-                _canWrite = false;
-                _canSeek = false;
                 _isDisposed = true;
             }
             base.Dispose(disposing);
@@ -317,10 +316,11 @@ internal class CheckSumAndSizeWriteStream : Stream
 
         //this is the position in BaseBaseStream
         private Int64 _initialPosition;
-
+        private readonly ZipArchiveEntry _zipArchiveEntry;
+        private readonly EventHandler _onClose;
         // Called when the stream is closed.
-        // parameters are initialPosition, currentPosition, checkSum
-        private readonly Action<Int64, Int64, UInt32> _saveCrcAndSizes;
+        // parameters are initialPosition, currentPosition, checkSum, baseBaseStream, zipArchiveEntry and onClose handler
+        private readonly Action<Int64, Int64, UInt32, Stream, ZipArchiveEntry, EventHandler> _saveCrcAndSizes;
 
         #endregion
 
@@ -329,10 +329,14 @@ internal class CheckSumAndSizeWriteStream : Stream
         /* parameters to saveCrcAndSizes are
          *  initialPosition (initialPosition in baseBaseStream),
          *  currentPosition (in this CheckSumAndSizeWriteStream),
-         *  checkSum (of data passed into this CheckSumAndSizeWriteStream)
+         *  checkSum (of data passed into this CheckSumAndSizeWriteStream),
+         *  baseBaseStream it's a backingStream, passed here so as to avoid closure allocation,
+         *  zipArchiveEntry passed here so as to avoid closure allocation,
+         *  onClose handler passed here so as to avoid closure allocation
         */
-        public CheckSumAndSizeWriteStream(Stream baseStream, Stream baseBaseStream,
-                                            Boolean leaveOpenOnClose, Action<Int64, Int64, UInt32> saveCrcAndSizes)
+        public CheckSumAndSizeWriteStream(Stream baseStream, Stream baseBaseStream, Boolean leaveOpenOnClose,
+            ZipArchiveEntry entry, EventHandler onClose,
+            Action<Int64, Int64, UInt32, Stream, ZipArchiveEntry, EventHandler> saveCrcAndSizes)
         {
             _baseStream = baseStream;
             _baseBaseStream = baseBaseStream;
@@ -342,6 +346,8 @@ public CheckSumAndSizeWriteStream(Stream baseStream, Stream baseBaseStream,
             _canWrite = true;
             _isDisposed = false;
             _initialPosition = 0;
+            _zipArchiveEntry = entry;
+            _onClose = onClose;
             _saveCrcAndSizes = saveCrcAndSizes;
         }
 
@@ -458,7 +464,7 @@ protected override void Dispose(Boolean disposing)
                 if (!_leaveOpenOnClose)
                     _baseStream.Dispose();        // Close my super-stream (flushes the last data)
                 if (_saveCrcAndSizes != null)
-                    _saveCrcAndSizes(_initialPosition, Position, _checksum);
+                    _saveCrcAndSizes(_initialPosition, Position, _checksum, _baseBaseStream, _zipArchiveEntry, _onClose);
                 _isDisposed = true;
             }
             base.Dispose(disposing);