SendAsync()

async Task< HttpResponseMessage > System.Net.Http.Http3RequestStream.SendAsync ( CancellationToken cancellationToken )

inline

Definition at line 252 of file Http3RequestStream.cs.

    {
        bool disposeSelf = true;
        using CancellationTokenSource requestCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _goawayCancellationToken);
        HttpResponseMessage result;
        try
        {
            _ = 4;
            try
            {
                BufferHeaders(_request);
                if (_request.HasHeaders && _request.Headers.ExpectContinue == true)
                {
                    _expect100ContinueCompletionSource = new TaskCompletionSource<bool>();
                }
                if (_expect100ContinueCompletionSource != null || _request.Content == null)
                {
                    await FlushSendBufferAsync(_request.Content == null, requestCancellationSource.Token).ConfigureAwait(continueOnCapturedContext: false);
                }
                HttpContent? content = _request.Content;
                CancellationToken cancellationToken2 = ((content != null && !content.AllowDuplex) ? requestCancellationSource.Token : default(CancellationToken));
                Task sendContentTask = ((_request.Content != null) ? SendContentAsync(_request.Content, cancellationToken2) : Task.CompletedTask);
                Task readResponseTask = ReadResponseAsync(requestCancellationSource.Token);
                bool sendContentObserved = false;
                int num;
                if (!sendContentTask.IsCompleted)
                {
                    HttpContent? content2 = _request.Content;
                    num = ((content2 == null || !content2.AllowDuplex) ? 1 : 0);
                }
                else
                {
                    num = 1;
                }
                bool flag = (byte)num != 0;
                bool flag2 = flag;
                if (!flag2)
                {
                    flag2 = await Task.WhenAny(sendContentTask, readResponseTask).ConfigureAwait(continueOnCapturedContext: false) == sendContentTask;
                }
                if (flag2 || sendContentTask.IsCompleted)
                {
                    try
                    {
                        await sendContentTask.ConfigureAwait(continueOnCapturedContext: false);
                        sendContentObserved = true;
                    }
                    catch
                    {
                        _connection.LogExceptions(readResponseTask);
                        throw;
                    }
                }
                else
                {
                    _connection.LogExceptions(sendContentTask);
                }
                await readResponseTask.ConfigureAwait(continueOnCapturedContext: false);
                Interlocked.Exchange(ref _goawayCancellationSource, null)?.Dispose();
                HttpConnectionResponseContent responseContent = (HttpConnectionResponseContent)_response.Content;
                bool useEmptyResponseContent = responseContent.Headers.ContentLength == 0 && sendContentObserved;
                if (useEmptyResponseContent)
                {
                    await DrainContentLength0Frames(requestCancellationSource.Token).ConfigureAwait(continueOnCapturedContext: false);
                    responseContent.SetStream(EmptyReadStream.Instance);
                }
                else
                {
                    responseContent.SetStream(new Http3ReadStream(this));
                }
                if (_connection.Pool.Settings._useCookies)
                {
                    CookieHelper.ProcessReceivedCookies(_response, _connection.Pool.Settings._cookieContainer);
                }
                HttpResponseMessage response = _response;
                _response = null;
                disposeSelf = useEmptyResponseContent;
                result = response;
            }
            catch (QuicStreamAbortedException ex) when (ex.ErrorCode == 272)
            {
                throw new HttpRequestException(System.SR.net_http_retry_on_older_version, ex, RequestRetryType.RetryOnLowerHttpVersion);
            }
            catch (QuicStreamAbortedException ex2) when (ex2.ErrorCode == 267)
            {
                throw new HttpRequestException(System.SR.net_http_request_aborted, ex2, RequestRetryType.RetryOnConnectionFailure);
            }
            catch (QuicStreamAbortedException ex3)
            {
                Exception abortException = _connection.AbortException;
                throw new HttpRequestException(System.SR.net_http_client_execution_error, abortException ?? ex3);
            }
            catch (QuicConnectionAbortedException abortException2)
            {
                Exception inner = _connection.Abort(abortException2);
                throw new HttpRequestException(System.SR.net_http_client_execution_error, inner);
            }
            catch (OperationCanceledException ex4) when (ex4.CancellationToken == requestCancellationSource.Token)
            {
                if (cancellationToken.IsCancellationRequested)
                {
                    _stream.AbortWrite(268L);
                    throw new OperationCanceledException(ex4.Message, ex4, cancellationToken);
                }
                throw new HttpRequestException(System.SR.net_http_request_aborted, ex4, RequestRetryType.RetryOnConnectionFailure);
            }
            catch (Http3ConnectionException ex5)
            {
                _connection.Abort(ex5);
                throw new HttpRequestException(System.SR.net_http_client_execution_error, ex5);
            }
            catch (Exception ex6)
            {
                _stream.AbortWrite(258L);
                if (ex6 is HttpRequestException)
                {
                    throw;
                }
                throw new HttpRequestException(System.SR.net_http_client_execution_error, ex6);
            }
        }
        finally
        {
            if (disposeSelf)
            {
                await DisposeAsync().ConfigureAwait(continueOnCapturedContext: false);
            }
        }
        return result;
    }

References System.Net.Http.Http3RequestStream._connection, System.Net.Http.HttpConnectionSettings._cookieContainer, System.Net.Http.Http3RequestStream._expect100ContinueCompletionSource, System.Net.Http.Http3RequestStream._goawayCancellationSource, System.Net.Http.Http3RequestStream._goawayCancellationToken, System.Net.Http.Http3RequestStream._request, System.Net.Http.Http3RequestStream._response, System.Net.Http.Http3RequestStream._stream, System.Net.Http.HttpConnectionSettings._useCookies, System.Net.Http.Http3Connection.Abort(), System.Net.Http.Http3Connection.AbortException, System.Net.Quic.QuicStream.AbortWrite(), System.Net.Http.HttpContent.AllowDuplex, System.Net.Http.Http3RequestStream.BufferHeaders(), System.cancellationToken, System.Threading.Tasks.Task< TResult >.CompletedTask, System.Net.Http.HttpRequestMessage.Content, System.Net.Http.HttpResponseMessage.Content, System.Threading.CancellationTokenSource.CreateLinkedTokenSource(), System.Net.Http.Http3RequestStream.DisposeAsync(), System.Net.Http.Http3RequestStream.DrainContentLength0Frames(), System.Threading.Interlocked.Exchange(), System.Net.Http.Headers.HttpRequestHeaders.ExpectContinue, System.Net.Http.Http3RequestStream.FlushSendBufferAsync(), System.Net.Http.HttpRequestMessage.HasHeaders, System.Net.Http.HttpRequestMessage.Headers, System.Net.Http.EmptyReadStream.Instance, System.L, System.Net.Http.HttpConnectionBase.LogExceptions(), System.SR.net_http_client_execution_error, System.SR.net_http_request_aborted, System.SR.net_http_retry_on_older_version, System.Net.Http.Http3Connection.Pool, System.Net.Http.CookieHelper.ProcessReceivedCookies(), System.Net.Http.Http3RequestStream.ReadResponseAsync(), System.Net.Http.Http3RequestStream.SendContentAsync(), System.Net.Http.HttpConnectionPool.Settings, and System.Threading.Tasks.Task< TResult >.WhenAny().