public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult <int>(callback, state);
IDisposable registration = CancellationToken.SafeRegister(asyncResult =>
{
lock (_completedLock)
{
if (!asyncResult.IsCompleted)
{
asyncResult.SetAsCompleted(0, false);
}
}
},
ar);
// If a write occurs after a synchronous read attempt and before the writeHandler is attached,
// the writeHandler could miss a write.
lock (_writeLock)
{
int read = Read(buffer, offset, count);
if (read != 0)
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
ar.SetAsCompleted(read, true);
registration.Dispose();
}
}
}
else
{
Action writeHandler = null;
writeHandler = () =>
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
read = Read(buffer, offset, count);
ar.SetAsCompleted(read, false);
registration.Dispose();
}
_onWrite -= writeHandler;
}
};
_onWrite += writeHandler;
}
}
return(ar);
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult <int>(callback, state, _cancelTokenSource.Token);
_reader.Read(completedSynchronously =>
{
// Try to read synchronously
int read = ReadBuffer(buffer, offset, count);
// If we're at the end of the stream or we've read some data then return it
ar.SetAsCompleted(read, completedSynchronously);
});
return(ar);
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult<int>(callback, state);
Action closedHandler = null;
closedHandler = () =>
{
lock (_lockObj)
{
if (!ar.IsCompleted)
{
// Set the response to 0 if we've closed
ar.SetAsCompleted(0, false);
}
_onClosed -= closedHandler;
}
};
_onClosed += closedHandler;
if (CancellationToken.IsCancellationRequested)
{
ar.SetAsCompleted(0, true);
return ar;
}
int read = Read(buffer, offset, count);
if (read != 0 || CancellationToken.IsCancellationRequested)
{
lock (_lockObj)
{
if (!ar.IsCompleted)
{
ar.SetAsCompleted(read, true);
}
}
}
else
{
Action writeHandler = null;
writeHandler = () =>
{
lock (_lockObj)
{
if (!ar.IsCompleted)
{
read = Read(buffer, offset, count);
ar.SetAsCompleted(read, false);
}
_onWrite -= writeHandler;
}
};
_onWrite += writeHandler;
}
return ar;
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult<int>(callback, state, _cancelTokenSource.Token);
_reader.Read(completedSynchronously =>
{
// Try to read synchronously
int read = ReadBuffer(buffer, offset, count);
// If we're at the end of the stream or we've read some data then return it
ar.SetAsCompleted(read, completedSynchronously);
});
return ar;
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult <int>(callback, state);
Action closedHandler = null;
closedHandler = () =>
{
lock (_lockObj)
{
if (!ar.IsCompleted)
{
// Set the response to 0 if we've closed
ar.SetAsCompleted(0, false);
}
_onClosed -= closedHandler;
}
};
_onClosed += closedHandler;
if (CancellationToken.IsCancellationRequested)
{
ar.SetAsCompleted(0, true);
return(ar);
}
int read = Read(buffer, offset, count);
if (read != 0 || CancellationToken.IsCancellationRequested)
{
lock (_lockObj)
{
if (!ar.IsCompleted)
{
ar.SetAsCompleted(read, true);
}
}
}
else
{
Action writeHandler = null;
writeHandler = () =>
{
lock (_lockObj)
{
if (!ar.IsCompleted)
{
read = Read(buffer, offset, count);
ar.SetAsCompleted(read, false);
}
_onWrite -= writeHandler;
}
};
_onWrite += writeHandler;
}
return(ar);
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult<int>(callback, state);
IDisposable registration = CancellationToken.SafeRegister(asyncResult =>
{
lock (_completedLock)
{
if (!asyncResult.IsCompleted)
{
asyncResult.SetAsCompleted(0, false);
}
}
},
ar);
// If a write occurs after a synchronous read attempt and before the writeHandler is attached,
// the writeHandler could miss a write.
lock (_writeLock)
{
int read = Read(buffer, offset, count);
if (read != 0)
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
ar.SetAsCompleted(read, true);
registration.Dispose();
}
}
}
else
{
Action writeHandler = null;
writeHandler = () =>
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
read = Read(buffer, offset, count);
ar.SetAsCompleted(read, false);
registration.Dispose();
}
_onWrite -= writeHandler;
}
};
_onWrite += writeHandler;
}
}
return ar;
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult <int>(callback, state);
Action closedHandler = null;
closedHandler = () =>
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
// Set the response to 0 if we've closed
ar.SetAsCompleted(0, false);
}
_onClosed -= closedHandler;
}
};
_onClosed += closedHandler;
if (CancellationToken.IsCancellationRequested)
{
ar.SetAsCompleted(0, true);
return(ar);
}
// If a write occurs after a synchronous read attempt and before the writeHandler is attached,
// the writeHandler could miss a write.
lock (_writeLock)
{
int read = Read(buffer, offset, count);
if (read != 0 || CancellationToken.IsCancellationRequested)
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
ar.SetAsCompleted(read, true);
}
}
}
else
{
Action writeHandler = null;
writeHandler = () =>
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
read = Read(buffer, offset, count);
ar.SetAsCompleted(read, false);
}
_onWrite -= writeHandler;
}
};
_onWrite += writeHandler;
}
}
return(ar);
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
var ar = new AsyncResult<int>(callback, state);
Action closedHandler = null;
closedHandler = () =>
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
// Set the response to 0 if we've closed
ar.SetAsCompleted(0, false);
}
_onClosed -= closedHandler;
}
};
_onClosed += closedHandler;
if (CancellationToken.IsCancellationRequested)
{
ar.SetAsCompleted(0, true);
return ar;
}
// If a write occurs after a synchronous read attempt and before the writeHandler is attached,
// the writeHandler could miss a write.
lock (_writeLock)
{
int read = Read(buffer, offset, count);
if (read != 0 || CancellationToken.IsCancellationRequested)
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
ar.SetAsCompleted(read, true);
}
}
}
else
{
Action writeHandler = null;
writeHandler = () =>
{
lock (_completedLock)
{
if (!ar.IsCompleted)
{
read = Read(buffer, offset, count);
ar.SetAsCompleted(read, false);
}
_onWrite -= writeHandler;
}
};
_onWrite += writeHandler;
}
}
return ar;
}