// // // private static void ReadCallback(IAsyncResult transportResult) { GlobalLog.Assert(transportResult.AsyncState is FixedSizeReader, "ReadCallback|State type is wrong, expected FixedSizeReader."); if (transportResult.CompletedSynchronously) { return; } FixedSizeReader reader = (FixedSizeReader)transportResult.AsyncState; AsyncProtocolRequest request = reader._Request; // Async completion try { int bytes = reader._Transport.EndRead(transportResult); if (reader.CheckCompletionBeforeNextRead(bytes)) { return; } reader.StartReading(); } catch (Exception e) { if (request.IsUserCompleted) { throw; } request.CompleteWithError(e); } }
private static void ReadCallback(IAsyncResult transportResult) { if (!transportResult.CompletedSynchronously) { FixedSizeReader asyncState = (FixedSizeReader)transportResult.AsyncState; AsyncProtocolRequest request = asyncState._Request; try { int bytes = asyncState._Transport.EndRead(transportResult); if (!asyncState.CheckCompletionBeforeNextRead(bytes)) { asyncState.StartReading(); } } catch (Exception exception) { if (request.IsUserCompleted) { throw; } request.CompleteWithError(exception); } } }
private static void ResumeAsyncWriteCallback(AsyncProtocolRequest asyncRequest) { try { SplitWriteAsyncProtocolRequest request = asyncRequest as SplitWriteAsyncProtocolRequest; if (request != null) { ((_SslStream) asyncRequest.AsyncObject).StartWriting(request.SplitWritesState, request); } else { ((_SslStream) asyncRequest.AsyncObject).StartWriting(asyncRequest.Buffer, asyncRequest.Offset, asyncRequest.Count, asyncRequest); } } catch (Exception exception) { if (asyncRequest.IsUserCompleted) { throw; } ((_SslStream) asyncRequest.AsyncObject)._SslState.FinishWrite(); asyncRequest.CompleteWithError(exception); } }
private static void ResumeAsyncReadCallback(AsyncProtocolRequest request) { try { ((_SslStream) request.AsyncObject).StartReading(request.Buffer, request.Offset, request.Count, request); } catch (Exception exception) { if (request.IsUserCompleted) { throw; } ((_SslStream) request.AsyncObject)._SslState.FinishRead(null); request.CompleteWithError(exception); } }
private static void ReadHeaderCallback(AsyncProtocolRequest asyncRequest) { try { _SslStream asyncObject = (_SslStream) asyncRequest.AsyncObject; BufferAsyncResult userAsyncResult = (BufferAsyncResult) asyncRequest.UserAsyncResult; if (-1 == asyncObject.StartFrameBody(asyncRequest.Result, userAsyncResult.Buffer, userAsyncResult.Offset, userAsyncResult.Count, asyncRequest)) { asyncObject.StartReading(userAsyncResult.Buffer, userAsyncResult.Offset, userAsyncResult.Count, asyncRequest); } } catch (Exception exception) { if (asyncRequest.IsUserCompleted) { throw; } asyncRequest.CompleteWithError(exception); } }
private void FinishHandshake(Exception e, AsyncProtocolRequest asyncRequest) { try { lock (this) { if (e != null) { this.SetException(e); } this.FinishHandshakeRead(0); if (Interlocked.CompareExchange(ref this._LockWriteState, 0, 2) == 3) { this._LockWriteState = 1; object state = this._QueuedWriteStateRequest; if (state != null) { this._QueuedWriteStateRequest = null; if (state is LazyAsyncResult) { ((LazyAsyncResult) state).InvokeCallback(); } else { ThreadPool.QueueUserWorkItem(new WaitCallback(this.CompleteRequestWaitCallback), state); } } } } } finally { if (asyncRequest != null) { if (e != null) { asyncRequest.CompleteWithError(e); } else { asyncRequest.CompleteUser(); } } } }