System.Net.Http.HttpClient.CheckRequestMessage C# (CSharp) Method

        private static void CheckRequestMessage(HttpRequestMessage request)
        {
            if (!request.MarkAsSent())
            {
                throw new InvalidOperationException(SR.net_http_client_request_already_sent);
            }
        }

        /// <summary>以异步操作发送 HTTP 请求。</summary>
        /// <param name="request">要发送的 HTTP 请求消息。</param>
        /// <param name="completionOption">操作应完成时（在响应可利用或在读取整个响应内容之后）。</param>
        /// <param name="cancellationToken">取消操作的取消标记。</param>
        /// <returns>表示异步操作的任务对象。</returns>
        /// <exception cref="T:System.ArgumentNullException">
        /// <paramref name="request" /> 为 <see langword="null" />。</exception>
        /// <exception cref="T:System.InvalidOperationException">请求消息已由 <see cref="T:System.Net.Http.HttpClient" /> 实例发送。</exception>
        /// <exception cref="T:System.Net.Http.HttpRequestException">由于基础问题（如网络连接性、DNS 失败、服务器证书验证或超时），请求失败。</exception>
        public Task <HttpResponseMessage> SendAsync(
            HttpRequestMessage request,
            HttpCompletionOption completionOption,
            CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }
            this.CheckDisposed();
            HttpClient.CheckRequestMessage(request);
            this.SetOperationStarted();
            this.PrepareRequestMessage(request);
            bool flag = this._timeout != HttpClient.s_infiniteTimeout;
            bool disposeCts;
            CancellationTokenSource cts;

            if (flag || cancellationToken.CanBeCanceled)
            {
                disposeCts = true;
                cts        = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, this._pendingRequestsCts.Token);
                if (flag)
                {
                    cts.CancelAfter(this._timeout);
                }
            }
            else
            {
                disposeCts = false;
                cts        = this._pendingRequestsCts;
            }
            Task <HttpResponseMessage> sendTask;

            try
            {
                sendTask = base.SendAsync(request, cts.Token);
            }
            catch
            {
                this.HandleFinishSendAsyncCleanup(cts, disposeCts);
                throw;
            }
            return(completionOption != HttpCompletionOption.ResponseContentRead || string.Equals(request.Method.Method, "HEAD", StringComparison.OrdinalIgnoreCase) ? this.FinishSendAsyncUnbuffered(sendTask, request, cts, disposeCts) : this.FinishSendAsyncBuffered(sendTask, request, cts, disposeCts));
        }