protected override void Dispose(bool disposing)
{
if (disposed)
{
string doubleDisposeStack = null;
if (memoryManager.GenerateCallStacks)
{
doubleDisposeStack = Environment.StackTrace;
}
return;
}
if (memoryManager.GenerateCallStacks)
{
disposeStack = Environment.StackTrace;
}
if (disposing)
{
// Once this flag is set, we can't access any properties -- use fields directly
disposed = true;
memoryManager.ReportStreamDisposed();
GC.SuppressFinalize(this);
}
else
{
// We're being finalized.
memoryManager.ReportStreamFinalized();
}
memoryManager.ReportStreamLength(length);
if (largeBuffer != null)
{
memoryManager.ReturnLargeBuffer(largeBuffer, tag);
}
if (dirtyBuffers != null)
{
foreach (var buffer in dirtyBuffers)
{
memoryManager.ReturnLargeBuffer(buffer, tag);
}
}
memoryManager.ReturnBlocks(blocks, tag);
base.Dispose(disposing);
}
/// <summary>
/// Returns a single buffer containing the contents of the stream.
/// The buffer may be longer than the stream length.
/// </summary>
/// <returns>A byte[] buffer</returns>
/// <remarks>IMPORTANT: Doing a Write() after calling GetBuffer() invalidates the buffer. The old buffer is held onto
/// until Dispose is called, but the next time GetBuffer() is called, a new buffer from the pool will be required.</remarks>
/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
public override byte[] GetBuffer()
{
CheckDisposed();
if (largeBuffer != null)
{
return(largeBuffer);
}
if (blocks.Count == 1)
{
return(blocks[0]);
}
// Buffer needs to reflect the capacity, not the length, because
// it's possible that people will manipulate the buffer directly
// and set the length afterward. Capacity sets the expectation
// for the size of the buffer.
var newBuffer = memoryManager.GetLargeBuffer(Capacity, tag);
// InternalRead will check for existence of largeBuffer, so make sure we
// don't set it until after we've copied the data.
InternalRead(newBuffer, 0, length, 0);
largeBuffer = newBuffer;
if (blocks.Count > 0 && memoryManager.AggressiveBufferReturn)
{
memoryManager.ReturnBlocks(blocks, tag);
blocks.Clear();
}
return(largeBuffer);
}
protected override void Dispose(bool disposing)
{
if (Interlocked.CompareExchange(ref disposedState, 1, 0) != 0)
{
string doubleDisposeStack = null;
if (memoryManager.GenerateCallStacks)
{
doubleDisposeStack = Environment.StackTrace;
}
RecyclableMemoryStreamManager.Events.Writer.MemoryStreamDoubleDispose(id, tag,
AllocationStack,
DisposeStack,
doubleDisposeStack);
return;
}
RecyclableMemoryStreamManager.Events.Writer.MemoryStreamDisposed(id, tag);
if (memoryManager.GenerateCallStacks)
{
DisposeStack = Environment.StackTrace;
}
if (disposing)
{
memoryManager.ReportStreamDisposed();
GC.SuppressFinalize(this);
}
else
{
// We're being finalized.
RecyclableMemoryStreamManager.Events.Writer.MemoryStreamFinalized(id, tag, AllocationStack);
#if !NETSTANDARD1_4
if (AppDomain.CurrentDomain.IsFinalizingForUnload())
{
// If we're being finalized because of a shutdown, don't go any further.
// We have no idea what's already been cleaned up. Triggering events may cause
// a crash.
base.Dispose(disposing);
return;
}
#endif
memoryManager.ReportStreamFinalized();
}
memoryManager.ReportStreamLength(length);
if (largeBuffer != null)
{
memoryManager.ReturnLargeBuffer(largeBuffer, tag);
}
if (dirtyBuffers != null)
{
foreach (var buffer in dirtyBuffers)
{
memoryManager.ReturnLargeBuffer(buffer, tag);
}
}
memoryManager.ReturnBlocks(blocks, tag);
blocks.Clear();
base.Dispose(disposing);
}
