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;
}
