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