Process()

async Task< WebSocketReceiveResult > System.Net.WebSockets.WebSocketBase.WebSocketOperation.Process ( ArraySegment< byte >? buffer, CancellationToken cancellationToken )

inlinepackageinherited

Definition at line 271 of file WebSocketBase.cs.

        {
            bool sessionHandleLockTaken = false;
            AsyncOperationCompleted = false;
            ReceiveResult = null;
            try
            {
                Monitor.Enter(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                _webSocket.ThrowIfPendingException();
                Initialize(buffer, cancellationToken);
                while (ShouldContinue(cancellationToken))
                {
                    bool completed = false;
                    while (!completed)
                    {
                        global::Interop.WebSocket.Buffer[] array = new global::Interop.WebSocket.Buffer[BufferCount];
                        uint dataBufferCount = (uint)BufferCount;
                        _webSocket.ThrowIfDisposed();
                        WebSocketProtocolComponent.WebSocketGetAction(_webSocket, ActionQueue, array, ref dataBufferCount, out var action, out var bufferType, out var actionContext);
                        switch (action)
                        {
                        case WebSocketProtocolComponent.Action.NoAction:
                            if (ProcessAction_NoAction())
                            {
                                bool thisLockTaken = false;
                                try
                                {
                                    if (_webSocket.StartOnCloseReceived(ref thisLockTaken))
                                    {
                                        ReleaseLock(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                                        bool flag;
                                        try
                                        {
                                            flag = await _webSocket.StartOnCloseCompleted(thisLockTaken, sessionHandleLockTaken, cancellationToken).SuppressContextFlow();
                                        }
                                        catch (Exception)
                                        {
                                            _webSocket.ResetFlagAndTakeLock(_webSocket._thisLock, ref thisLockTaken);
                                            throw;
                                        }
                                        if (flag)
                                        {
                                            _webSocket.ResetFlagAndTakeLock(_webSocket._thisLock, ref thisLockTaken);
                                            _webSocket.FinishOnCloseCompleted();
                                        }
                                    }
                                    _webSocket.FinishOnCloseReceived(ReceiveResult.CloseStatus.Value, ReceiveResult.CloseStatusDescription);
                                }
                                finally
                                {
                                    if (thisLockTaken)
                                    {
                                        ReleaseLock(_webSocket._thisLock, ref thisLockTaken);
                                    }
                                }
                            }
                            completed = true;
                            break;
                        case WebSocketProtocolComponent.Action.IndicateReceiveComplete:
                            ProcessAction_IndicateReceiveComplete(buffer, bufferType, action, array, dataBufferCount, actionContext);
                            break;
                        case WebSocketProtocolComponent.Action.ReceiveFromNetwork:
                        {
                            int count = 0;
                            try
                            {
                                ArraySegment<byte> arraySegment = _webSocket._internalBuffer.ConvertNativeBuffer(action, array[0], bufferType);
                                ReleaseLock(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                                HttpWebSocket.ThrowIfConnectionAborted(_webSocket._innerStream, read: true);
                                try
                                {
                                    Task<int> task = _webSocket._innerStream.ReadAsync(arraySegment.Array, arraySegment.Offset, arraySegment.Count, cancellationToken);
                                    count = await task.SuppressContextFlow();
                                    _webSocket._keepAliveTracker.OnDataReceived();
                                }
                                catch (ObjectDisposedException innerException)
                                {
                                    throw new WebSocketException(WebSocketError.ConnectionClosedPrematurely, innerException);
                                }
                                catch (NotSupportedException innerException2)
                                {
                                    throw new WebSocketException(WebSocketError.ConnectionClosedPrematurely, innerException2);
                                }
                                Monitor.Enter(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                                _webSocket.ThrowIfPendingException();
                                if (count == 0)
                                {
                                    throw new WebSocketException(WebSocketError.ConnectionClosedPrematurely);
                                }
                            }
                            finally
                            {
                                WebSocketProtocolComponent.WebSocketCompleteAction(_webSocket, actionContext, count);
                            }
                            break;
                        }
                        case WebSocketProtocolComponent.Action.IndicateSendComplete:
                            WebSocketProtocolComponent.WebSocketCompleteAction(_webSocket, actionContext, 0);
                            AsyncOperationCompleted = true;
                            ReleaseLock(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                            await _webSocket._innerStream.FlushAsync(cancellationToken).SuppressContextFlow();
                            Monitor.Enter(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                            break;
                        case WebSocketProtocolComponent.Action.SendToNetwork:
                        {
                            int bytesSent = 0;
                            try
                            {
                                if ((_webSocket.State != WebSocketState.CloseSent || (bufferType != WebSocketProtocolComponent.BufferType.PingPong && bufferType != WebSocketProtocolComponent.BufferType.UnsolicitedPong)) && dataBufferCount != 0)
                                {
                                    List<ArraySegment<byte>> list = new List<ArraySegment<byte>>((int)dataBufferCount);
                                    int sendBufferSize2 = 0;
                                    ArraySegment<byte> item = _webSocket._internalBuffer.ConvertNativeBuffer(action, array[0], bufferType);
                                    list.Add(item);
                                    sendBufferSize2 += item.Count;
                                    if (dataBufferCount == 2)
                                    {
                                        ArraySegment<byte> item2 = ((!_webSocket._internalBuffer.IsPinnedSendPayloadBuffer(array[1], bufferType)) ? _webSocket._internalBuffer.ConvertNativeBuffer(action, array[1], bufferType) : _webSocket._internalBuffer.ConvertPinnedSendPayloadFromNative(array[1], bufferType));
                                        list.Add(item2);
                                        sendBufferSize2 += item2.Count;
                                    }
                                    ReleaseLock(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                                    HttpWebSocket.ThrowIfConnectionAborted(_webSocket._innerStream, read: false);
                                    await _webSocket.SendFrameAsync(list, cancellationToken).SuppressContextFlow();
                                    Monitor.Enter(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                                    _webSocket.ThrowIfPendingException();
                                    bytesSent += sendBufferSize2;
                                    _webSocket._keepAliveTracker.OnDataSent();
                                }
                            }
                            finally
                            {
                                WebSocketProtocolComponent.WebSocketCompleteAction(_webSocket, actionContext, bytesSent);
                            }
                            break;
                        }
                        default:
                            throw new InvalidOperationException();
                        }
                    }
                    ReleaseLock(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                    Monitor.Enter(_webSocket.SessionHandle, ref sessionHandleLockTaken);
                }
            }
            finally
            {
                Cleanup();
                ReleaseLock(_webSocket.SessionHandle, ref sessionHandleLockTaken);
            }
            return ReceiveResult;
        }

References System.Net.WebSockets.WebSocketBase._innerStream, System.Net.WebSockets.WebSocketBase._internalBuffer, System.Net.WebSockets.WebSocketBase._keepAliveTracker, System.Net.WebSockets.WebSocketBase._thisLock, System.Net.WebSockets.WebSocketBase.WebSocketOperation._webSocket, System.action, System.Net.WebSockets.WebSocketBase.WebSocketOperation.ActionQueue, System.ArraySegment< T >.Add(), System.Collections.Generic.Dictionary< TKey, TValue >.Add(), System.array, System.Net.WebSockets.WebSocketBase.WebSocketOperation.AsyncOperationCompleted, System.buffer, System.Net.WebSockets.WebSocketBase.WebSocketOperation.BufferCount, System.cancellationToken, System.Net.WebSockets.WebSocketBase.WebSocketOperation.Cleanup(), System.Net.WebSockets.WebSocketReceiveResult.CloseStatus, System.Net.WebSockets.WebSocketReceiveResult.CloseStatusDescription, System.Net.WebSockets.WebSocketBuffer.ConvertNativeBuffer(), System.Net.WebSockets.WebSocketBuffer.ConvertPinnedSendPayloadFromNative(), System.count, System.Collections.Generic.Dictionary< TKey, TValue >.Count, System.Threading.Monitor.Enter(), System.Net.WebSockets.WebSocketBase.FinishOnCloseCompleted(), System.Net.WebSockets.WebSocketBase.FinishOnCloseReceived(), System.IO.Stream.FlushAsync(), System.Net.WebSockets.WebSocketBase.WebSocketOperation.Initialize(), System.Net.WebSockets.WebSocketBuffer.IsPinnedSendPayloadBuffer(), System.item, System.list, System.Net.WebSockets.WebSocketBase.KeepAliveTracker.OnDataReceived(), System.Net.WebSockets.WebSocketBase.KeepAliveTracker.OnDataSent(), System.Net.WebSockets.WebSocketBase.WebSocketOperation.ProcessAction_IndicateReceiveComplete(), System.Net.WebSockets.WebSocketBase.WebSocketOperation.ProcessAction_NoAction(), System.IO.Stream.ReadAsync(), System.Net.WebSockets.WebSocketBase.WebSocketOperation.ReceiveResult, System.Net.WebSockets.WebSocketBase.ReleaseLock(), System.Net.WebSockets.WebSocketBase.ResetFlagAndTakeLock(), System.Net.WebSockets.WebSocketBase.SendFrameAsync(), System.Net.WebSockets.WebSocketBase.SessionHandle, System.Net.WebSockets.WebSocketBase.WebSocketOperation.ShouldContinue(), System.Net.WebSockets.WebSocketBase.StartOnCloseCompleted(), System.Net.WebSockets.WebSocketBase.StartOnCloseReceived(), System.Net.WebSockets.WebSocketBase.State, System.task, System.Net.WebSockets.HttpWebSocket.ThrowIfConnectionAborted(), System.Net.WebSockets.WebSocketBase.ThrowIfDisposed(), System.Net.WebSockets.WebSocketBase.ThrowIfPendingException(), System.Net.WebSockets.WebSocketProtocolComponent.WebSocketCompleteAction(), and System.Net.WebSockets.WebSocketProtocolComponent.WebSocketGetAction().