public static void ReleaseBuffer(BufferWrapper bufferWrapper) { Stack <WeakReference> weakReferences; if (object.ReferenceEquals(bufferWrapper, BufferPool.EmptyByteBuffer)) { return; } if (bufferWrapper.Buffer == null) { throw new InvalidOperationException("Buffer pointer is null which implies it is released twice to stack."); } byte[] buffer = bufferWrapper.Buffer; bufferWrapper.ClearBuffer(); WeakReference weakReference = new WeakReference(buffer, false) { Target = buffer }; int length = (int)buffer.Length; lock (BufferPoolOriginalWeakReferenceLocking.buffers) { if (BufferPoolOriginalWeakReferenceLocking.buffers.TryGetValue(length, out weakReferences)) { weakReferences.Push(weakReference); } } }
public static BufferWrapper GetBuffer(int RoundUpToPowerOfTwoBufferSize) { BufferWrapper bufferWrapper; if (RoundUpToPowerOfTwoBufferSize == 0) { return(BufferPool.EmptyByteBuffer); } lock (BufferPoolOriginalWeakReferenceLocking.buffers) { Stack <WeakReference> bufferStack = BufferPoolOriginalWeakReferenceLocking.GetBufferStack(RoundUpToPowerOfTwoBufferSize, BufferPoolOriginalWeakReferenceLocking.buffers); while (bufferStack.Count > 0) { byte[] target = (byte[])bufferStack.Pop().Target; if (target == null) { continue; } bufferWrapper = new BufferWrapper(target); return(bufferWrapper); } bufferWrapper = BufferPoolOriginalWeakReferenceLocking.AllocateNewBuffer(RoundUpToPowerOfTwoBufferSize); } return(bufferWrapper); }
public static void ReleaseBuffer(BufferWrapper bufferWrapper) { if (object.ReferenceEquals(bufferWrapper, BufferPool.EmptyByteBuffer)) { return; } if (bufferWrapper.Buffer == null) { throw new InvalidOperationException("Buffer pointer is null which implies it is released twice to stack."); } if (((int)bufferWrapper.Buffer.Length & (int)bufferWrapper.Buffer.Length - 1) != 0) { return; } BufferPoolOriginalWeakReferenceLocking.ReleaseBuffer(bufferWrapper); }
private static IEnumerator <IAsyncResult> AsyncStreamCopyImpl(Stream source, Stream destination, long numBytes, int bufferSize, AsyncStreamCopy.ComputeAndLogCrcMethod computeCrcMethodForCrcLogging, TimeSpan timeout, AsyncIteratorContext <long> context) { Exception exception; BufferWrapper buffer = null; BufferWrapper bufferWrapper = null; try { Duration startingNow = Duration.StartingNow; IAsyncResult asyncResult = null; IAsyncResult asyncResult1 = null; buffer = BufferPool.GetBuffer(bufferSize); bufferWrapper = BufferPool.GetBuffer(bufferSize); long num = (long)0; context.ResultData = (long)0; bool canTimeout = source.CanTimeout; bool flag = destination.CanTimeout; while (true) { int timeoutInMS = AsyncStreamCopy.TimeSpanToTimeoutInMS(startingNow.Remaining(timeout)); if (timeoutInMS == 0) { throw new TimeoutException("The asynchronous stream copy timed out."); } if (canTimeout) { try { source.ReadTimeout = timeoutInMS; } catch (InvalidOperationException invalidOperationException) { canTimeout = false; } } if (flag) { try { destination.WriteTimeout = timeoutInMS; } catch (InvalidOperationException invalidOperationException1) { flag = false; } } if (numBytes > (long)0) { asyncResult = source.BeginRead(buffer.Buffer, 0, (int)Math.Min((long)((int)buffer.Buffer.Length), numBytes), context.GetResumeCallback(), context.GetResumeState("AsyncStreamCopy.source.Read")); } exception = null; if (num > (long)0) { try { asyncResult1 = destination.BeginWrite(bufferWrapper.Buffer, 0, (int)num, context.GetResumeCallback(), context.GetResumeState("AsyncStreamCopy.dest.Write")); } catch (Exception exception1) { exception = exception1; } if (exception == null) { yield return(asyncResult1); try { destination.EndWrite(asyncResult1); } catch (Exception exception2) { exception = exception2; } } } if (numBytes <= (long)0) { num = (long)0; } else { yield return(asyncResult); num = (long)source.EndRead(asyncResult); } if (exception != null) { throw ExceptionCloner.AttemptClone(exception, RethrowableWrapperBehavior.NoWrap); } if (num < (long)0) { break; } numBytes -= num; AsyncIteratorContext <long> resultData = context; resultData.ResultData = resultData.ResultData + num; if (computeCrcMethodForCrcLogging != null) { computeCrcMethodForCrcLogging(buffer.Buffer, 0, (int)num, context.ResultData); } AsyncStreamCopy.Swap <BufferWrapper>(ref buffer, ref bufferWrapper); if (num <= (long)0) { goto Label2; } } throw new TimeoutException("Reading from the stream resulted in a negative number of bytes read. This typically means an HttpWebRequest was aborted."); } finally { if (buffer != null) { BufferPool.ReleaseBuffer(buffer); } if (bufferWrapper != null) { BufferPool.ReleaseBuffer(bufferWrapper); } } Label2: yield break; throw new TimeoutException("The asynchronous stream copy timed out."); throw ExceptionCloner.AttemptClone(exception, RethrowableWrapperBehavior.NoWrap); }
static BufferPool() { BufferPool.EmptyByteBuffer = new EmptyBufferWrapper(); }
public void ReleaseBuffer(BufferWrapper bufferWrapper) { BufferPool.ReleaseBuffer(bufferWrapper); }