public override int EndRead(IAsyncResult asyncResult)
{
if (Interlocked.Decrement(ref m_ReadNesting) != 0)
{
Interlocked.Increment(ref m_ReadNesting);
throw new InvalidOperationException(SR.GetString(SR.net_io_invalidendcall, "EndRead"));
}
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
InnerAsyncResult myResult = asyncResult as InnerAsyncResult;
if (myResult == null)
{
// We are just passing IO down, although m_HeadEOF should be always true here.
GlobalLog.Assert(m_HeadEOF, "CombinedReadStream::EndRead|m_HeadEOF is false and asyncResult is not of InnerAsyncResult type {0).", asyncResult.GetType().FullName);
return(m_HeadEOF? WrappedStream.EndRead(asyncResult): m_HeadStream.EndRead(asyncResult));
}
// this is our wrapped AsyncResult
myResult.InternalWaitForCompletion();
// Exception?
if (myResult.Result is Exception)
{
throw (Exception)(myResult.Result);
}
// Report the count read
return((int)myResult.Result);
}
public override int EndRead(IAsyncResult asyncResult)
{
int result = WrappedStream.EndRead(asyncResult);
m_Position += result;
return(result);
}
public override int EndRead(IAsyncResult asyncResult)
{
if (Interlocked.Decrement(ref m_ReadNesting) != 0)
{
Interlocked.Increment(ref m_ReadNesting);
throw new InvalidOperationException(SR.GetString(SR.net_io_invalidendcall, "EndRead"));
}
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
InnerAsyncResult myResult = asyncResult as InnerAsyncResult;
if (myResult == null)
{
// We are just passing IO down, although the shadow stream should be dead for now.
GlobalLog.Assert(m_ShadowStreamIsDead, "ForwardingReadStream::EndRead|m_ShadowStreamIsDead is false and asyncResult is not of InnerAsyncResult type {0}.", asyncResult.GetType().FullName);
int bytes = WrappedStream.EndRead(asyncResult);
if (bytes == 0)
{
m_SeenReadEOF = true;
}
}
// this is our wrapped AsyncResult
bool suceess = false;
try {
myResult.InternalWaitForCompletion();
// Exception?
if (myResult.Result is Exception)
{
throw (Exception)(myResult.Result);
}
suceess = true;
}
finally {
if (!suceess && !m_ShadowStreamIsDead)
{
m_ShadowStreamIsDead = true;
if (m_ShadowStream is ICloseEx)
{
((ICloseEx)m_ShadowStream).CloseEx(CloseExState.Abort | CloseExState.Silent);
}
else
{
m_ShadowStream.Close();
}
}
}
// Report the read count
return((int)myResult.Result);
}
private void ReadCallback(IAsyncResult transportResult)
{
GlobalLog.Assert(transportResult.AsyncState is InnerAsyncResult, "InnerAsyncResult::ReadCallback|The state expected to be of type InnerAsyncResult, received {0}.", transportResult.GetType().FullName);
if (transportResult.CompletedSynchronously)
{
return;
}
InnerAsyncResult userResult = transportResult.AsyncState as InnerAsyncResult;
try {
// Complete transport IO, in this callback that is always the head stream
int count;
if (!m_HeadEOF)
{
count = m_HeadStream.EndRead(transportResult);
m_HeadLength += count;
}
else
{
count = WrappedStream.EndRead(transportResult);
}
//check on EOF condition
if (!m_HeadEOF && count == 0 && userResult.Count != 0)
{
//Got a first stream EOF
m_HeadEOF = true;
m_HeadStream.Close();
IAsyncResult ar = WrappedStream.BeginRead(userResult.Buffer, userResult.Offset, userResult.Count, m_ReadCallback, userResult);
if (!ar.CompletedSynchronously)
{
return;
}
count = WrappedStream.EndRead(ar);
}
// just complete user IO
userResult.Buffer = null;
userResult.InvokeCallback(count);
}
catch (Exception e) {
//ASYNC: try to ignore even serious exceptions (nothing to loose?)
if (userResult.InternalPeekCompleted)
{
throw;
}
userResult.InvokeCallback(e);
}
}
/// <summary>
/// Waits for the pending asynchronous read to complete.
/// </summary>
public override int EndRead(IAsyncResult asyncResult)
{
ThrowIfDisposed();
return(WrappedStream.EndRead(asyncResult));
}
public async Task Parameterized_Methods_Are_Properly_Wrapped()
{
var strm = Substitute.For <Stream>();
using (var wrprstrm = new WrappedStream(strm, false))
{
wrprstrm.Seek(0, SeekOrigin.Current);
strm.Received(1).Seek(0, SeekOrigin.Current);
wrprstrm.SetLength(10);
strm.Received(1).SetLength(10);
var arrByte = new byte[5];
wrprstrm.Read(arrByte, 0, arrByte.Length);
strm.Received(1).Read(arrByte, 0, arrByte.Length);
wrprstrm.Write(arrByte, 0, arrByte.Length);
strm.Received(1).Write(arrByte, 0, arrByte.Length);
var anotherStrm = new MemoryStream();
await wrprstrm.CopyToAsync(anotherStrm, 1, CancellationToken.None).ConfigureAwait(false);
await strm.Received(1).CopyToAsync(anotherStrm, 1, CancellationToken.None).ConfigureAwait(false);
await wrprstrm.FlushAsync(CancellationToken.None).ConfigureAwait(false);
await strm.Received(1).FlushAsync(CancellationToken.None).ConfigureAwait(false);
await wrprstrm.WriteAsync(arrByte, 1, arrByte.Length, CancellationToken.None).ConfigureAwait(false);
await strm.Received(1)
.WriteAsync(arrByte, 1, arrByte.Length, CancellationToken.None)
.ConfigureAwait(false);
await wrprstrm.ReadAsync(arrByte, 1, arrByte.Length, CancellationToken.None).ConfigureAwait(false);
await strm.Received(1)
.ReadAsync(arrByte, 1, arrByte.Length, CancellationToken.None)
.ConfigureAwait(false);
var cb = new AsyncCallback(ar => { });
var result = wrprstrm.BeginRead(arrByte, 0, arrByte.Length, cb, null);
strm.Received(1).BeginRead(arrByte, 0, arrByte.Length, cb, null);
wrprstrm.BeginWrite(arrByte, 0, arrByte.Length, cb, null);
strm.Received(1).BeginWrite(arrByte, 0, arrByte.Length, cb, null);
#if FEATURE_REMOTING
wrprstrm.CreateObjRef(null);
strm.Received(1).CreateObjRef(null);
wrprstrm.InitializeLifetimeService();
strm.Received(1).InitializeLifetimeService();
#else
Assert.True(Assert.Throws <RemotingException>(() => wrprstrm.CreateObjRef(null))
.Message.Equals(WrappedStream.RemotingErrorTxt));
Assert.True(Assert.Throws <RemotingException>(() => wrprstrm.InitializeLifetimeService())
.Message.Equals(WrappedStream.RemotingErrorTxt));
#endif
wrprstrm.EndRead(result);
strm.Received(1).EndRead(result);
wrprstrm.EndWrite(result);
strm.Received(1).EndWrite(result);
wrprstrm.WriteByte(20);
strm.Received(1).WriteByte(20);
wrprstrm.Equals(null);
strm.Received(1).Equals(null);
}
}
private void ReadComplete(IAsyncResult transportResult)
{
while (true)
{
// Recover our asyncResult
InnerAsyncResult userResult = transportResult.AsyncState as InnerAsyncResult;
try
{
if (!userResult.IsWriteCompletion)
{
userResult.Count = WrappedStream.EndRead(transportResult);
if (userResult.Count == 0)
{
m_SeenReadEOF = true;
}
if (!m_ShadowStreamIsDead)
{
userResult.IsWriteCompletion = true;
//Optionally charge notification write IO
transportResult = m_ShadowStream.BeginWrite(userResult.Buffer, userResult.Offset, userResult.Count, m_ReadCallback, userResult);
if (transportResult.CompletedSynchronously)
{
continue;
}
return;
}
}
else
{
GlobalLog.Assert(!m_ShadowStreamIsDead, "ForwardingReadStream::ReadComplete|ERROR: IsWriteCompletion && m_ShadowStreamIsDead");
m_ShadowStream.EndWrite(transportResult);
userResult.IsWriteCompletion = false;
}
}
catch (Exception e)
{
//ASYNC: try to ignore even serious exceptions (nothing to loose?)
if (userResult.InternalPeekCompleted)
{
GlobalLog.Print("ShadowReadStream::ReadComplete() Rethrowing Exception (end), userResult.IsCompleted, stack trace = " + e.ToString());
throw;
}
try
{
m_ShadowStreamIsDead = true;
if (m_ShadowStream is ICloseEx)
{
((ICloseEx)m_ShadowStream).CloseEx(CloseExState.Abort | CloseExState.Silent);
}
else
{
m_ShadowStream.Close();
}
}
catch (Exception ee)
{
//ASYNC: Again try to ignore even serious exceptions
GlobalLog.Print("ShadowReadStream::ReadComplete() Got (ignoring) Exception, on shadow stream.Close, stack trace = " + ee.ToString());
}
if (!userResult.IsWriteCompletion || m_ThrowOnWriteError)
{
if (transportResult.CompletedSynchronously)
{
throw;
}
userResult.InvokeCallback(e);
return;
}
}
// Need to process, re-issue the read.
try
{
if (m_BytesToSkip != 0L)
{
m_BytesToSkip -= userResult.Count;
userResult.Count = m_BytesToSkip < (long)userResult.Buffer.Length? (int)m_BytesToSkip: userResult.Buffer.Length;
if (m_BytesToSkip == 0L)
{
// we did hide the original IO request in the outer iaresult state.
// charge the real user operation now
transportResult = userResult;
userResult = userResult.AsyncState as InnerAsyncResult;
GlobalLog.Assert(userResult != null, "ForwardingReadStream::ReadComplete|ERROR: Inner IAResult is null after stream FastForwarding.");
}
transportResult = WrappedStream.BeginRead(userResult.Buffer, userResult.Offset, userResult.Count, m_ReadCallback, userResult);
if (transportResult.CompletedSynchronously)
{
continue;
}
return;
}
//if came to here, complete original user IO
userResult.InvokeCallback(userResult.Count);
return;
}
catch (Exception e)
{
//ASYNC: try to ignore even serious exceptions (nothing to loose?)
if (userResult.InternalPeekCompleted)
{
GlobalLog.Print("ShadowReadStream::ReadComplete() Rethrowing Exception (begin), userResult.IsCompleted, stack trace = " + e.ToString());
throw;
}
try
{
m_ShadowStreamIsDead = true;
if (m_ShadowStream is ICloseEx)
{
((ICloseEx)m_ShadowStream).CloseEx(CloseExState.Abort | CloseExState.Silent);
}
else
{
m_ShadowStream.Close();
}
}
catch (Exception ee)
{
//ASYNC: Again try to ignore even serious exceptions
GlobalLog.Print("ShadowReadStream::ReadComplete() Got (ignoring) Exception, on shadow stream.Close (after begin), stack trace = " + ee.ToString());
}
if (transportResult.CompletedSynchronously)
{
throw;
}
// This will set the exception result first then try to execute a user callback
userResult.InvokeCallback(e);
return;
}
}
}
public override int EndRead(IAsyncResult asyncResult)
{
return(WrappedStream.EndRead(asyncResult));
}
