private Nothing HandleIncomingMessageHeader(IInvocationMessageHeader header, Nothing _)
        {
            switch (_incomingStreamState)
            {
            case IncomingStreamState.Open:
                _incomingStreamState = IncomingStreamState.ReceivingMessage;
                break;

            default:
                throw new InvalidOperationException($"Received unexpected message when in state {_incomingStreamState}: {header}");
            }
            return(Nothing.Instance);
        }
        private Nothing HandleIncomingCompletion(IInvocationSendCompleted completion, Nothing _)
        {
            switch (_incomingStreamState)
            {
            case IncomingStreamState.Open:
                _log.Debug("Incoming message stream completed");
                _incomingStreamState = IncomingStreamState.Completed;
                _buffer.Out.TryComplete();
                break;

            default:
                throw new InvalidOperationException($"Received unexpected message when in state {_incomingStreamState}: {completion}");
            }
            return(Nothing.Instance);
        }
        private async Task HandleIncomingMessageFrameAsync(TransportMessageFrame frame)
        {
            _log.Trace("Consuming message frame: {0}", frame);
            _curIncomingMessage.Write(frame.Payload.Array, frame.Payload.Offset, frame.Payload.Count);
            if (!frame.HasMore)
            {
                _curIncomingMessage.Position = 0;
                var msg = _marshaller.Decode(_curIncomingMessage);
                await _buffer.Out.WriteAsync(msg, CancellationToken).ConfigureAwait(false);

                _log.Debug("Received message of type {0} with length {1}", msg.GetType().Name, _curIncomingMessage.Length);
                _curIncomingMessage.Position = 0;
                _curIncomingMessage.SetLength(0);
                _incomingStreamState = IncomingStreamState.Open;
                var header = _protocol.MessageFactory.CreateInvocationMessageReceived();
                await _sender.WriteOrDisposeAsync(header, CancellationToken).ConfigureAwait(false);
            }
        }
        private async Task HandleIncomingMessageFrameAsync(TransportMessageFrame frame)
        {
            _log.Trace("Consuming message frame: {0}", frame);
            _curIncomingMessage.Write(frame.Payload.Array, frame.Payload.Offset, frame.Payload.Count);
            if (frame.HasMore)
            {
                _log.Trace("Consumed message frame {0}", frame);
            }
            else
            {
                _curIncomingMessage.Position = 0;
                var msg = _marshaller.Decode(_curIncomingMessage);
                _log.Debug("Received message of type {0} with length {1}", msg.GetType().Name, _curIncomingMessage.Length);
                await _buffer.Out.WriteAsync(msg, CancellationToken).ConfigureAwait(false);

                _log.Debug("Received message added to response buffer: type {0} with length {1}", msg.GetType().Name, _curIncomingMessage.Length);
                _curIncomingMessage.Position = 0;
                _curIncomingMessage.SetLength(0);
                _incomingStreamState = IncomingStreamState.Open;
            }
        }