public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { IAsyncResult result2; this.EnsureDecompressionMode(); if (this.asyncOperations != 0) { throw new InvalidOperationException("Only one asynchronous reader is allowed time at one time."); } Interlocked.Increment(ref this.asyncOperations); try { this.ValidateParameters(array, offset, count); DeflateStreamAsyncResult state = new DeflateStreamAsyncResult(this, asyncState, asyncCallback, array, offset, count); state.isWrite = false; int result = this.inflater.Inflate(array, offset, count); if (result != 0) { state.InvokeCallback(true, result); return state; } if (this.inflater.Finished()) { state.InvokeCallback(true, 0); return state; } this._stream.BeginRead(this.buffer, 0, this.buffer.Length, this.m_CallBack, state); state.m_CompletedSynchronously &= state.IsCompleted; result2 = state; } catch { Interlocked.Decrement(ref this.asyncOperations); throw; } return result2; }
public override IAsyncResult BeginWrite(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { EnsureCompressionMode(); if (asyncOperations != 0) { throw new InvalidOperationException(SR.GetString(SR.InvalidBeginCall)); } Interlocked.Increment(ref asyncOperations); try { ValidateParameters(array, offset, count); DeflateStreamAsyncResult userResult = new DeflateStreamAsyncResult( this, asyncState, asyncCallback, array, offset, count); userResult.isWrite = true; m_AsyncWriterDelegate.BeginInvoke(array, offset, count, true, m_CallBack, userResult); userResult.m_CompletedSynchronously &= userResult.IsCompleted; return(userResult); } catch { Interlocked.Decrement(ref asyncOperations); throw; } }
private void ReadCallback(IAsyncResult baseStreamResult) { DeflateStreamAsyncResult asyncState = (DeflateStreamAsyncResult)baseStreamResult.AsyncState; asyncState.m_CompletedSynchronously &= baseStreamResult.CompletedSynchronously; int length = 0; try { length = this._stream.EndRead(baseStreamResult); } catch (Exception exception) { asyncState.InvokeCallback(exception); return; } if (length > 0) { this.inflater.SetInput(this.buffer, 0, length); length = this.inflater.Inflate(asyncState.buffer, asyncState.offset, asyncState.count); if ((length == 0) && !this.inflater.Finished()) { this._stream.BeginRead(this.buffer, 0, this.buffer.Length, this.m_CallBack, asyncState); } else { asyncState.InvokeCallback(length); } } else { asyncState.InvokeCallback(0); } }
public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { IAsyncResult result2; this.EnsureDecompressionMode(); if (this.asyncOperations != 0) { throw new InvalidOperationException("Only one asynchronous reader is allowed time at one time."); } Interlocked.Increment(ref this.asyncOperations); try { this.ValidateParameters(array, offset, count); DeflateStreamAsyncResult state = new DeflateStreamAsyncResult(this, asyncState, asyncCallback, array, offset, count); state.isWrite = false; int result = this.inflater.Inflate(array, offset, count); if (result != 0) { state.InvokeCallback(true, result); return(state); } if (this.inflater.Finished()) { state.InvokeCallback(true, 0); return(state); } this._stream.BeginRead(this.buffer, 0, this.buffer.Length, this.m_CallBack, state); state.m_CompletedSynchronously &= state.IsCompleted; result2 = state; } catch { Interlocked.Decrement(ref this.asyncOperations); throw; } return(result2); }
private void AwaitAsyncResultCompletion(DeflateStreamAsyncResult asyncResult) { try { if (!asyncResult.IsCompleted) { asyncResult.AsyncWaitHandle.WaitOne(); } } finally { Interlocked.Decrement(ref asyncOperations); asyncResult.Close(); // this will just close the wait handle } }
private void WriteCallback(IAsyncResult asyncResult) { DeflateStreamAsyncResult asyncState = (DeflateStreamAsyncResult)asyncResult.AsyncState; asyncState.m_CompletedSynchronously &= asyncResult.CompletedSynchronously; try { this.m_AsyncWriterDelegate.EndInvoke(asyncResult); } catch (Exception exception) { asyncState.InvokeCallback(exception); return; } asyncState.InvokeCallback(null); }
// Callback function for asynchrous reading on base stream private void WriteCallback(IAsyncResult asyncResult) { DeflateStreamAsyncResult outerResult = (DeflateStreamAsyncResult)asyncResult.AsyncState; outerResult.m_CompletedSynchronously &= asyncResult.CompletedSynchronously; try { m_AsyncWriterDelegate.EndInvoke(asyncResult); } catch (Exception exc) { // Defer throwing this until EndWrite where there is user code on the stack: outerResult.InvokeCallback(exc); return; } outerResult.InvokeCallback(null); }
public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { EnsureDecompressionMode(); // We use this checking order for compat to earlier versions: if (asyncOperations != 0) { throw new InvalidOperationException(SR.GetString(SR.InvalidBeginCall)); } ValidateParameters(array, offset, count); EnsureNotDisposed(); Interlocked.Increment(ref asyncOperations); try { DeflateStreamAsyncResult userResult = new DeflateStreamAsyncResult( this, asyncState, asyncCallback, array, offset, count); userResult.isWrite = false; // Try to read decompressed data in output buffer int bytesRead = inflater.Inflate(array, offset, count); if (bytesRead != 0) { // If decompression output buffer is not empty, return immediately. // 'true' means we complete synchronously. userResult.InvokeCallback(true, (object)bytesRead); return(userResult); } if (inflater.Finished()) { // end of compression stream userResult.InvokeCallback(true, (object)0); return(userResult); } // If there is no data on the output buffer and we are not at // the end of the stream, we need to get more data from the base stream _stream.BeginRead(buffer, 0, buffer.Length, m_CallBack, userResult); userResult.m_CompletedSynchronously &= userResult.IsCompleted; return(userResult); } catch { Interlocked.Decrement(ref asyncOperations); throw; } }
public override int EndRead(IAsyncResult asyncResult) { EnsureDecompressionMode(); if (asyncOperations != 1) { throw new InvalidOperationException(SR.GetString(SR.InvalidEndCall)); } if (asyncResult == null) { throw new ArgumentNullException("asyncResult"); } if (_stream == null) { throw new InvalidOperationException(SR.GetString(SR.ObjectDisposed_StreamClosed)); } DeflateStreamAsyncResult myResult = asyncResult as DeflateStreamAsyncResult; if (myResult == null) { throw new ArgumentNullException("asyncResult"); } try { if (!myResult.IsCompleted) { myResult.AsyncWaitHandle.WaitOne(); } } finally { Interlocked.Decrement(ref asyncOperations); // this will just close the wait handle myResult.Close(); } if (myResult.Result is Exception) { throw (Exception)(myResult.Result); } return((int)myResult.Result); }
public override void EndWrite(IAsyncResult asyncResult) { EnsureCompressionMode(); CheckEndXxxxLegalStateAndParams(asyncResult); // We checked that this will work in CheckEndXxxxLegalStateAndParams: DeflateStreamAsyncResult deflateStrmAsyncResult = (DeflateStreamAsyncResult)asyncResult; AwaitAsyncResultCompletion(deflateStrmAsyncResult); Exception previousException = deflateStrmAsyncResult.Result as Exception; if (previousException != null) { // Rethrowing will delete the stack trace. Let's help future debuggers: //previousException.Data.Add(OrigStackTrace_ExceptionDataKey, previousException.StackTrace); throw previousException; } }
// callback function for asynchrous reading on base stream private void ReadCallback(IAsyncResult baseStreamResult) { DeflateStreamAsyncResult outerResult = (DeflateStreamAsyncResult)baseStreamResult.AsyncState; outerResult.m_CompletedSynchronously &= baseStreamResult.CompletedSynchronously; int bytesRead = 0; try { EnsureNotDisposed(); bytesRead = _stream.EndRead(baseStreamResult); if (bytesRead <= 0) { // This indicates the base stream has received EOF outerResult.InvokeCallback((object)0); return; } // Feed the data from base stream into decompression engine inflater.SetInput(buffer, 0, bytesRead); bytesRead = inflater.Inflate(outerResult.buffer, outerResult.offset, outerResult.count); if (bytesRead == 0 && !inflater.Finished()) { // We could have read in head information and didn't get any data. // Read from the base stream again. // Need to solve recusion. _stream.BeginRead(buffer, 0, buffer.Length, m_CallBack, outerResult); } else { outerResult.InvokeCallback((object)bytesRead); } } catch (Exception exc) { // Defer throwing this until EndRead where we will likely have user code on the stack. outerResult.InvokeCallback(exc); return; } }
public override int EndRead(IAsyncResult asyncResult) { this.EnsureDecompressionMode(); if (this.asyncOperations != 1) { throw new InvalidOperationException(SR.GetString("InvalidEndCall")); } if (asyncResult == null) { throw new ArgumentNullException("asyncResult"); } if (this._stream == null) { throw new InvalidOperationException(SR.GetString("ObjectDisposed_StreamClosed")); } DeflateStreamAsyncResult result = asyncResult as DeflateStreamAsyncResult; if (result == null) { throw new ArgumentNullException("asyncResult"); } try { if (!result.IsCompleted) { result.AsyncWaitHandle.WaitOne(); } } finally { Interlocked.Decrement(ref this.asyncOperations); result.Close(); } if (result.Result is Exception) { throw ((Exception)result.Result); } return((int)result.Result); }
private void CheckEndXxxxLegalStateAndParams(IAsyncResult asyncResult) { if (asyncOperations != 1) { throw new InvalidOperationException(SR.GetString(SR.InvalidEndCall)); } if (asyncResult == null) { throw new ArgumentNullException("asyncResult"); } EnsureNotDisposed(); DeflateStreamAsyncResult myResult = asyncResult as DeflateStreamAsyncResult; // This should really be an ArgumentException, but we keep this for compat to previous versions: if (myResult == null) { throw new ArgumentNullException("asyncResult"); } }
public override int EndRead(IAsyncResult asyncResult) { this.EnsureDecompressionMode(); if (this.asyncOperations != 1) { throw new InvalidOperationException("Only one asynchronous reader is allowed time at one time."); } if (asyncResult == null) { throw new ArgumentNullException("asyncResult"); } if (this._stream == null) { throw new InvalidOperationException("Can not access a closed Stream."); } DeflateStreamAsyncResult result = asyncResult as DeflateStreamAsyncResult; if (result == null) { throw new ArgumentNullException("asyncResult"); } try { if (!result.IsCompleted) { result.AsyncWaitHandle.WaitOne(); } } finally { Interlocked.Decrement(ref this.asyncOperations); result.Close(); } if (result.Result is Exception) { throw ((Exception)result.Result); } return((int)result.Result); }
public override IAsyncResult BeginWrite(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { IAsyncResult result2; this.EnsureCompressionMode(); if (this.asyncOperations != 0) { throw new InvalidOperationException("Only one asynchronous reader is allowed time at one time."); } Interlocked.Increment(ref this.asyncOperations); try { this.ValidateParameters(array, offset, count); DeflateStreamAsyncResult result = new DeflateStreamAsyncResult(this, asyncState, asyncCallback, array, offset, count); result.isWrite = true; this.m_AsyncWriterDelegate.BeginInvoke(array, offset, count, true, this.m_CallBack, result); result.m_CompletedSynchronously &= result.IsCompleted; result2 = result; } catch { Interlocked.Decrement(ref this.asyncOperations); throw; } return(result2); }
private void AwaitAsyncResultCompletion(DeflateStreamAsyncResult asyncResult) { try { if (!asyncResult.IsCompleted) asyncResult.AsyncWaitHandle.WaitOne(); } finally { Interlocked.Decrement(ref asyncOperations); asyncResult.Close(); // this will just close the wait handle } }
public override IAsyncResult BeginWrite(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { EnsureCompressionMode(); // We use this checking order for compat to earlier versions: if (asyncOperations != 0 ) throw new InvalidOperationException(SR.GetString(SR.InvalidBeginCall)); ValidateParameters(array, offset, count); EnsureNotDisposed(); Interlocked.Increment(ref asyncOperations); try { DeflateStreamAsyncResult userResult = new DeflateStreamAsyncResult( this, asyncState, asyncCallback, array, offset, count); userResult.isWrite = true; m_AsyncWriterDelegate.BeginInvoke(array, offset, count, true, m_CallBack, userResult); userResult.m_CompletedSynchronously &= userResult.IsCompleted; return userResult; } catch { Interlocked.Decrement(ref asyncOperations); throw; } }
public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { EnsureDecompressionMode(); // We use this checking order for compat to earlier versions: if (asyncOperations != 0) throw new InvalidOperationException(SR.GetString(SR.InvalidBeginCall)); ValidateParameters(array, offset, count); EnsureNotDisposed(); Interlocked.Increment(ref asyncOperations); try { DeflateStreamAsyncResult userResult = new DeflateStreamAsyncResult( this, asyncState, asyncCallback, array, offset, count); userResult.isWrite = false; // Try to read decompressed data in output buffer int bytesRead = inflater.Inflate(array, offset, count); if( bytesRead != 0) { // If decompression output buffer is not empty, return immediately. // 'true' means we complete synchronously. userResult.InvokeCallback(true, (object) bytesRead); return userResult; } if (inflater.Finished() ) { // end of compression stream userResult.InvokeCallback(true, (object) 0); return userResult; } // If there is no data on the output buffer and we are not at // the end of the stream, we need to get more data from the base stream _stream.BeginRead(buffer, 0, buffer.Length, m_CallBack, userResult); userResult.m_CompletedSynchronously &= userResult.IsCompleted; return userResult; } catch { Interlocked.Decrement( ref asyncOperations); throw; } }
public override IAsyncResult BeginWrite(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState) { IAsyncResult result2; this.EnsureCompressionMode(); if (this.asyncOperations != 0) { throw new InvalidOperationException("Only one asynchronous reader is allowed time at one time."); } Interlocked.Increment(ref this.asyncOperations); try { this.ValidateParameters(array, offset, count); DeflateStreamAsyncResult result = new DeflateStreamAsyncResult(this, asyncState, asyncCallback, array, offset, count); result.isWrite = true; this.m_AsyncWriterDelegate.BeginInvoke(array, offset, count, true, this.m_CallBack, result); result.m_CompletedSynchronously &= result.IsCompleted; result2 = result; } catch { Interlocked.Decrement(ref this.asyncOperations); throw; } return result2; }