@@ -19,26 +19,24 @@ public sealed class HybridMemoryStream : Stream
1919 {
2020 private MemoryStream _memStream ;
2121 private Stream _overflowStream ;
22- private string _overflowPath ;
2322 private readonly int _overflowBoundary ;
2423 private const int _defaultMaxLen = 1 << 30 ;
2524
2625 private bool _disposed ;
2726
28- private Stream MyStream { get { return _memStream ?? _overflowStream ; } }
27+ private Stream MyStream => _memStream ?? _overflowStream ;
2928
30- private bool IsMemory { get { return _memStream != null ; } }
29+ private bool IsMemory => _memStream != null ;
3130
32- public override long Position
33- {
34- get { return MyStream . Position ; }
35- set { Seek ( value , SeekOrigin . Begin ) ; }
31+ public override long Position {
32+ get => MyStream . Position ;
33+ set => Seek ( value , SeekOrigin . Begin ) ;
3634 }
3735
38- public override long Length { get { return MyStream . Length ; } }
39- public override bool CanWrite { get { return MyStream . CanWrite ; } }
40- public override bool CanSeek { get { return MyStream . CanSeek ; } }
41- public override bool CanRead { get { return MyStream . CanRead ; } }
36+ public override long Length => MyStream . Length ;
37+ public override bool CanWrite => MyStream . CanWrite ;
38+ public override bool CanSeek => MyStream . CanSeek ;
39+ public override bool CanRead => MyStream . CanRead ;
4240
4341 /// <summary>
4442 /// Constructs an initially empty read-write stream. Once the number of
@@ -123,27 +121,24 @@ protected override void Dispose(bool disposing)
123121 var overflow = _overflowStream ;
124122 _overflowStream = null ;
125123 overflow . Dispose ( ) ;
126- Contracts . AssertValue ( _overflowPath ) ;
127- File . Delete ( _overflowPath ) ;
128- _overflowPath = null ;
129124 }
130125 _disposed = true ;
131126 AssertInvariants ( ) ;
127+ base . Dispose ( disposing ) ;
132128 }
133129 }
134130
135131 public override void Close ( )
136132 {
137133 AssertInvariants ( ) ;
138- if ( MyStream != null )
139- MyStream . Close ( ) ;
134+ // The base Stream class Close will call Dispose(bool).
135+ base . Close ( ) ;
140136 }
141137
142138 public override void Flush ( )
143139 {
144140 AssertInvariants ( ) ;
145- if ( MyStream != null )
146- MyStream . Flush ( ) ;
141+ MyStream ? . Flush ( ) ;
147142 AssertInvariants ( ) ;
148143 }
149144
@@ -164,9 +159,9 @@ private void EnsureOverflow()
164159 // been closed.
165160 Contracts . Check ( _memStream . CanRead , "attempt to perform operation on closed stream" ) ;
166161
167- Contracts . Assert ( _overflowPath == null ) ;
168- _overflowPath = Path . GetTempFileName ( ) ;
169- _overflowStream = new FileStream ( _overflowPath , FileMode . Open , FileAccess . ReadWrite ) ;
162+ string overflowPath = Path . GetTempFileName ( ) ;
163+ _overflowStream = new FileStream ( overflowPath , FileMode . Open , FileAccess . ReadWrite ,
164+ FileShare . None , bufferSize : 4096 , FileOptions . DeleteOnClose ) ;
170165
171166 // The documentation is not clear on this point, but the source code for
172167 // memory stream makes clear that this buffer is exposable for a memory
0 commit comments