public override IAsyncResult BeginWrite(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState)
{
EnsureCompressionMode();
if (asyncOperations != 0)
{
throw new InvalidOperationException("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;
}
}
// 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 EndXxx where we are ensured of user code on the stack.
outerResult.InvokeCallback(exc);
return;
}
outerResult.InvokeCallback(null);
}
public override int EndRead(IAsyncResult asyncResult)
{
EnsureDecompressionMode();
if (asyncOperations != 1)
{
throw new InvalidOperationException("InvalidEndCall");
}
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
if (_stream == null)
{
throw new InvalidOperationException("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 IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback, object asyncState)
{
EnsureDecompressionMode();
if (asyncOperations != 0)
{
throw new InvalidOperationException("InvalidBeginCall");
}
Interlocked.Increment(ref asyncOperations);
try
{
ValidateParameters(array, offset, count);
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;
}
}
// callback function for asynchronous reading on base stream
private void ReadCallback(IAsyncResult baseStreamResult)
{
DeflateStreamAsyncResult outerResult = (DeflateStreamAsyncResult)baseStreamResult.AsyncState;
outerResult.m_CompletedSynchronously &= baseStreamResult.CompletedSynchronously;
int bytesRead = 0;
try
{
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;
}
}
