HttpResponseMessage

tests\AnalyzeCiFailure.Tests\TestServices\GitHubFixtureHandler.cs (3)

183return new HttpResponseMessage(success) { Content = new ByteArrayContent(await File.ReadAllBytesAsync(outputFile!, cancellationToken)) }; 191return new HttpResponseMessage(HttpStatusCode.OK) 254=> new(status) { Content = new StringContent(text, Encoding.UTF8, "application/json") };

GitHubApiClientTests.cs (31)

TestServices\GitHubFixtureHandler.cs (3)

183return new HttpResponseMessage(success) { Content = new ByteArrayContent(await File.ReadAllBytesAsync(outputFile!, cancellationToken)) }; 191return new HttpResponseMessage(HttpStatusCode.OK) 254=> new(status) { Content = new StringContent(text, Encoding.UTF8, "application/json") };

TestServices\GitHubHttpTestServices.cs (1)

18var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(json) };

tests\Shared\FoundryClientTestHelpers.cs (1)

34return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)

tests\Shared\FoundryClientTestHelpers.cs (1)

34return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)

Agents\SigstoreNpmProvenanceCheckerTests.cs (1)

1190using var response = new HttpResponseMessage(HttpStatusCode.OK)

Commands\AgentMcpCommandTests.cs (3)

62return new HttpResponseMessage(HttpStatusCode.OK) 69return new HttpResponseMessage(HttpStatusCode.OK) 74return new HttpResponseMessage(HttpStatusCode.NotFound);

Commands\ExportCommandTests.cs (7)

245return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) 252return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) 259return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) 264return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.NotFound); 902return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) 912return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.OK) 919return new System.Net.Http.HttpResponseMessage(System.Net.HttpStatusCode.NotFound);

Commands\TelemetryCommandTests.cs (12)

Commands\TelemetryFollowTests.cs (2)

256return new HttpResponseMessage(HttpStatusCode.OK) 264return new HttpResponseMessage(HttpStatusCode.OK) { Content = content };

Commands\TelemetryLogsCommandTests.cs (24)

Commands\TelemetrySpansCommandTests.cs (16)

Commands\TelemetryTestHelper.cs (3)

96return new HttpResponseMessage(HttpStatusCode.OK) 106return new HttpResponseMessage(HttpStatusCode.OK) 113return new HttpResponseMessage(HttpStatusCode.NotFound);

Commands\TelemetryTracesCommandTests.cs (23)

Mcp\ApiDocs\ApiDocsCacheTests.cs (2)

27using var response = new HttpResponseMessage(HttpStatusCode.OK) 53using var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\ApiDocs\ApiDocsFetcherTests.cs (3)

28using var response = new HttpResponseMessage(HttpStatusCode.OK) 54using var response = new HttpResponseMessage(HttpStatusCode.OK) 81using var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\Docs\DocsCacheTests.cs (1)

26using var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\Docs\DocsFetcherTests.cs (16)

Mcp\ExcludeFromMcpTests.cs (2)

596return new HttpResponseMessage(HttpStatusCode.OK) 602return new HttpResponseMessage(HttpStatusCode.OK)

Mcp\ListStructuredLogsToolTests.cs (10)

Mcp\ListTracesToolTests.cs (11)

Mcp\ListTraceStructuredLogsToolTests.cs (1)

29return new HttpResponseMessage(HttpStatusCode.OK)

Mcp\McpToolHelpersTests.cs (1)

238return new HttpResponseMessage(HttpStatusCode.OK)

ProfileCaptureServiceTests.cs (13)

Telemetry\AgentTelemetryPersistenceTests.cs (4)

80return new HttpResponseMessage(HttpStatusCode.OK) 157return new HttpResponseMessage(HttpStatusCode.OK) 439return new HttpResponseMessage(HttpStatusCode.OK) 512return new HttpResponseMessage(HttpStatusCode.OK)

Telemetry\InternalMicrosoftDetectorTests.cs (19)

Telemetry\ReportedLogExportTests.cs (1)

283return new HttpResponseMessage(HttpStatusCode.OK)

Telemetry\TelemetryShutdownTests.cs (2)

193return new HttpResponseMessage(HttpStatusCode.ServiceUnavailable); 200return new HttpResponseMessage(HttpStatusCode.OK)

AcrLoginServiceTests.cs (5)

30var handler = new CallbackHttpMessageHandler((_, _) => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) 64return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) 90var handler = new CallbackHttpMessageHandler((_, _) => Task.FromResult(new HttpResponseMessage(HttpStatusCode.BadRequest) 112var handler = new CallbackHttpMessageHandler((_, _) => Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound) 134var handler = new CallbackHttpMessageHandler((_, _) => Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound)

AzureSandboxesTests.cs (14)

AzureWebPubSubEmulatorTests.cs (1)

163return Task.FromResult(new HttpResponseMessage(matches ? statusCode : HttpStatusCode.MethodNotAllowed));

FoundryExtensionsTests.cs (8)

AzureFoundryToolboxAdministrationTests.cs (2)

56new HttpResponseMessage(HttpStatusCode.OK) 60new HttpResponseMessage(HttpStatusCode.OK)

HostedAgentExtensionTests.cs (1)

1041return new HttpResponseMessage(statusCode)

PromptAgentTests.cs (1)

128using var handler = new SequenceHttpMessageHandler(new HttpResponseMessage(HttpStatusCode.OK)

ToolboxTests.cs (5)

398var initialize = new HttpResponseMessage(HttpStatusCode.OK) 408new HttpResponseMessage(HttpStatusCode.Accepted), 409new HttpResponseMessage(HttpStatusCode.InternalServerError), 453new HttpResponseMessage(HttpStatusCode.Accepted), 949new(HttpStatusCode.OK)

DcpResponseTests.cs (2)

113? Json("""{"kind":"Status","status":"Success"}""") : new(HttpStatusCode.NotFound) 120private static HttpResponseMessage Json(string body) => new(HttpStatusCode.OK)

TestServices\DcpCleanupTestHandler.cs (4)

73return Resources.TryRemove(key, out _) ? Json("{}") : new(HttpStatusCode.NotFound); 77return new(HttpStatusCode.OK) { Content = new StringContent("") }; 81return new(HttpStatusCode.NotFound); 90private static HttpResponseMessage Json(string value) => new(HttpStatusCode.OK)

Dcp\TestKubernetesService.cs (2)

83Response = new HttpResponseMessageWrapper(new HttpResponseMessage { StatusCode = System.Net.HttpStatusCode.NotFound }, "Not found") 304Response = new HttpResponseMessageWrapper(new HttpResponseMessage { StatusCode = System.Net.HttpStatusCode.NotFound }, ex.Message)

WithHttpCommandTests.cs (4)

50using var response = new HttpResponseMessage(HttpStatusCode.OK) 65using var response = new HttpResponseMessage(HttpStatusCode.OK) 84using var response = new HttpResponseMessage(HttpStatusCode.BadRequest) 576var response = new HttpResponseMessage(statusCode);

ArcadeHttpMessageHandler.cs (2)

24return Task.FromResult(new HttpResponseMessage() 31return Task.FromResult(new HttpResponseMessage()

HttpClientSlim.cs (1)

102new HttpResponseMessage(status).EnsureSuccessStatusCode();

ClientHandler.cs (1)

192var response = new HttpResponseMessage();

TestResources\ReturningHttpClientHandler.cs (2)

16return new(HttpStatusCode.Gone); 22return Task.FromResult(new HttpResponseMessage(HttpStatusCode.Gone));

TestResources\TestHandler.cs (1)

16return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK));

VerbatimHttpHandler.cs (1)

86return new() { Content = new StringContent(_expectedOutput) };

VerbatimMultiPartHttpHandler.cs (1)

153return new() { Content = new StringContent(sentJsonOutput, Encoding.UTF8, "application/json") };

OpenAIHostedFileClientTests.cs (14)

OpenAIResponseClientTests.cs (1)

7370return new HttpResponseMessage { Content = new StringContent(body) };

NoRemoteCallHandler.cs (1)

37var response = new HttpResponseMessage

NoRemoteCallNotSeekableHandler.cs (1)

40var response = new HttpResponseMessage

Latency\Internal\HttpClientLatencyLogEnricherTest.cs (2)

46using HttpResponseMessage httpResponseMessage = new(); 66using HttpResponseMessage httpResponseMessage = new();

Latency\Internal\HttpLatencyMediatorTests.cs (2)

69var resp = new HttpResponseMessage(); 120using var response = new HttpResponseMessage();

Logging\HttpClientLoggerTest.cs (15)

Logging\HttpClientLoggingExtensionsTest.cs (5)

662var response = new HttpResponseMessage(HttpStatusCode.OK); 697? new HttpResponseMessage(HttpStatusCode.OK) 782.ConfigurePrimaryHttpMessageHandler(() => new TestMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.OK))) 804var response = new HttpResponseMessage(HttpStatusCode.OK); 829.ConfigurePrimaryHttpMessageHandler(() => new TestMessageHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)));

Logging\HttpHeadersReaderTest.cs (4)

24using var httpResponse = new HttpResponseMessage(); 42using var httpResponse = new HttpResponseMessage(); 145using var httpResponse = new HttpResponseMessage { Content = responseContent }; 178using var httpResponse = new HttpResponseMessage();

Logging\HttpRequestReaderTest.cs (7)

93using var httpResponseMessage = new HttpResponseMessage 155using var httpResponseMessage = new HttpResponseMessage 226using var httpResponseMessage = new HttpResponseMessage 302using var httpResponseMessage = new HttpResponseMessage 435using var httpResponseMessage = new HttpResponseMessage 504using var httpResponseMessage = new HttpResponseMessage 574using var httpResponseMessage = new HttpResponseMessage

Logging\HttpResponseBodyReaderTest.cs (10)

Logging\Internal\NoRemoteCallHandler.cs (1)

31var response = new HttpResponseMessage

NoRemoteCallHandler.cs (1)

18_response = new HttpResponseMessage

Hedging\HedgingTests.cs (1)

334_responses.Enqueue(new HttpResponseMessage(statusCode));

Hedging\HttpClientHedgingResiliencePredicatesTests.cs (1)

42using var response = new HttpResponseMessage(code);

Hedging\StandardHedgingTests.cs (3)

116using var response = new HttpResponseMessage(HttpStatusCode.OK); 361return new HttpResponseMessage(HttpStatusCode.OK); 375return new HttpResponseMessage(HttpStatusCode.OK);

Helpers\TestHandlerStub.cs (1)

17: this((_, _) => Task.FromResult(new HttpResponseMessage(statusCode)))

Internal\RequestMessageSnapshotStrategyTests.cs (1)

29return new ValueTask<HttpResponseMessage>(new HttpResponseMessage());

Internal\RetryAfterHelperTests.cs (4)

19using var response = new HttpResponseMessage(); 31using var response = new HttpResponseMessage(); 44using var response = new HttpResponseMessage(); 58using var response = new HttpResponseMessage();

Polly\HttpCircuitBreakerStrategyOptionsTests.cs (1)

59using var response = new HttpResponseMessage { StatusCode = statusCode };

Polly\HttpClientResiliencePredicatesTests.cs (1)

55var response = new HttpResponseMessage { StatusCode = statusCode };

Polly\HttpRetryResiliencePipelineBuilderExtensionsTests.cs (2)

251using var okResponse = new HttpResponseMessage(HttpStatusCode.OK); 333return new ValueTask<HttpResponseMessage>(new HttpResponseMessage(HttpStatusCode.InternalServerError));

Polly\HttpRetryStrategyOptionsExtensionsTests.cs (4)

50using var response = new HttpResponseMessage { RequestMessage = request }; 62using var response = new HttpResponseMessage { RequestMessage = request }; 86using var response = new HttpResponseMessage { RequestMessage = null }; 109using var response = new HttpResponseMessage { RequestMessage = request };

Polly\HttpRetryStrategyOptionsTests.cs (4)

58var response = new HttpResponseMessage { StatusCode = statusCode }; 83var response = new HttpResponseMessage { StatusCode = statusCode }; 102using var responseMessage = new HttpResponseMessage(); 130using var responseMessage = new HttpResponseMessage

Resilience\HttpClientBuilderExtensionsTests.RetryBudget.cs (1)

176return Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError));

Resilience\HttpClientBuilderExtensionsTests.Standard.cs (1)

245return Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError));

Resilience\HttpResilienceMetricsEnricherTests.cs (1)

46using var response = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError);

Resilience\ResilienceHandlerTest.cs (2)

112return Task.FromResult(new HttpResponseMessage { StatusCode = HttpStatusCode.Created }); 137return Task.FromResult(new HttpResponseMessage { StatusCode = HttpStatusCode.Created });

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (1)

137_response = new HttpResponseMessage()

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (1)

1094_response = new HttpResponseMessage()

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (1)

668var response = new HttpResponseMessage() { RequestMessage = request, Content = new HttpConnectionResponseContent() };

System\Net\Http\WinHttpResponseParser.cs (1)

25var response = new HttpResponseMessage();

ActivityGenerationWorker.cs (1)

63using var response = await client.GetAsync(path, stoppingToken);

tools\Aspire.TestTools\GitHubApiClient.cs (17)

121using var response = await OpenAsync(HttpMethod.Get, current, original, body: null, HttpStatusCode.OK, allowExternalRedirect: false, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 147using var response = await OpenAsync(method, uri, uri, body, expectedStatusCode, allowExternalRedirect: false, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 163using var response = await OpenAsync(method, uri, uri, body, expectedStatusCode, allowExternalRedirect: false, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 184using var response = await OpenAsync(HttpMethod.Get, uri, uri, body: null, HttpStatusCode.OK, allowExternalRedirect: true, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 208using var response = await OpenAsync(HttpMethod.Get, uri, uri, body: null, HttpStatusCode.OK, allowExternalRedirect: true, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 263private async Task<HttpResponseMessage> OpenAsync(HttpMethod method, Uri uri, Uri original, JsonNode? body, HttpStatusCode expectedStatus, bool allowExternalRedirect, CancellationToken cancellationToken) 308var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); 346private static bool ShouldRetry(HttpResponseMessage response) 352private static bool HasRateLimitHeaders(HttpResponseMessage response) 356private static TimeSpan? GetRetryDelay(HttpResponseMessage response, int attempt) 380private static string DescribeHttpFailure(HttpResponseMessage response) 414private static string? ReadSingleHeader(HttpResponseMessage response, string name) 436private static long? ReadNumericHeader(HttpResponseMessage response, string name) 443private static DateTimeOffset? ReadRetryAfterDate(HttpResponseMessage response) 452private static async Task<(JsonNode? Node, long Bytes)> ReadJsonAsync(HttpResponseMessage response, long maximumBytes, HttpMethod method, Uri original, CancellationToken cancellationToken) 471private static async Task<long> CopyBoundedAsync(HttpResponseMessage response, Stream output, long maximumBytes, HttpMethod method, Uri original, CancellationToken cancellationToken) 504private Uri? GetNextPage(HttpResponseMessage response, Uri current, Uri original)

tests\AnalyzeCiFailure.Tests\TestServices\GitHubFixtureHandler.cs (4)

17private readonly Dictionary<string, HttpResponseMessage> _pages = new(StringComparer.Ordinal); 21protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 29if (_pages.Remove(uri.AbsoluteUri, out var cached)) 253private static HttpResponseMessage Response(HttpStatusCode status, string text)

GitHubApiClientTests.cs (19)

TestServices\GitHubFixtureHandler.cs (4)

17private readonly Dictionary<string, HttpResponseMessage> _pages = new(StringComparer.Ordinal); 21protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 29if (_pages.Remove(uri.AbsoluteUri, out var cached)) 253private static HttpResponseMessage Response(HttpStatusCode status, string text)

TestServices\GitHubHttpTestServices.cs (4)

11Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> send) : HttpMessageHandler 13protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 16public static HttpResponseMessage Json(string json, string? next = null) 18var response = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(json) };

Commands\ExportCommand.cs (2)

295var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false); 326var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false);

Commands\TelemetryCommandHelpers.cs (4)

127public static bool HasJsonContentType(HttpResponseMessage response) 148public static void EnsureTelemetryApiResponse(HttpResponseMessage response) 393var probeResponse = await probeClient.GetAsync(dashboardBaseUrl, cancellationToken).ConfigureAwait(false); 561var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false);

Commands\TelemetryLogsCommand.cs (2)

168var response = await client.GetAsync(url, cancellationToken); 190using var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken);

Commands\TelemetrySpansCommand.cs (2)

163var response = await client.GetAsync(url, cancellationToken); 185using var response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken);

Commands\TelemetryTracesCommand.cs (2)

141var response = await client.GetAsync(url, cancellationToken); 212var response = await client.GetAsync(url, cancellationToken);

Documentation\CachedHttpDocumentFetcher.cs (2)

47using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false); 61using var retryResponse = await httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);

Mcp\Tools\ListStructuredLogsTool.cs (1)

100var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false);

Mcp\Tools\ListTracesTool.cs (1)

100var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false);

Mcp\Tools\ListTraceStructuredLogsTool.cs (1)

90var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false);

Npm\SigstoreNpmProvenanceChecker.cs (1)

159var response = await _httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);

Profiling\ProfileCaptureService.cs (2)

294using var response = await client.GetAsync(_options.DashboardUrl, linkedCts.Token).ConfigureAwait(false); 452using var response = await client.GetAsync(url, cancellationToken).ConfigureAwait(false);

src\Shared\Telemetry\InternalMicrosoftDetector.cs (4)

1034using var userResponse = await http.SendAsync(userRequest, cancellationToken).ConfigureAwait(false); 1055using var membershipResponse = await http.SendAsync(membershipRequest, cancellationToken).ConfigureAwait(false); 1077using var publicMemberResponse = await http.SendAsync(publicMemberRequest, cancellationToken).ConfigureAwait(false); 1128private static async Task<string?> ReadJsonPropertyAsync(HttpResponseMessage response, string propertyName, CancellationToken cancellationToken)

Utils\CliDownloader.cs (1)

173using var response = await s_httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cts.Token);

Utils\EnvironmentChecker\DcpConnectionChecker.cs (2)

63using var response = await client.GetAsync(new Uri(kubeconfig.Server, "/version"), timeoutCts.Token).ConfigureAwait(false); 339using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);

Scripts\Common\ScriptHostFixture.cs (1)

79using var response = await client.GetAsync($"{BaseUrl}/get-aspire-cli.sh");

tests\Shared\FoundryClientTestHelpers.cs (1)

31protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

tests\Shared\FoundryClientTestHelpers.cs (1)

31protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Helpers\CliE2ETestHelpers.cs (4)

691using var response = await s_nuGetHttpClient.GetAsync(indexUrl, cancellationToken); 841using var response = await s_nuGetHttpClient.GetAsync(stagingDownloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken); 881using var response = await s_nuGetHttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken); 923using var response = await s_nuGetHttpClient.GetAsync(indexUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);

Agents\SigstoreNpmProvenanceCheckerTests.cs (1)

1190using var response = new HttpResponseMessage(HttpStatusCode.OK)

Commands\TelemetryCommandTests.cs (6)

603var response = new HttpResponseMessage(HttpStatusCode.OK) 620var response = new HttpResponseMessage(HttpStatusCode.OK) 637var response = new HttpResponseMessage(HttpStatusCode.Unauthorized); 651var response = new HttpResponseMessage(HttpStatusCode.NotFound); 678var response = new HttpResponseMessage(HttpStatusCode.InternalServerError); 713var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\ApiDocs\ApiDocsCacheTests.cs (2)

27using var response = new HttpResponseMessage(HttpStatusCode.OK) 53using var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\ApiDocs\ApiDocsFetcherTests.cs (3)

28using var response = new HttpResponseMessage(HttpStatusCode.OK) 54using var response = new HttpResponseMessage(HttpStatusCode.OK) 81using var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\Docs\DocsCacheTests.cs (1)

26using var response = new HttpResponseMessage(HttpStatusCode.OK)

Mcp\Docs\DocsFetcherTests.cs (13)

ProfileCaptureServiceTests.cs (3)

648Func<HttpRequestMessage, HttpResponseMessage> telemetryResponseFactory, 655var response = telemetryResponseFactory(request); 664private static HttpResponseMessage JsonResponse(TelemetryApiResponse response)

Telemetry\InternalMicrosoftDetectorTests.cs (3)

1744private static HttpResponseMessage JsonResponse(HttpStatusCode statusCode, string json) 1923private sealed class TestGitHubHttpMessageHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync) : HttpMessageHandler 1936protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Utils\MockHttpMessageHandler.cs (8)

src\Shared\Telemetry\InternalMicrosoftDetector.cs (4)

1034using var userResponse = await http.SendAsync(userRequest, cancellationToken).ConfigureAwait(false); 1055using var membershipResponse = await http.SendAsync(membershipRequest, cancellationToken).ConfigureAwait(false); 1077using var publicMemberResponse = await http.SendAsync(publicMemberRequest, cancellationToken).ConfigureAwait(false); 1128private static async Task<string?> ReadJsonPropertyAsync(HttpResponseMessage response, string propertyName, CancellationToken cancellationToken)

Integration\Playwright\NativeAotDashboardTests.cs (2)

155using var response = await client.PostAsync("/v1/traces", content, TestContext.Current.CancellationToken); 194using var response = await client.GetAsync(dashboardUrl, timeout.Token);

Integration\BlazorWebSocketOriginTests.cs (1)

25using var response = await client.SendAsync(request).DefaultTimeout();

Integration\FrontendBrowserTokenAuthTests.cs (15)

Integration\FrontendOpenIdConnectAuthTests.cs (2)

39var response = await client.GetAsync("/").DefaultTimeout(); 84var response = await client.GetAsync("/").DefaultTimeout();

Integration\HealthTests.cs (2)

37var response = await client.SendAsync(request).DefaultTimeout(); 54var response = await client.GetAsync($"/{DashboardUrls.HealthBasePath}").DefaultTimeout();

Integration\OtlpCorsHttpServiceTests.cs (5)

35var responseMessage = await httpClient.SendAsync(preflightRequest).DefaultTimeout(); 59var responseMessage1 = await httpClient.SendAsync(preflightRequest1).DefaultTimeout(); 73var responseMessage2 = await httpClient.SendAsync(preflightRequest2).DefaultTimeout(); 100var responseMessage = await httpClient.SendAsync(preflightRequest).DefaultTimeout(); 128var responseMessage = await httpClient.SendAsync(preflightRequest).DefaultTimeout();

Integration\OtlpGrpcServiceTests.cs (1)

264using var response = await httpClient.SendAsync(request).DefaultTimeout();

Integration\OtlpHttpJsonTests.cs (9)

Integration\OtlpHttpServiceTests.cs (13)

Integration\ResponseCompressionTests.cs (2)

27var response = await client.SendAsync(request).DefaultTimeout(); 50var response = await client.SendAsync(request).DefaultTimeout();

Integration\StartupTests.cs (5)

468var response = await httpClient.SendAsync(request).DefaultTimeout(); 569var responseMessage = await httpClient.SendAsync(request).DefaultTimeout(); 849var response = await httpClient.GetAsync("/api/telemetry/spans").DefaultTimeout(); 996var response = await client.GetAsync("/").DefaultTimeout(); 1075var response = await client.SendAsync(request).DefaultTimeout();

Integration\TelemetryApiTests.cs (20)

Middleware\ValidateTokenMiddlewareTests.cs (8)

AcaExpressDeploymentTests.cs (4)

323using var response = await client.SendAsync(request, cancellationToken); 354using var response = await client.GetAsync(urls["frontend"], readiness.Token); 365using var unauthenticated = await client.GetAsync(urls["api"], readiness.Token); 370using var wrongSecret = await client.SendAsync(wrongSecretRequest, readiness.Token);

AcaStarterDeploymentTests.cs (2)

236using var originsResponse = await http.GetAsync($"{apiUrl}/browser-origins", cancellationToken); 245using var preflightResponse = await http.SendAsync(preflight, cancellationToken);

FoundryDotnetProjectDeploymentTests.cs (2)

170using var resourcesResponse = await http.GetAsync( 177using var projectResponse = await http.GetAsync($"https://management.azure.com{id}?api-version=2025-06-01", cancellationToken);

FoundryHostedAgentDeploymentTests.cs (3)

232using var resourcesResponse = await client.SendAsync(resourcesRequest, cancellationToken); 250using var projectResponse = await client.SendAsync(projectRequest, cancellationToken); 265using var connectionsResponse = await client.SendAsync(connectionsRequest, cancellationToken);

Helpers\DotnetProjectDeploymentHelpers.cs (1)

80using var response = await client.SendAsync(request, cancellationToken);

Helpers\EntraDeploymentHelpers.cs (3)

350using var response = await SendAsync(client, credential, HttpMethod.Delete, url, cancellationToken); 360using var response = await SendAsync(client, credential, HttpMethod.Get, url, cancellationToken); 371private static async Task<HttpResponseMessage> SendAsync(

IntegrationServicesTests.cs (1)

35var response = await _integrationServicesFixture.IntegrationServiceA.HttpGetAsync("http", $"/{resourceName}/verify", cancellationToken);

tests\Shared\TemplatesTesting\AspireProject.cs (1)

418var res = await Client.Value.GetAsync(dashboardUrl, token);

tests\Shared\TemplatesTesting\ProjectInfo.cs (1)

20public Task<HttpResponseMessage> HttpGetAsync(string bindingName, string path, CancellationToken cancellationToken = default)

ApplicationModel\HttpCommandContext.cs (1)

150public required HttpResponseMessage Response { get; init; }

Dcp\DcpKubernetesClient.cs (9)

68var response = await HttpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false); 142var httpResponse = await SendRequest<object?>(url, HttpMethod.Get, customHeaders: null, body: null, cancellationToken).ConfigureAwait(false); 165var httpResponse = await SendRequestRaw(null, httpRequest, cancellationToken).ConfigureAwait(false); 191var httpResponse = await SendRequestRaw(content, httpRequest, cancellationToken).ConfigureAwait(false); 211private readonly HttpResponseMessage _response; 217public WatchConnection(HttpResponseMessage response, Stream stream, CancellationToken cancellationToken) 224_cancellationRegistration = cancellationToken.Register(static state => ((HttpResponseMessage)state!).Dispose(), response); 229using var response = _response; 231using var consumerCancellation = cancellationToken.Register(static state => ((HttpResponseMessage)state!).Dispose(), response);

ExternalServiceBuilderExtensions.cs (1)

351using var response = await httpClientFactory().GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, linkedSource.Token).ConfigureAwait(false);

ResourceBuilderExtensions.cs (2)

4130HttpResponseMessage? response = null; 4263internal static async Task<ExecuteCommandResult> GetDefaultHttpCommandResultAsync(HttpResponseMessage response, HttpCommandOptions commandOptions, CancellationToken cancellationToken)

AcrLoginService.cs (1)

167var response = await httpClient.PostAsync(exchangeUrl, content, cancellationToken).ConfigureAwait(false);

Internal\Adc\AzureDevComputeClient.cs (9)

191using var response = await SendWithRetryAsync(scope, method, path, content, cancellationToken).ConfigureAwait(false); 208using var response = await SendWithRetryAsync(scope, method, path, content, cancellationToken).ConfigureAwait(false); 227HttpResponseMessage response; 295private async Task<HttpResponseMessage> SendWithRetryAsync( 305HttpResponseMessage response; 383HttpResponseMessage response, 412private async Task<HttpResponseMessage> SendCoreAsync( 454private static async Task EnsureSuccessAsync(HttpResponseMessage response, HttpMethod method, string path, CancellationToken cancellationToken) 468private static Task<string> GetErrorMessageAsync(HttpResponseMessage response, CancellationToken cancellationToken)

AcrLoginServiceTests.cs (2)

156private sealed class CallbackHttpMessageHandler(Func<int, CancellationToken, Task<HttpResponseMessage>> callback) : HttpMessageHandler 160protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

AzureSandboxesTests.cs (8)

1381using var secondsResponse = new HttpResponseMessage(HttpStatusCode.TooManyRequests); 1383using var dateResponse = new HttpResponseMessage(HttpStatusCode.TooManyRequests); 1411var response = new HttpResponseMessage(status); 1434? Task.FromException<HttpResponseMessage>(new HttpRequestException("connection reset")) 1455return Task.FromException<HttpResponseMessage>(new HttpRequestException("connection reset")); 3682private sealed class RecordingHandler(Func<HttpRequestMessage, Task<HttpResponseMessage>> handler) : HttpMessageHandler 3684protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 3755private static HttpResponseMessage JsonResponse(string content, HttpStatusCode statusCode = HttpStatusCode.OK)

AzureWebPubSubEmulatorTests.cs (1)

160protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

FoundryExtensionsTests.cs (2)

975Func<int, HttpRequestMessage, HttpResponseMessage> callback) : HttpMessageHandler 979protected override Task<HttpResponseMessage> SendAsync(

AddBlazorGatewayTests.cs (5)

301using var bootScript = await httpClient.GetAsync("/app/_framework/blazor.webassembly.js", requestTimeout.Token); 303using var missingAsset = await httpClient.GetAsync("/app/missing.js", requestTimeout.Token); 305using var configurationResponse = await httpClient.GetAsync("/app/_blazor/_configuration", requestTimeout.Token); 313using var apiResponse = await httpClient.GetAsync("/app/_api/weatherapi/forecast.json", requestTimeout.Token); 317using var missingApi = await httpClient.GetAsync("/app/_api/weatherapi/missing.json", requestTimeout.Token);

BrowserEndpointDiscovery.cs (1)

213using var response = await s_probeHttpClient.GetAsync(versionEndpoint, probeCts.Token).ConfigureAwait(false);

src\Aspire.Hosting.Browsers\BrowserEndpointDiscovery.cs (1)

213using var response = await s_probeHttpClient.GetAsync(versionEndpoint, probeCts.Token).ConfigureAwait(false);

FoundryLocalHealthCheck.cs (2)

22using var response = await httpClient 31using var legacyResponse = await httpClient

FoundryLocalService.cs (1)

132using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);

HostedAgent\HostedAgentBuilderExtension.cs (1)

359var response = ctx.Response;

Toolbox\FoundryToolboxReadinessProbe.cs (1)

176using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);

Helpers\SequenceHttpMessageHandler.cs (4)

6internal sealed class SequenceHttpMessageHandler(params HttpResponseMessage[] responses) : HttpMessageHandler 8private readonly Queue<HttpResponseMessage> _responses = new(responses); 12protected override async Task<HttpResponseMessage> SendAsync( 32while (_responses.TryDequeue(out var response))

HostedAgentExtensionTests.cs (1)

1034protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

ToolboxTests.cs (3)

398var initialize = new HttpResponseMessage(HttpStatusCode.OK) 449var initialize = CreateJsonResponse( 948private static HttpResponseMessage CreateJsonResponse(string json) =>

DenoFunctionalTests.cs (1)

92using var response = await client.GetAsync(requestUri, cancellationToken);

MongoDbFunctionalTests.cs (1)

144using var response = await httpClient.GetAsync("/", token);

ReplicaSet\MongoDbReplicaSetFunctionalTests.cs (2)

149using var response = await httpClient.GetAsync("/", token); 235using var response = await httpClient.GetAsync("/", token);

SingleMemberReplicaSetFunctionalTests.cs (1)

111using var response = await httpClient.GetAsync("/", token);

DcpConnectionMaterialTests.cs (2)

28using var response = await material.Client.GetAsync("/readyz", TestContext.Current.CancellationToken); 41using var response = await material.Client.GetAsync("/readyz", TestContext.Current.CancellationToken);

DcpResponseTests.cs (1)

120private static HttpResponseMessage Json(string body) => new(HttpStatusCode.OK)

TestServices\DcpCleanupTestHandler.cs (3)

22public Func<HttpRequestMessage, HttpResponseMessage>? ResponseFactory { get; set; } 29protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 90private static HttpResponseMessage Json(string value) => new(HttpStatusCode.OK)

Dashboard\DcpDashboard.cs (1)

69using var response = await http.GetAsync(new Uri(frontend, "health"), requestTimeout.Token).ConfigureAwait(false);

Dcp\DcpApiClient.cs (2)

147using var response = await Client.GetAsync(path, HttpCompletionOption.ResponseHeadersRead, timeout.Token).ConfigureAwait(false); 182using var response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, timeout.Token).ConfigureAwait(false);

src\Shared\DcpConnectionMaterial.cs (1)

123using var response = await material.Client.GetAsync("/readyz", request.Token).ConfigureAwait(false);

OpenAIHealthCheck.cs (1)

69HttpResponseMessage resp;

OpenAIModelHealthCheck.cs (2)

45using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false); 64private static async Task<HealthCheckResult> HandleNotFound(HttpResponseMessage response, CancellationToken cancellationToken)

PostgresFunctionalTests.cs (2)

93var response = await client.GetAsync(path); 178var response = await client.PostAsync("/api/connect", httpContent);

RedisFunctionalTests.cs (6)

94var response = await client.GetAsync(path); 303var response = await client.GetAsync("/api/databases", cts.Token); 334var testConnectionResponse = await client.GetAsync($"/api/databases/{db.Id}/connect", cts2.Token); 709var response = await httpClient.GetAsync("/api/settings", ct); 741var response = await client.PatchAsync(apiUrl, jsonContent, ct); 797var httpResponse = await client.GetAsync(redisCommanderUrl!);

SeqFunctionalTests.cs (2)

57var ingestResponse = await httpClient.PostAsync("/ingest/clef", content, token); 60var response = await httpClient.GetAsync("/api/events?filter=Username='johndoe'", token);

DashboardUrlTests.cs (5)

47using var loginResponse = await httpClient.GetAsync(dashboardUri, cancellationTokenSource.Token); 55using var protectedResponse = await httpClient.GetAsync( 182using var loginResponse = await httpClient.GetAsync(dashboardUri, cancellationTokenSource.Token); 227using var response = await httpClient.GetAsync(invalidLoginUrl, cancellationTokenSource.Token); 269using var response = await httpClient.GetAsync(dashboardUri, cancellationTokenSource.Token);

ContainerTunnelTests.cs (2)

68var response = await clientA.GetAsync("/servicea/").DefaultTimeout(TestConstants.DefaultOrchestratorTestTimeout); 111var response = await clientA.GetAsync("/servicea/").DefaultTimeout(TestConstants.DefaultOrchestratorTestTimeout);

WithHttpCommandTests.cs (6)

50using var response = new HttpResponseMessage(HttpStatusCode.OK) 65using var response = new HttpResponseMessage(HttpStatusCode.OK) 84using var response = new HttpResponseMessage(HttpStatusCode.BadRequest) 564protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 576var response = new HttpResponseMessage(statusCode); 592protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

YarpFunctionalTests.cs (2)

59using var response200 = await httpClient.GetAsync("/aspnetapp"); 62using var response404 = await httpClient.GetAsync("/another");

AppHostTests.cs (1)

126HttpResponseMessage? response = null;

BlazorWasmHostingTests.cs (8)

26var homeResponse = await blazorClient.GetAsync("/"); 31var configResponse = await blazorClient.GetAsync("/_blazor/_configuration"); 34var proxyApiResponse = await blazorClient.GetAsync("/_api/weatherapi/weatherforecast"); 40var directApiResponse = await weatherApiClient.GetAsync("/weatherforecast"); 107var homeResponse = await gatewayClient.GetAsync("/app/"); 112var configResponse = await gatewayClient.GetAsync("/app/_blazor/_configuration"); 115var apiResponse = await gatewayClient.GetAsync("/app/_api/weatherapi/weatherforecast"); 121var directApiResponse = await weatherApiClient.GetAsync("/weatherforecast");

Infrastructure\DistributedApplicationExtensions.cs (2)

221using var checkResponse = await checkHttpClient.PostAsync("/ApplyDatabaseMigrations", emptyDbContextContent); 253using var response = await applyMigrationsHttpClient.PostAsync("/ApplyDatabaseMigrations", content);

ProjectSpecificTests.cs (1)

82var response = await AppHostTests.CreateHttpClientWithResilience(app, "funcapp").GetAsync("/api/injected-resources");

SeqHealthCheck.cs (1)

24using var response = await _client.GetAsync("/health", cancellationToken)

tests\Shared\TemplatesTesting\AspireProject.cs (1)

418var res = await Client.Value.GetAsync(dashboardUrl, token);

tests\Shared\TemplatesTesting\ProjectInfo.cs (1)

20public Task<HttpResponseMessage> HttpGetAsync(string bindingName, string path, CancellationToken cancellationToken = default)

GitHubApiClient.cs (17)

121using var response = await OpenAsync(HttpMethod.Get, current, original, body: null, HttpStatusCode.OK, allowExternalRedirect: false, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 147using var response = await OpenAsync(method, uri, uri, body, expectedStatusCode, allowExternalRedirect: false, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 163using var response = await OpenAsync(method, uri, uri, body, expectedStatusCode, allowExternalRedirect: false, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 184using var response = await OpenAsync(HttpMethod.Get, uri, uri, body: null, HttpStatusCode.OK, allowExternalRedirect: true, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 208using var response = await OpenAsync(HttpMethod.Get, uri, uri, body: null, HttpStatusCode.OK, allowExternalRedirect: true, timeout.Token).ConfigureAwait(continueOnCapturedContext: false); 263private async Task<HttpResponseMessage> OpenAsync(HttpMethod method, Uri uri, Uri original, JsonNode? body, HttpStatusCode expectedStatus, bool allowExternalRedirect, CancellationToken cancellationToken) 308var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(continueOnCapturedContext: false); 346private static bool ShouldRetry(HttpResponseMessage response) 352private static bool HasRateLimitHeaders(HttpResponseMessage response) 356private static TimeSpan? GetRetryDelay(HttpResponseMessage response, int attempt) 380private static string DescribeHttpFailure(HttpResponseMessage response) 414private static string? ReadSingleHeader(HttpResponseMessage response, string name) 436private static long? ReadNumericHeader(HttpResponseMessage response, string name) 443private static DateTimeOffset? ReadRetryAfterDate(HttpResponseMessage response) 452private static async Task<(JsonNode? Node, long Bytes)> ReadJsonAsync(HttpResponseMessage response, long maximumBytes, HttpMethod method, Uri original, CancellationToken cancellationToken) 471private static async Task<long> CopyBoundedAsync(HttpResponseMessage response, Stream output, long maximumBytes, HttpMethod method, Uri original, CancellationToken cancellationToken) 504private Uri? GetNextPage(HttpResponseMessage response, Uri current, Uri original)

BasicHttpBindingTests.4.0.0.cs (2)

118return Task.FromResult((HttpResponseMessage)null); 176return Task.FromResult((HttpResponseMessage)null);

HttpBindingTestHelpers.cs (5)

30public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendingAsync { get; set; } 31public Func<HttpResponseMessage, CancellationToken, Task<HttpResponseMessage>> OnSentAsync { get; set; } 45protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 47HttpResponseMessage response;

NetHttpBindingTests.cs (1)

379return Task.FromResult<HttpResponseMessage>(null);

parent\Http\HttpBindingTestHelpers.cs (5)

30public Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> OnSendingAsync { get; set; } 31public Func<HttpResponseMessage, CancellationToken, Task<HttpResponseMessage>> OnSentAsync { get; set; } 45protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 47HttpResponseMessage response;

WSHttpBindingTests.cs (1)

378return Task.FromResult<HttpResponseMessage>(null);

Program.cs (1)

15var response = await http.GetAsync("/");

HttpClientWrapper.cs (3)

31var response = await _client.GetAsync(url); 44private readonly HttpResponseMessage _response; 46public HttpResponseMessageWrapper(HttpResponseMessage response)

Program.cs (1)

249using var response = await client.SendAsync(request, cancellationToken).ConfigureAwait(false);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelFactory.cs (1)

879private HttpResponseMessage _httpResponseMessage;

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelHelpers.cs (2)

112public static HttpResponseMessage ProcessGetResponseWebException(HttpRequestException requestException, HttpRequestMessage request, HttpAbortReason abortReason) 147internal static Exception CreateUnexpectedResponseException(HttpResponseMessage response)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageExtensionMethods.cs (4)

15internal static void CopyPropertiesFromMessage(this HttpResponseMessage httpResponseMessage, Message message) 29internal static bool CreateContentIfNull(this HttpResponseMessage httpResponseMessage) 42internal static void MergeWebHeaderCollection(this HttpResponseMessage responseMessage, WebHeaderCollection headersToMerge) 48internal static WebHeaderCollection ToWebHeaderCollection(this HttpResponseMessage httpResponse)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageHelper.cs (2)

21private readonly HttpResponseMessage _httpResponseMessage; 25public HttpResponseMessageHelper(HttpResponseMessage httpResponseMessage, HttpChannelFactory<IRequestChannel> factory)

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpResponseMessageProperty.cs (6)

31internal HttpResponseMessageProperty(HttpResponseMessage httpResponseMessage) 153public HttpResponseMessage HttpResponseMessage 166internal static HttpResponseMessage GetHttpResponseMessageFromMessage(Message message) 168HttpResponseMessage httpResponseMessage = null; 291public HttpResponseMessageBackedProperty(HttpResponseMessage httpResponseMessage) 298public HttpResponseMessage HttpResponseMessage { get; private set; }

GraphController.cs (1)

28using var response = await client.SendAsync(request, cancellationToken);

Program.cs (1)

856using var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);

ServiceUtilHelper.cs (3)

581HttpResponseMessage response = httpClient.GetAsync(requestUri).GetAwaiter().GetResult(); 600HttpResponseMessage response = httpClient.GetAsync(requestUri).GetAwaiter().GetResult(); 619HttpResponseMessage response = await httpClient.GetAsync(requestUri);

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (1)

74HttpResponseMessage response = await client.GetAsync(c.Url);

AuthorizationHandler.cs (1)

8protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

ArcadeHttpMessageHandler.cs (2)

15public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request) => SendAsync(request, CancellationToken.None); 17protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

RequestResponseHelper.cs (1)

14public HttpResponseMessage ResponseMessage { get; set;}

FacebookHandler.cs (1)

52var response = await Backchannel.GetAsync(endpoint, Context.RequestAborted);

GoogleHandler.cs (1)

50var response = await Backchannel.SendAsync(request, Context.RequestAborted);

MicrosoftAccountHandler.cs (1)

46var response = await Backchannel.SendAsync(request, Context.RequestAborted);

OAuthHandler.cs (2)

222var response = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 232private static OAuthTokenResponse PrepareFailedOAuthTokenResponse(HttpResponseMessage response, string body)

OpenIdConnectHandler.cs (5)

604var parResponseMessage = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 613private async Task<string> GetPushedAuthorizationRequestUri(HttpResponseMessage parResponseMessage) 1000var responseMessage = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 1066var responseMessage = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 1520private OpenIdConnectProtocolException CreateOpenIdConnectProtocolException(OpenIdConnectMessage message, HttpResponseMessage? response)

TwitterHandler.cs (5)

184private async Task<HttpResponseMessage> ExecuteRequestAsync(string url, HttpMethod httpMethod, RequestToken? accessToken = null, Dictionary<string, string>? extraOAuthPairs = null, Dictionary<string, string>? queryParameters = null, Dictionary<string, string>? formData = null) 274var response = await ExecuteRequestAsync(TwitterDefaults.RequestTokenEndpoint, HttpMethod.Post, extraOAuthPairs: new Dictionary<string, string>() { { "oauth_callback", callBackUri } }); 300var response = await ExecuteRequestAsync(TwitterDefaults.AccessTokenEndpoint, HttpMethod.Post, token, formData: formPost); 325var response = await ExecuteRequestAsync("https://api.twitter.com/1.1/account/verify_credentials.json", HttpMethod.Get, accessToken, queryParameters: new Dictionary<string, string>() { { "include_email", "true" } }); 357private async Task EnsureTwitterRequestSuccess(HttpResponseMessage response)

Infrastructure\ReadinessNotificationService.cs (1)

53var response = await client.PostAsync(url, content: null).ConfigureAwait(false);

Services\AuthorizationMessageHandler.cs (2)

13/// A <see cref="DelegatingHandler"/> that attaches access tokens to outgoing <see cref="HttpResponseMessage"/> instances. 55protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Services\BaseAddressAuthorizationMessageHandler.cs (1)

9/// A <see cref="DelegatingHandler"/> that attaches access tokens to outgoing <see cref="HttpResponseMessage"/> instances.

Buffering\PerRequestLogBufferingIncludeScopesTests.cs (1)

52using HttpResponseMessage response = await client.GetAsync(RequestPath);

Latency\ChecpointAcceptanceTests.cs (2)

103HttpResponseMessage? response = null; 127using var response = await host.GetTestServer().CreateClient().GetAsync("/Path");

Logging\AcceptanceTests.cs (19)

Logging\AcceptanceTests.Mvc.cs (5)

65using var response = await client.GetAsync($"/api/users/{UserId}/someTestData?{QueryParamName}=foo").ConfigureAwait(false); 100using var response = await client.GetAsync($"/api/users/{UserId}/someTestData?{QueryParamName}=foo").ConfigureAwait(false); 146using var response = await client.GetAsync($"/api/users/{UserId}/{NoDataClassParamValue}?{QueryParamName}=foo").ConfigureAwait(false); 190using var response = await client.GetAsync($"/api/users/{UserId}/someTestData?{QueryParamName}=foo").ConfigureAwait(false); 231using var response = await client.GetAsync(RequestPath).ConfigureAwait(false);

Logging\AcceptanceTests.Routing.cs (1)

65using var response = await client.GetAsync(httpPath).ConfigureAwait(false);

HeaderPropagationMessageHandler.cs (1)

41protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

HttpConnection.cs (2)

493using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false)) 789using var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);

Internal\AccessTokenHttpMessageHandler.cs (2)

22protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 65var result = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

Internal\Http2HttpMessageHandler.cs (1)

20protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Internal\LoggingHttpMessageHandler.cs (2)

25protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 29var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

Internal\LongPollingTransport.cs (3)

57using (var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false)) 156HttpResponseMessage response; 235var response = await _httpClient.SendAsync(request).ConfigureAwait(false);

Internal\LongPollingTransport.Log.cs (1)

44public static void PollResponseReceived(ILogger logger, HttpResponseMessage response)

Internal\SendUtils.cs (1)

51using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))

Internal\ServerSentEventsTransport.cs (3)

58HttpResponseMessage? response = null; 88private async Task ProcessAsync(Uri url, HttpResponseMessage response) 126private async Task ProcessEventStream(HttpResponseMessage response, CancellationToken cancellationToken)

Handlers\CookieContainerHandler.cs (3)

12/// more pairs of <see cref="HttpRequestMessage"/> and <see cref="HttpResponseMessage"/>. 41protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 50var response = await base.SendAsync(request, cancellationToken);

Handlers\RedirectHandler.cs (5)

45protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 51var response = await base.SendAsync(request, cancellationToken); 133HttpResponseMessage response, 167private static bool ShouldKeepVerb(HttpResponseMessage response) => 171private static bool IsRedirect(HttpResponseMessage response) =>

Common\LoggingHandler.cs (2)

18protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 23var response = await base.SendAsync(request, cancellationToken);

Common\RetryHelper.cs (3)

19public static async Task<HttpResponseMessage> RetryRequest( 20Func<Task<HttpResponseMessage>> retryBlock, 36var response = await retryBlock().ConfigureAwait(false);

Deployers\NginxDeployer.cs (1)

81var response = await RetryHelper.RetryRequest(() =>

SpaProxyLaunchManager.cs (2)

81var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token); 112var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);

Proxying\SpaProxy.cs (2)

86using (var responseMessage = await httpClient.SendAsync( 165private static async Task CopyProxyHttpResponse(HttpContext context, HttpResponseMessage responseMessage, CancellationToken cancellationToken)

ClientHandler.cs (4)

58protected override HttpResponseMessage Send( 73/// <returns>A <see cref="Task{TResult}"/> returning the <see cref="HttpResponseMessage"/>.</returns> 74protected override async Task<HttpResponseMessage> SendAsync( 192var response = new HttpResponseMessage();

RequestBuilder.cs (6)

71/// <returns>The resulting <see cref="HttpResponseMessage"/>.</returns> 72public Task<HttpResponseMessage> SendAsync(string method) 81/// <returns>The resulting <see cref="HttpResponseMessage"/>.</returns> 82public Task<HttpResponseMessage> GetAsync() 91/// <returns>The resulting <see cref="HttpResponseMessage"/>.</returns> 92public Task<HttpResponseMessage> PostAsync()

FakesExtensionsTests.cs (1)

89using var response = await client.SendAsync(new HttpRequestMessage());

TestResources\ReturningHttpClientHandler.cs (2)

14protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 20protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

TestResources\TestHandler.cs (1)

13protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,

src\sdk\src\Dotnet.Watch\Web.Middleware\BrowserToolsForwarder.cs (1)

90using var response = await _httpClient.SendAsync(

DownloadFile.cs (2)

157using (HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false)) 354private bool ShouldSkip(HttpResponseMessage response, FileInfo destinationFile)

Utils.cs (2)

32HttpResponseMessage httpResponse = await s_httpClient.SendAsync(httpRequest).ConfigureAwait(false); 65HttpResponseMessage httpResponse = await s_httpClient.GetAsync(address).ConfigureAwait(false);

src\DownloadFile.cs (1)

199var httpResponse = await httpClient.GetAsync(uri, _cancellationSource.Token).ConfigureAwait(false);

Internal\GitHubMembershipClient.cs (3)

106using var userResponse = await client.GetAsync( 124using var membershipResponse = await client.GetAsync( 149using var publicMembershipResponse = await client.GetAsync(

ContentSafetyService.cs (6)

201HttpResponseMessage response = 252HttpResponseMessage response = 308HttpResponseMessage response = 357HttpResponseMessage response; 406private async ValueTask<HttpResponseMessage> GetResponseAsync( 419HttpResponseMessage response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);

VerbatimHttpHandler.cs (2)

44protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 79using var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

VerbatimMultiPartHttpHandler.cs (1)

46protected override async Task<HttpResponseMessage> SendAsync(

OpenAIHostedFileClientTests.cs (3)

902protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) => 906private sealed class RoutingHandler(Func<HttpRequestMessage, HttpResponseMessage> handler) : HttpMessageHandler 908protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) =>

OpenAIRequestPoliciesTests.cs (1)

163protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)

OpenAIResponseClientTests.cs (1)

7364protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)

ThrowUserAgentExceptionHandler.cs (1)

13protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) =>

Readers\DocumentReaderConformanceTests.cs (4)

80using HttpResponseMessage response = await DownloadAsync(new(source)); 152protected static async Task<HttpResponseMessage> DownloadAsync(Uri uri) 156HttpResponseMessage response = await _httpClient.GetAsync(uri); 181using HttpResponseMessage response = await DownloadAsync(uri);

HttpMessageHandlerBuilder.cs (1)

73/// of sending an <see cref="HttpRequestMessage"/> and receiving an <see cref="HttpResponseMessage"/>.

Logging\HttpClientLoggerHandler.cs (4)

25protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 30HttpResponseMessage? response = null; 65protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 70HttpResponseMessage? response = null;

Logging\IHttpClientAsyncLogger.cs (3)

24/// <see cref="HttpResponseMessage"/> properties, such as reading from a content stream; if possible, such behavior should be avoided. 51ValueTask LogRequestStopAsync(object? context, HttpRequestMessage request, HttpResponseMessage response, TimeSpan elapsed, CancellationToken cancellationToken = default); 63ValueTask LogRequestFailedAsync(object? context, HttpRequestMessage request, HttpResponseMessage? response, Exception exception, TimeSpan elapsed, CancellationToken cancellationToken = default);

Logging\IHttpClientLogger.cs (3)

16/// <see cref="HttpResponseMessage"/> properties, such as reading from a content stream; if possible, such behavior should be avoided. 39void LogRequestStop(object? context, HttpRequestMessage request, HttpResponseMessage response, TimeSpan elapsed); 49void LogRequestFailed(object? context, HttpRequestMessage request, HttpResponseMessage? response, Exception exception, TimeSpan elapsed);

Logging\LoggingHttpMessageHandler.cs (5)

49private Task<HttpResponseMessage> SendCoreAsync(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 54async Task<HttpResponseMessage> Core(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 65HttpResponseMessage response = useAsync 86protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 92protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

Logging\LoggingScopeHttpMessageHandler.cs (5)

48private Task<HttpResponseMessage> SendCoreAsync(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 53async Task<HttpResponseMessage> Core(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) 65HttpResponseMessage response = useAsync 87protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 93protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

Logging\LogHelper.cs (2)

87public static void LogRequestEnd(this ILogger logger, HttpResponseMessage response, TimeSpan duration, Func<string, bool> shouldRedactHeaderValue) 126public static void LogRequestPipelineEnd(this ILogger logger, HttpResponseMessage response, TimeSpan duration, Func<string, bool> shouldRedactHeaderValue)

Latency\Internal\HttpClientLatencyLogEnricher.cs (1)

39public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage? request, HttpResponseMessage? response, Exception? exception)

Latency\Internal\HttpLatencyMediator.cs (1)

29public void RecordEnd(ILatencyContext latencyContext, HttpResponseMessage? response = null)

Latency\Internal\HttpLatencyTelemetryHandler.cs (1)

45protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Logging\IHttpClientLogEnricher.cs (2)

20/// <param name="response"><see cref="HttpResponseMessage"/> object associated with the outgoing HTTP request.</param> 26void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception);

Logging\Internal\HttpClientLogger.cs (6)

113HttpResponseMessage response, 121HttpResponseMessage? response, 130public void LogRequestStop(object? context, HttpRequestMessage request, HttpResponseMessage response, TimeSpan elapsed) 133public void LogRequestFailed(object? context, HttpRequestMessage request, HttpResponseMessage? response, Exception exception, TimeSpan elapsed) 153HttpResponseMessage? response, 219HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\HttpHeadersReader.cs (1)

55public void ReadResponseHeaders(HttpResponseMessage response, List<KeyValuePair<string, string>>? destination)

Logging\Internal\HttpRequestReader.cs (1)

100public async Task ReadResponseAsync(LogRecord logRecord, HttpResponseMessage response,

Logging\Internal\HttpResponseBodyReader.cs (3)

47public ValueTask<string> ReadAsync(HttpResponseMessage response, CancellationToken cancellationToken) 63private static async ValueTask<string> ReadFromStreamWithTimeoutAsync(HttpResponseMessage response, TimeSpan readTimeout, int readSizeLimit, CancellationToken cancellationToken) 93private static async ValueTask<string> ReadFromStreamAsync(HttpResponseMessage response, int readSizeLimit, CancellationToken cancellationToken)

Logging\Internal\IHttpHeadersReader.cs (2)

25/// <param name="response">An instance of <see cref="HttpResponseMessage"/> to read headers from.</param> 27void ReadResponseHeaders(HttpResponseMessage response, List<KeyValuePair<string, string>>? destination);

Logging\Internal\IHttpRequestReader.cs (3)

12/// Methods to read <see cref="HttpResponseMessage"/> or <see cref="HttpRequestMessage"/>. 17/// Reads <see cref="HttpResponseMessage"/>. 24Task ReadResponseAsync(LogRecord record, HttpResponseMessage response,

Logging\Internal\Log.cs (1)

14/// Logs <see cref="HttpRequestMessage"/>, <see cref="HttpResponseMessage"/> and the exceptions due to errors of request/response.

BenchEnricher.cs (1)

15public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Benchmarks\HugeHttpCLientLoggingBenchmark.cs (32)

Benchmarks\MediumHttpClientLoggingBenchmark.cs (32)

Benchmarks\SmallHttpClientLoggingBenchmark.cs (32)

NoRemoteCallHandler.cs (2)

35protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 37var response = new HttpResponseMessage

NoRemoteCallNotSeekableHandler.cs (2)

38protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 40var response = new HttpResponseMessage

Latency\Internal\HttpClientLatencyLogEnricherTest.cs (2)

46using HttpResponseMessage httpResponseMessage = new(); 66using HttpResponseMessage httpResponseMessage = new();

Latency\Internal\HttpLatencyMediatorTests.cs (3)

69var resp = new HttpResponseMessage(); 71mockHandler.Protected().Setup<Task<HttpResponseMessage>>( 120using var response = new HttpResponseMessage();

Latency\Internal\HttpLatencyTelemetryHandlerTest.cs (2)

64var resp = new Mock<HttpResponseMessage>(); 66mockHandler.Protected().Setup<Task<HttpResponseMessage>>(

Logging\AcceptanceTests.cs (7)

40using var _ = await httpClient.GetAsync(_unreachableRequestUri); 71using var _ = await httpClient.GetAsync(_unreachableRequestUri); 197using var content = await httpClient 251var content = await firstClient!.SendRequest(httpRequestMessage); 363using var _ = await httpClient.SendAsync(httpRequestMessage); 432using var _ = await httpClient.SendAsync(httpRequestMessage); 690var content = await client.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead);

Logging\HttpClientLoggerTest.cs (21)

Logging\HttpClientLoggingExtensionsTest.cs (10)

662var response = new HttpResponseMessage(HttpStatusCode.OK); 673using var response = await client.GetAsync("http://localhost/api"); 748using var response = await client.GetAsync("http://localhost/api"); 769using var response = await client.SendAsync(request); 791using var response = await client.SendAsync(request); 804var response = new HttpResponseMessage(HttpStatusCode.OK); 815using var response = await client.GetAsync("http://localhost/api"); 846private sealed class TestMessageHandler(Func<HttpRequestMessage, HttpResponseMessage> responseFactory) 849protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 859protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Logging\HttpHeadersReaderTest.cs (4)

24using var httpResponse = new HttpResponseMessage(); 42using var httpResponse = new HttpResponseMessage(); 145using var httpResponse = new HttpResponseMessage { Content = responseContent }; 178using var httpResponse = new HttpResponseMessage();

Logging\HttpRequestReaderTest.cs (7)

93using var httpResponseMessage = new HttpResponseMessage 155using var httpResponseMessage = new HttpResponseMessage 226using var httpResponseMessage = new HttpResponseMessage 302using var httpResponseMessage = new HttpResponseMessage 435using var httpResponseMessage = new HttpResponseMessage 504using var httpResponseMessage = new HttpResponseMessage 574using var httpResponseMessage = new HttpResponseMessage

Logging\HttpResponseBodyReaderTest.cs (10)

Logging\Internal\EmptyEnricher.cs (1)

12public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\EnricherWithCounter.cs (1)

14public void Enrich(IEnrichmentTagCollector collector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\ITestHttpClient1.cs (1)

11Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage);

Logging\Internal\ITestHttpClient2.cs (1)

11Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage);

Logging\Internal\MockedRequestReader.cs (1)

23HttpResponseMessage response,

Logging\Internal\NoRemoteCallHandler.cs (2)

29protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 31var response = new HttpResponseMessage

Logging\Internal\TestEnricher.cs (1)

29public void Enrich(IEnrichmentTagCollector tagCollector, HttpRequestMessage request, HttpResponseMessage? response, Exception? exception)

Logging\Internal\TestHttpClient1.cs (1)

18public Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage)

Logging\Internal\TestHttpClient2.cs (1)

18public Task<HttpResponseMessage> SendRequest(HttpRequestMessage httpRequestMessage)

Logging\Internal\TestingHandlerStub.cs (3)

13private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _handlerFunc; 15public TestingHandlerStub(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> handlerFunc) 20protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) => _handlerFunc(request, cancellationToken);

DependencyInjection\PollyHttpClientBuilderExtensions.cs (10)

HttpRequestMessageExtensions.cs (2)

25/// The <see cref="PolicyHttpMessageHandler"/> will attach a context to the <see cref="HttpResponseMessage"/> prior 46/// The <see cref="PolicyHttpMessageHandler"/> will attach a context to the <see cref="HttpResponseMessage"/> prior

PolicyHttpMessageHandler.cs (12)

Hedging\HttpClientHedgingResiliencePredicates.cs (3)

25public static bool IsTransient(Outcome<HttpResponseMessage> outcome) 34/// Determines whether an <see cref="HttpResponseMessage"/> should be treated by hedging as a transient failure. 40public static bool IsTransient(Outcome<HttpResponseMessage> outcome, CancellationToken cancellationToken)

Hedging\HttpHedgingStrategyOptions.cs (2)

13/// Implementation of the <see cref="HedgingStrategyOptions{TResult}"/> class for <see cref="HttpResponseMessage"/> results. 15public class HttpHedgingStrategyOptions : HedgingStrategyOptions<HttpResponseMessage>

Internal\RetryAfterHelper.cs (1)

16internal static bool TryParse(HttpResponseMessage response, TimeProvider timeProvider, out TimeSpan retryAfter)

Internal\RetryBudgetStrategy.cs (5)

37public static Func<RetryPredicateArguments<HttpResponseMessage>, ValueTask<bool>> WrapShouldHandle( 38Func<RetryPredicateArguments<HttpResponseMessage>, ValueTask<bool>> shouldHandle, 55static async ValueTask<bool> EvaluateBudgetAsync(ValueTask<bool> handled, RetryPredicateArguments<HttpResponseMessage> args, int maxRetryAttempts) 80private static bool EvaluateBudget(bool handled, RetryPredicateArguments<HttpResponseMessage> args, int maxRetryAttempts) 97private bool TryAcquireRetry(RetryPredicateArguments<HttpResponseMessage> args)

Polly\HttpCircuitBreakerStrategyOptions.cs (2)

11/// Implementation of the <see cref="CircuitBreakerStrategyOptions{TResult}"/> for <see cref="HttpResponseMessage"/> results. 13public class HttpCircuitBreakerStrategyOptions : CircuitBreakerStrategyOptions<HttpResponseMessage>

Polly\HttpClientResiliencePredicates.cs (5)

25public static bool IsTransient(Outcome<HttpResponseMessage> outcome) => outcome switch 33/// Determines whether an <see cref="HttpResponseMessage"/> should be treated by resilience strategies as a transient failure. 39public static bool IsTransient(Outcome<HttpResponseMessage> outcome, CancellationToken cancellationToken) 53internal static bool IsHttpConnectionTimeout(in Outcome<HttpResponseMessage> outcome, in CancellationToken cancellationToken) 63internal static bool IsTransientHttpFailure(HttpResponseMessage response)

Polly\HttpRetryResiliencePipelineBuilderExtensions.cs (6)

40public static ResiliencePipelineBuilder<HttpResponseMessage> AddRetryWithBudget(this ResiliencePipelineBuilder<HttpResponseMessage> builder, HttpRetryStrategyOptions options) 49internal static ResiliencePipelineBuilder<HttpResponseMessage> AddRetryWithOptionalBudget(this ResiliencePipelineBuilder<HttpResponseMessage> builder, HttpRetryStrategyOptions options) 86private static ResiliencePipelineBuilder<HttpResponseMessage> AddBudgetedRetry( 87ResiliencePipelineBuilder<HttpResponseMessage> builder,

Polly\HttpRetryStrategyOptions.cs (4)

19/// Implementation of the <see cref="RetryStrategyOptions{TResult}"/> for <see cref="HttpResponseMessage"/> results. 21public class HttpRetryStrategyOptions : RetryStrategyOptions<HttpResponseMessage> 61HttpResponseMessage response when RetryAfterHelper.TryParse(response, TimeProvider.System, out var retryAfter) => new ValueTask<TimeSpan?>(retryAfter), 80/// <see cref="HttpRetryResiliencePipelineBuilderExtensions.AddRetryWithBudget(ResiliencePipelineBuilder{HttpResponseMessage}, HttpRetryStrategyOptions)"/>.

Polly\HttpRetryStrategyOptionsExtensions.cs (2)

33/// <see cref="HttpRetryResiliencePipelineBuilderExtensions.AddRetryWithBudget(ResiliencePipelineBuilder{HttpResponseMessage}, HttpRetryStrategyOptions)"/> 83private static HttpRequestMessage? GetRequestMessage(RetryPredicateArguments<HttpResponseMessage> args) =>

Resilience\Internal\HttpResilienceMetricsEnricher.cs (2)

14if (typeof(TResult) != typeof(HttpResponseMessage)) 19if (context.TelemetryEvent.Outcome.HasValue && context.TelemetryEvent.Outcome.Value.Result is HttpResponseMessage response)

Resilience\ResilienceHandler.cs (12)

Resilience\ResilienceHttpClientBuilderExtensions.Resilience.cs (7)

37Action<ResiliencePipelineBuilder<HttpResponseMessage>> configure) 60Action<ResiliencePipelineBuilder<HttpResponseMessage>, ResilienceHandlerContext> configure) 101private static Func<HttpRequestMessage, ResiliencePipeline<HttpResponseMessage>> CreatePipelineSelector(IServiceProvider serviceProvider, string pipelineName) 108var pipeline = resilienceProvider.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, string.Empty)); 118return resilienceProvider.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, key)); 136Action<ResiliencePipelineBuilder<HttpResponseMessage>, ResilienceHandlerContext> configure) 141_ = builder.Services.AddResiliencePipeline<HttpKey, HttpResponseMessage>(key, (builder, context) => configure(builder, new ResilienceHandlerContext(context)));

EmptyHandler.cs (1)

12protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

HedgingBenchmark.cs (1)

37public Task<HttpResponseMessage> HedgingCall() => _client.SendAsync(Request, CancellationToken.None);

HttpResilienceBenchmark.cs (5)

46public Task<HttpResponseMessage> DefaultClient() 52public Task<HttpResponseMessage> SingleHandler() 58public Task<HttpResponseMessage> StandardResilienceHandler() 64public Task<HttpResponseMessage> StandardHedgingHandler_RoutesFromRequest() 70public Task<HttpResponseMessage> StandardHedgingHandler_RoutesFromConfig()

NoRemoteCallHandler.cs (4)

12private readonly HttpResponseMessage _response; 13private readonly Task<HttpResponseMessage> _completedResponse; 26protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 33protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

RetryBenchmark.cs (4)

48var builder = Policy.Handle<HttpRequestException>().Or<TimeoutRejectedException>().OrResult<HttpResponseMessage>(r => 69public Task<HttpResponseMessage> Retry_Polly_V7() 75public Task<HttpResponseMessage> Retry_Polly_V8() 81public HttpResponseMessage Retry_Polly_V8_Sync()

StandardResilienceBenchmark.cs (7)

43var builder = Policy.Handle<HttpRequestException>().Or<TimeoutRejectedException>().OrResult<HttpResponseMessage>(r => 53Policy.TimeoutAsync<HttpResponseMessage>(3), 56Policy.BulkheadAsync<HttpResponseMessage>(1000, 100), 57Policy.TimeoutAsync<HttpResponseMessage>(30)); 71public Task<HttpResponseMessage> StandardPipeline_Polly_V7() 77public Task<HttpResponseMessage> StandardPipeline_Polly_V8() 83public HttpResponseMessage StandardPipeline_Polly_V8_Sync()

Hedging\HedgingTests.cs (11)

37private readonly Queue<HttpResponseMessage> _responses = new(); 68foreach (var response in _responses) 107using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 127using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 200using var result = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 224using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 250using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 277using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 300using var result = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 308protected static Task<HttpResponseMessage> SendRequest( 348private Task<HttpResponseMessage> InnerHandlerFunction(HttpRequestMessage request, CancellationToken cancellationToken)

Hedging\HttpClientHedgingResiliencePredicatesTests.cs (6)

29Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new TimeoutRejectedException()))); 30Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new BrokenCircuitException()))); 31Assert.True(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new HttpRequestException()))); 32Assert.False(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(new InvalidOperationException()))); 33Assert.False(HttpClientHedgingResiliencePredicates.IsTransient(Outcome.FromResult<HttpResponseMessage>(null))); 42using var response = new HttpResponseMessage(code);

Hedging\StandardHedgingTests.cs (14)

Helpers\TestHandlerStub.cs (4)

14private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _handlerFunc; 21public TestHandlerStub(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> handlerFunc) 26protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 32protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)

Internal\RequestMessageSnapshotStrategyTests.cs (2)

25using var response = await strategy.ExecuteAsync( 29return new ValueTask<HttpResponseMessage>(new HttpResponseMessage());

Internal\RetryAfterHelperTests.cs (4)

19using var response = new HttpResponseMessage(); 31using var response = new HttpResponseMessage(); 44using var response = new HttpResponseMessage(); 58using var response = new HttpResponseMessage();

Polly\HttpCircuitBreakerStrategyOptionsTests.cs (5)

59using var response = new HttpResponseMessage { StatusCode = statusCode }; 72private CircuitBreakerPredicateArguments<HttpResponseMessage> CreateArgs(Exception error) 73=> new(_context, Outcome.FromException<HttpResponseMessage>(error)); 75private CircuitBreakerPredicateArguments<HttpResponseMessage> CreateArgs(HttpResponseMessage response)

Polly\HttpClientResiliencePredicatesTests.cs (2)

39isTransientHttpException = HttpClientResiliencePredicates.IsTransient(Outcome.FromException<HttpResponseMessage>(ex)); 55var response = new HttpResponseMessage { StatusCode = statusCode };

Polly\HttpRetryResiliencePipelineBuilderExtensionsTests.cs (30)

Polly\HttpRetryStrategyOptionsExtensionsTests.cs (7)

50using var response = new HttpResponseMessage { RequestMessage = request }; 62using var response = new HttpResponseMessage { RequestMessage = request }; 86using var response = new HttpResponseMessage { RequestMessage = null }; 109using var response = new HttpResponseMessage { RequestMessage = request }; 140private static RetryPredicateArguments<HttpResponseMessage> CreatePredicateArguments(HttpResponseMessage? response, ResilienceContext? context = null) 142return new RetryPredicateArguments<HttpResponseMessage>(

Polly\HttpRetryStrategyOptionsTests.cs (10)

58var response = new HttpResponseMessage { StatusCode = statusCode }; 69var args = CreateArgs(Outcome.FromException<HttpResponseMessage>(exception), token ?? default); 83var response = new HttpResponseMessage { StatusCode = statusCode }; 93var args = CreateArgs(Outcome.FromException<HttpResponseMessage>(exception), token ?? default); 102using var responseMessage = new HttpResponseMessage(); 115Outcome.FromResult<HttpResponseMessage>(null), 121Outcome.FromException<HttpResponseMessage>(new InvalidOperationException()), 130using var responseMessage = new HttpResponseMessage 159private static RetryPredicateArguments<HttpResponseMessage> CreateArgs( 160Outcome<HttpResponseMessage> outcome,

Resilience\HttpClientBuilderExtensionsTests.BySelector.cs (2)

132.Setup(p => p.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, expectedPipelineKey))) 133.Returns(ResiliencePipeline<HttpResponseMessage>.Empty);

Resilience\HttpClientBuilderExtensionsTests.Resilience.cs (10)

36Assert.Throws<ArgumentNullException>(() => builder.AddResilienceHandler("dummy", (Action<ResiliencePipelineBuilder<HttpResponseMessage>>)null!)); 37Assert.Throws<ArgumentNullException>(() => builder.AddResilienceHandler("dummy", (Action<ResiliencePipelineBuilder<HttpResponseMessage>, ResilienceHandlerContext>)null!)); 135using var response = await SendRequest(client, "https://dummy", asynchronous); 220.Setup(v => v.GetPipeline<HttpResponseMessage>(new HttpKey(expectedPipelineKey, "https://dummy1"))) 221.Returns(ResiliencePipeline<HttpResponseMessage>.Empty); 226.Setup(v => v.GetPipeline<HttpResponseMessage>(new HttpKey(expectedPipelineKey, string.Empty))) 227.Returns(ResiliencePipeline<HttpResponseMessage>.Empty); 260.Setup(v => v.GetPipeline<HttpResponseMessage>(new HttpKey(pipelineName, string.Empty))) 261.Returns(ResiliencePipeline<HttpResponseMessage>.Empty) 361private void ConfigureBuilder(ResiliencePipelineBuilder<HttpResponseMessage> builder) => builder.AddTimeout(TimeSpan.FromSeconds(1));

Resilience\HttpClientBuilderExtensionsTests.Standard.cs (4)

39private static Task<HttpResponseMessage> SendRequest(HttpClient client, string url, bool asynchronous) 165var descriptor = provider.GetPipeline<HttpResponseMessage>(new HttpKey("test-standard", string.Empty)).GetPipelineDescriptor(); 295private static ResiliencePipeline<HttpResponseMessage> GetPipeline(IServiceCollection services, string name) 299return provider.GetPipeline<HttpResponseMessage>(new HttpKey(name, string.Empty));

Resilience\HttpResilienceMetricsEnricherTests.cs (4)

34var context = new EnrichmentContext<HttpResponseMessage, string>(default, tags); 46using var response = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError); 47var args = new TelemetryEventArguments<HttpResponseMessage, string>(default!, default!, default!, default!, Outcome.FromResult(response)); 48var context = new EnrichmentContext<HttpResponseMessage, string>(args, tags);

Resilience\ResilienceHandlerTest.cs (8)

28using var handler = new ResilienceHandler(ResiliencePipeline<HttpResponseMessage>.Empty); 66using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 98using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 115var response = await InvokeHandler(invoker, request, asynchronous); 129using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 140var response = await InvokeHandler(invoker, request, asynchronous, source.Token); 153using var handler = new ResilienceHandler(_ => ResiliencePipeline<HttpResponseMessage>.Empty); 162private static Task<HttpResponseMessage> InvokeHandler(

BlobAppendReferenceWrapper.cs (2)

33Task<HttpResponseMessage> AppendDataAsync() 44var response = await AppendDataAsync().ConfigureAwait(false);

ModelLoaders\UriModelLoader.cs (2)

110var resp = await client.SendAsync(headRequest); 143var resp = await client.GetAsync(_uri);

Http\ResolvingHttpClientHandler.cs (1)

17protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

Http\ResolvingHttpDelegatingHandler.cs (1)

41protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

StreamWrapper.cs (1)

95 var response = await client.GetAsync(uri, cancellationToken).ConfigureAwait(false);

DatasetUtil.cs (1)

210var response = await client.GetAsync(url).ConfigureAwait(false);

Utilities\ResourceManagerUtils.cs (1)

268var response = await httpClient.GetAsync(uri, ct).ConfigureAwait(false);

ImageClassificationBench.cs (3)

163var headerResponse = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead).Result; 171var response = client.GetAsync(url).Result; 180var response = client.GetAsync(url).Result;

TestDownloadUtils.cs (1)

31using (var response = client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationSource.Token).GetAwaiter().GetResult())

Utils\Helpers.netcoreapp.cs (1)

34HttpResponseMessage response = client.Send(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseHeadersRead);

parent\Microsoft.ML.Tokenizers.Tests\Utils.cs (1)

21var response = await client.GetAsync(url);

parent\parent\src\Microsoft.ML.Tokenizers\Utils\Helpers.netcoreapp.cs (1)

34HttpResponseMessage response = client.Send(new HttpRequestMessage(HttpMethod.Get, url), HttpCompletionOption.ResponseHeadersRead);

Utils.cs (1)

21var response = await client.GetAsync(url);

AmazonECRMessageHandler.cs (1)

20protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

AuthHandshakeMessageHandler.cs (7)

74private static bool TryParseAuthenticationInfo(HttpResponseMessage msg, [NotNullWhen(true)] out string? scheme, out AuthInfo? bearerAuthInfo) 301private void ValidateAuthenticationOrigin(HttpResponseMessage response, Uri requestUri) 423using HttpResponseMessage postResponse = await realmClient.SendAsync(postMessage, cancellationToken).ConfigureAwait(false); 467using var tokenResponse = await realmClient.SendAsync(message, cancellationToken).ConfigureAwait(false); 507protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 527var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false); 543HttpResponseMessage authenticatedResponse = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

AuthRealmHandlerFactory.cs (4)

142protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 144HttpResponseMessage response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false); 177private static Uri? GetRedirectUri(Uri requestUri, HttpResponseMessage response) 211protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

FallbackToHttpMessageHandler.cs (2)

30protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 58HttpResponseMessage response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);

Registry\DefaultBlobOperations.cs (7)

33using HttpResponseMessage response = await _client.SendAsync(new HttpRequestMessage(HttpMethod.Head, new Uri(_baseUri, $"/v2/{repositoryName}/blobs/{digest}")), cancellationToken).ConfigureAwait(false); 57HttpResponseMessage response = await GetResponseAsync(repositoryName, digest, cancellationToken).ConfigureAwait(false); 64using HttpResponseMessage response = await GetResponseAsync(repositoryName, digest, cancellationToken).ConfigureAwait(false); 70private async Task<HttpResponseMessage> GetResponseAsync(string repositoryName, string digest, CancellationToken cancellationToken) 74HttpResponseMessage response = await _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false); 79_ => await LogAndThrowContainerHttpException<HttpResponseMessage>(response, cancellationToken).ConfigureAwait(false) 83private async Task<T> LogAndThrowContainerHttpException<T>(HttpResponseMessage response, CancellationToken cancellationToken)

Registry\DefaultBlobUploadOperations.cs (5)

31HttpResponseMessage finalizeResponse = await _client.PutAsync(putUri, null, cancellationToken).ConfigureAwait(false); 43public async Task<HttpResponseMessage> GetStatusAsync(Uri uploadUri, CancellationToken cancellationToken) 53HttpResponseMessage pushResponse = await _client.PostAsync(startUploadUri, content: null, cancellationToken).ConfigureAwait(false); 69HttpResponseMessage pushResponse = await _client.PostAsync(new Uri(_baseUri, $"/v2/{destinationRepository}/blobs/uploads/?mount={digest}&from={sourceRepository}"), content: null, cancellationToken).ConfigureAwait(false); 110using HttpResponseMessage patchResponse = await _client.SendAsync(patchMessage, cancellationToken).ConfigureAwait(false);

Registry\DefaultManifestOperations.cs (4)

31using HttpResponseMessage response = await _client.SendAsync(request, cancellationToken).ConfigureAwait(false); 52using HttpResponseMessage response = await _client.SendAsync(request, cancellationToken).ConfigureAwait(false); 98HttpResponseMessage putResponse = await _client.PutAsync(new Uri(_baseUri, $"/v2/{repositoryName}/manifests/{reference}"), manifestUploadContent, cancellationToken).ConfigureAwait(false); 107private async Task<T> LogAndThrowContainerHttpException<T>(HttpResponseMessage response, CancellationToken cancellationToken)

Registry\HttpExtensions.cs (2)

31public static Uri GetNextLocation(this HttpResponseMessage response) 67internal static async Task LogHttpResponseAsync(this HttpResponseMessage response, ILogger logger, CancellationToken cancellationToken)

Registry\IBlobUploadOperations.cs (1)

22public Task<HttpResponseMessage> GetStatusAsync(Uri uploadUri, CancellationToken cancellationToken);

Kudu\KuduVfsDeploy.cs (1)

72using (var response = await client.SendAsync(req))

Kudu\KuduZipDeploy.cs (1)

63using (var response = await client.SendAsync(req))

Tasks\Http\DefaultHttpClient.cs (3)

20public Task<HttpResponseMessage> PostAsync(Uri uri, StreamContent content) 26public Task<HttpResponseMessage> GetAsync(Uri uri, CancellationToken cancellationToken) 32public Task<HttpResponseMessage> PutAsync(Uri uri, StreamContent content, CancellationToken cancellationToken)

Tasks\Http\HttpClientExtensions.cs (3)

72HttpResponseMessage responseMessage = await client.PostAsync(uri, content); 130HttpResponseMessage responseMessage = await client.PutAsync(uri, content, cancellationToken); 166HttpResponseMessage responseMessage = await client.GetAsync(uri, cancellationToken);

Tasks\Http\HttpResponseMessageWrapper.cs (2)

11private readonly HttpResponseMessage _message; 14public HttpResponseMessageWrapper(HttpResponseMessage message)

Tasks\Http\IHttpClient.cs (3)

25Task<HttpResponseMessage> PostAsync(Uri uri, StreamContent content); 33Task<HttpResponseMessage> GetAsync(Uri uri, CancellationToken cancellationToken); 42Task<HttpResponseMessage> PutAsync(Uri uri, StreamContent content, CancellationToken cancellationToken);

Providers\NuGetMetadataSearchProvider.cs (2)

185using HttpResponseMessage response = await client.GetAsync(searchMetadataUri, cancellationToken).ConfigureAwait(false); 236private string GetResponseDetails(HttpResponseMessage response)

netstandard.cs (1)

1132[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Net.Http.HttpResponseMessage))]

Signing\Timestamp\Rfc3161TimestampRequestNetstandard21Wrapper.cs (1)

59using (HttpResponseMessage httpResponse = await HttpClient.PostAsync(timestampUri, content))

HttpResponseMessageExtensions.cs (1)

12public static void LogServerWarning(this HttpResponseMessage response, ILogger log)

HttpSource\DownloadTimeoutStreamContent.cs (1)

12/// to the contained stream. When the <see cref="HttpResponseMessage"/> is disposed, this

HttpSource\HttpCacheUtility.cs (1)

53HttpResponseMessage response,

HttpSource\HttpRetryHandler.cs (4)

41public Task<HttpResponseMessage> SendAsync( 57public async Task<HttpResponseMessage> SendAsync( 75HttpResponseMessage? response = null; 157var responseMessage = await request.HttpClient.SendAsync(requestMessage, request.CompletionOption, timeoutToken);

HttpSource\HttpSource.cs (6)

220Func<HttpResponseMessage?, Task<T>> processAsync, 275Func<HttpResponseMessage, Task<T>> processAsync, 284Func<HttpResponseMessage, Task<T>> processAsync, 354HttpResponseMessage response; 490public ThrottledResponse(IThrottle throttle, HttpResponseMessage response) 506public HttpResponseMessage Response { get; }

HttpSource\HttpSourceAuthenticationHandler.cs (2)

68protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 75HttpResponseMessage? response = null;

HttpSource\HttpSourceCachedRequest.cs (2)

63/// When processing the <see cref="HttpResponseMessage"/>, this flag allows 79/// The timeout to use when fetching the <see cref="HttpResponseMessage"/>. Since

HttpSource\HttpSourceRequest.cs (2)

43/// When processing the <see cref="HttpResponseMessage"/>, this flag allows 50/// The timeout to use when fetching the <see cref="HttpResponseMessage"/>. Since

HttpSource\IHttpRetryHandler.cs (2)

13Task<HttpResponseMessage> SendAsync( 18Task<HttpResponseMessage> SendAsync(

HttpSource\ProxyAuthenticationHandler.cs (2)

57protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, 60HttpResponseMessage? response = null;

HttpSource\ServerWarningLogHandler.cs (2)

19protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 23var response = await base.SendAsync(request, cancellationToken);

Resources\PackageSearchResourceV3.cs (4)

227internal async Task<IReadOnlyList<PackageSearchMetadata>> ProcessHttpStreamTakeCountedItemAsync(HttpResponseMessage? httpInitialResponse, int take, CancellationToken token) 238private async Task<V3SearchResults?> ProcessHttpStreamWithoutBufferingAsync(HttpResponseMessage? httpInitialResponse, uint take, CancellationToken token) 261private static async Task<V3SearchResults?> ProcessHttpStreamWithStjAsync(HttpResponseMessage httpInitialResponse, uint take, CancellationToken token) 282private static async Task<V3SearchResults?> ProcessHttpStreamWithNsjAsync(HttpResponseMessage httpInitialResponse, uint take, CancellationToken token)

Resources\PackageUpdateResource.cs (1)

535private static HttpStatusCode? EnsureSuccessStatusCode(HttpResponseMessage response, HttpStatusCode? codeNotToThrow, ILogger logger)

DistributedApplicationPipelineExtensions.cs (1)

162var response = await httpClient.PostAsync(kuduUrl, content, cancellationToken).ConfigureAwait(false);

Program.cs (1)

227var response = await client.GetAsync(url);

System\Net\Http\DelegatingHandler.cs (2)

45protected internal override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 53protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

System\Net\Http\DiagnosticsHandler.cs (11)

76internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 85new ValueTask<HttpResponseMessage>(_innerHandler.SendAsync(request, cancellationToken)) : 86new ValueTask<HttpResponseMessage>(_innerHandler.Send(request, cancellationToken)); 90private async ValueTask<HttpResponseMessage> SendAsyncCore(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 160HttpResponseMessage? response = null; 280internal ActivityStopData(HttpResponseMessage? response, HttpRequestMessage request, TaskStatus requestTaskStatus) 287public HttpResponseMessage? Response { get; } 338[DynamicDependency(nameof(HttpResponseMessage.StatusCode), typeof(HttpResponseMessage))] 339internal ResponseData(HttpResponseMessage? response, Guid loggingRequestId, long timestamp, TaskStatus requestTaskStatus) 347public HttpResponseMessage? Response { get; }

System\Net\Http\DiagnosticsHelper.cs (1)

53public static bool TryGetErrorType(HttpResponseMessage? response, Exception? exception, out string? errorType)

System\Net\Http\HttpClient.cs (41)

System\Net\Http\HttpClientHandler.cs (2)

350protected internal override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 360protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

System\Net\Http\HttpMessageHandler.cs (2)

22protected internal virtual HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 27protected internal abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);

System\Net\Http\HttpMessageInvoker.cs (5)

35public virtual HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken) 45HttpResponseMessage? response = null; 67public virtual Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 80static async Task<HttpResponseMessage> SendAsyncWithTelemetry(HttpMessageHandler handler, HttpRequestMessage request, CancellationToken cancellationToken) 84HttpResponseMessage? response = null;

System\Net\Http\HttpResponseMessage.cs (1)

161public HttpResponseMessage EnsureSuccessStatusCode()

System\Net\Http\HttpTelemetry.cs (1)

63public void RequestStop(HttpResponseMessage? response)

System\Net\Http\MessageProcessingHandler.cs (10)

27protected abstract HttpResponseMessage ProcessResponse(HttpResponseMessage response, 30protected internal sealed override HttpResponseMessage Send(HttpRequestMessage request, 37HttpResponseMessage response = base.Send(newRequestMessage, cancellationToken); 38HttpResponseMessage newResponseMessage = ProcessResponse(response, cancellationToken); 42protected internal sealed override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, 56Task<HttpResponseMessage> sendAsyncTask = base.SendAsync(newRequestMessage, cancellationToken); 86HttpResponseMessage responseMessage = self.ProcessResponse(task.Result, token); 118TaskCompletionSource<HttpResponseMessage> tcs, OperationCanceledException e) 136private sealed class SendState : TaskCompletionSource<HttpResponseMessage>

System\Net\Http\Metrics\HttpMetricsEnrichmentContext.cs (3)

26private HttpResponseMessage? _response; 46public HttpResponseMessage? Response => _response; 102HttpResponseMessage? response,

System\Net\Http\Metrics\MetricsHandler.cs (6)

158internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 167new ValueTask<HttpResponseMessage>(_innerHandler.SendAsync(request, cancellationToken)) : 168new ValueTask<HttpResponseMessage>(_innerHandler.Send(request, cancellationToken)); 172private async ValueTask<HttpResponseMessage> SendAsyncWithMetrics(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 177HttpResponseMessage? response = null; 221private void RequestStop(HttpRequestMessage request, HttpResponseMessage? response, Exception? exception, long startTimestamp, bool recordCurrentRequests, ActiveRequestsTagKey requestTagKey)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.cs (10)

System\Net\Http\SocketsHttpHandler\AuthenticationHelper.NtAuth.cs (6)

21private static Task<HttpResponseMessage> InnerSendAsync(HttpRequestMessage request, bool async, bool isProxyAuth, HttpConnectionPool pool, HttpConnection connection, CancellationToken cancellationToken) 28private static bool ProxySupportsConnectionAuth(HttpResponseMessage response) 46private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMessage request, Uri authUri, bool async, ICredentials credentials, TokenImpersonationLevel impersonationLevel, bool isProxyAuth, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken) 48HttpResponseMessage response = await InnerSendAsync(request, async, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(false); 205public static Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, Uri proxyUri, bool async, ICredentials proxyCredentials, TokenImpersonationLevel impersonationLevel, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken) 210public static Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpRequestMessage request, bool async, ICredentials credentials, TokenImpersonationLevel impersonationLevel, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (2)

21private readonly HttpResponseMessage _response; 23public ChunkedEncodingReadStream(HttpConnection connection, HttpResponseMessage response) : base(connection)

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.cs (7)

356public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 375public ValueTask<HttpResponseMessage> SendWithProxyAuthAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 385private Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpConnection connection, HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 395public Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpConnection connection, HttpRequestMessage request, bool async, CancellationToken cancellationToken) 405public async ValueTask<HttpResponseMessage> SendWithVersionDetectionAndRetryAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 422HttpResponseMessage? response = null; 809HttpResponseMessage tunnelResponse = await _poolManager.SendProxyConnectAsync(tunnelRequest, _proxyUri!, async, cancellationToken).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http3.cs (3)

64private async ValueTask<HttpResponseMessage?> TrySendUsingHttp3Async(HttpRequestMessage request, CancellationToken cancellationToken) 108HttpResponseMessage response = await connection.SendAsync(request, waitForConnectionActivity, streamAvailable, cancellationToken).ConfigureAwait(false); 638private void ProcessAltSvc(HttpResponseMessage response)

System\Net\Http\SocketsHttpHandler\CookieHelper.cs (1)

12public static void ProcessReceivedCookies(HttpResponseMessage response, CookieContainer cookieContainer)

System\Net\Http\SocketsHttpHandler\DecompressionHandler.cs (2)

66internal override async ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 98HttpResponseMessage response = await _innerHandler.SendAsync(request, async, cancellationToken).ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\Http2Connection.cs (2)

2078public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 2147HttpResponseMessage response = http2Stream.GetAndClearResponse();

System\Net\Http\SocketsHttpHandler\Http2Stream.cs (9)

System\Net\Http\SocketsHttpHandler\Http3Connection.cs (2)

266public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, WaitForHttp3ConnectionActivity waitForConnectionActivity, bool streamAvailable, CancellationToken cancellationToken) 338Task<HttpResponseMessage> responseTask = requestStream.SendAsync(cancellationToken);

System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (8)

System\Net\Http\SocketsHttpHandler\HttpConnection.cs (8)

533public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 668var response = new HttpResponseMessage() { RequestMessage = request, Content = new HttpConnectionResponseContent() }; 1032private bool ParseStatusLine(HttpResponseMessage response) 1061private static void ParseStatusLineCore(Span<byte> line, HttpResponseMessage response) 1134private bool ParseHeaders(HttpResponseMessage? response, bool isFromTrailer) 1153private (bool finished, int bytesConsumed) ParseHeadersCore(Span<byte> buffer, HttpResponseMessage? response, bool isFromTrailer) 1232private void AddResponseHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value, HttpResponseMessage response, bool isFromTrailer) 2100public async ValueTask DrainResponseAsync(HttpResponseMessage response, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpConnectionHandler.cs (1)

20internal override ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpConnectionPoolManager.cs (4)

354public ValueTask<HttpResponseMessage> SendAsyncCore(HttpRequestMessage request, Uri? proxyUri, bool async, bool doRequestAuth, bool isProxyConnect, CancellationToken cancellationToken) 404public ValueTask<HttpResponseMessage> SendProxyConnectAsync(HttpRequestMessage request, Uri proxyUri, bool async, CancellationToken cancellationToken) 409public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, bool doRequestAuth, CancellationToken cancellationToken) 462private async ValueTask<HttpResponseMessage> SendAsyncMultiProxy(HttpRequestMessage request, bool async, bool doRequestAuth, MultiProxy multiProxy, Uri? firstProxy, CancellationToken cancellationToken)

System\Net\Http\SocketsHttpHandler\HttpMessageHandlerStage.cs (4)

11protected internal sealed override HttpResponseMessage Send(HttpRequestMessage request, 14ValueTask<HttpResponseMessage> sendTask = SendAsync(request, async: false, cancellationToken); 20protected internal sealed override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) => 23internal abstract ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken);

System\Net\Http\SocketsHttpHandler\RedirectHandler.cs (3)

27internal override async ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cancellationToken) 29HttpResponseMessage response = await _innerHandler.SendAsync(request, async, cancellationToken).ConfigureAwait(false); 94private Uri? GetUriForRedirect(Uri requestUri, HttpResponseMessage response)

System\Net\Http\SocketsHttpHandler\SocketsHttpHandler.cs (5)

645protected internal override HttpResponseMessage Send(HttpRequestMessage request, 676protected internal override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) 684return Task.FromCanceled<HttpResponseMessage>(cancellationToken); 690return Task.FromException<HttpResponseMessage>(error); 700async Task<HttpResponseMessage> CreateHandlerAndSendAsync(HttpRequestMessage request, CancellationToken cancellationToken)

System\Net\Http\Json\HttpClientJsonExtensions.cs (9)

System\Net\Http\Json\HttpClientJsonExtensions.Delete.cs (1)

18private static readonly Func<HttpClient, Uri?, CancellationToken, Task<HttpResponseMessage>> s_deleteAsync =

System\Net\Http\Json\HttpClientJsonExtensions.Get.AsyncEnumerable.cs (1)

159using HttpResponseMessage response = await client.GetAsync(requestUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken)

System\Net\Http\Json\HttpClientJsonExtensions.Get.cs (1)

18private static readonly Func<HttpClient, Uri?, CancellationToken, Task<HttpResponseMessage>> s_getAsync =

System\Net\Http\Json\HttpClientJsonExtensions.Patch.cs (6)

27public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 48public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 68public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, CancellationToken cancellationToken) 83public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, CancellationToken cancellationToken) 97public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) 116public static Task<HttpResponseMessage> PatchAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default)

System\Net\Http\Json\HttpClientJsonExtensions.Post.cs (6)

16public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 26public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 36public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, CancellationToken cancellationToken) 41public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, CancellationToken cancellationToken) 44public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) 52public static Task<HttpResponseMessage> PostAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default)

System\Net\Http\Json\HttpClientJsonExtensions.Put.cs (6)

16public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 26public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonSerializerOptions? options = null, CancellationToken cancellationToken = default) 36public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, CancellationToken cancellationToken) 41public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, CancellationToken cancellationToken) 44public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default) 52public static Task<HttpResponseMessage> PutAsJsonAsync<TValue>(this HttpClient client, Uri? requestUri, TValue value, JsonTypeInfo<TValue> jsonTypeInfo, CancellationToken cancellationToken = default)

System\Net\Http\WinHttpHandler.cs (4)

591protected override Task<HttpResponseMessage> SendAsync( 629TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(); 1006HttpResponseMessage responseMessage = WinHttpResponseParser.CreateResponseMessage(state);

System\Net\Http\WinHttpRequestState.cs (1)

96public TaskCompletionSource<HttpResponseMessage>? Tcs { get; set; }

System\Net\Http\WinHttpResponseParser.cs (4)

18public static HttpResponseMessage CreateResponseMessage(WinHttpRequestState state) 25var response = new HttpResponseMessage(); 278HttpResponseMessage response, 320HttpResponseMessage response,

System\Net\Http\WinHttpResponseStream.cs (2)

21private readonly HttpResponseMessage _responseMessage; 25internal WinHttpResponseStream(SafeWinHttpHandle requestHandle, WinHttpRequestState state, HttpResponseMessage responseMessage)

System\Net\Http\WinHttpTrailersHelper.cs (1)

25public static HttpHeaders GetResponseTrailers(HttpResponseMessage response)

System\Net\HttpWebRequest.cs (3)

48private Task<HttpResponseMessage>? _sendRequestTask; 1194private Task<HttpResponseMessage> SendRequest(bool async, HttpContent? content = null) 1281HttpResponseMessage responseMessage = await _sendRequestTask.ConfigureAwait(false);

System\Net\HttpWebResponse.cs (3)

24private HttpResponseMessage _httpResponseMessage = null!; 58internal HttpWebResponse(HttpResponseMessage _message, Uri requestUri, CookieContainer? cookieContainer) 369var httpResponseMessage = _httpResponseMessage;

System\ServiceModel\Channels\HttpChannelFactory.cs (1)

977private HttpResponseMessage _httpResponseMessage;

System\ServiceModel\Channels\HttpChannelHelpers.cs (2)

103public static HttpResponseMessage ProcessGetResponseWebException(HttpRequestException requestException, HttpRequestMessage request, HttpAbortReason abortReason) 163internal static Exception CreateUnexpectedResponseException(HttpResponseMessage response)

System\ServiceModel\Channels\HttpResponseMessageExtensionMethods.cs (3)

23internal static bool CreateContentIfNull(this HttpResponseMessage httpResponseMessage) 36internal static void MergeWebHeaderCollection(this HttpResponseMessage responseMessage, WebHeaderCollection headersToMerge) 42internal static WebHeaderCollection ToWebHeaderCollection(this HttpResponseMessage httpResponse)

System\ServiceModel\Channels\HttpResponseMessageHelper.cs (2)

23private readonly HttpResponseMessage _httpResponseMessage; 27public HttpResponseMessageHelper(HttpResponseMessage httpResponseMessage, HttpChannelFactory<IRequestChannel> factory)

System\ServiceModel\Channels\HttpResponseMessageProperty.cs (4)

32internal HttpResponseMessageProperty(HttpResponseMessage httpResponseMessage) 114public HttpResponseMessage HttpResponseMessage 230public HttpResponseMessageBackedProperty(HttpResponseMessage httpResponseMessage) 237public HttpResponseMessage HttpResponseMessage { get; private set; }

Program.cs (1)

21var response = await client.GetAsync("/api/weatherforecast");