RequestAborted

DefaultHttpContext.cs (1)

184public override CancellationToken RequestAborted

Timeouts\RequestTimeoutsMiddleware.cs (2)

106context.RequestAborted = linkedCts.Token; 132context.RequestAborted = originalToken;

RequestDelegateGenerator\RequestDelegateCreationTests.SpecialTypes.cs (1)

59httpContext.RequestAborted = cts.Token;

Formatters\SystemTextJsonOutputFormatterTest.cs (1)

126actionContext.HttpContext.RequestAborted = cts.Token;

Infrastructure\JsonResultExecutorTestBase.cs (4)

368context.HttpContext.RequestAborted = cts.Token; 399context.HttpContext.RequestAborted = cts.Token; 433context.HttpContext.RequestAborted = cts.Token; 453context.HttpContext.RequestAborted = cts.Token;

XmlDataContractSerializerOutputFormatterTest.cs (1)

734outputFormatterContext.HttpContext.RequestAborted = cts.Token;

XmlSerializerOutputFormatterTest.cs (1)

516outputFormatterContext.HttpContext.RequestAborted = cts.Token;

NewtonsoftJsonOutputFormatterTest.cs (3)

444actionContext.HttpContext.RequestAborted = cts.Token; 489actionContext.HttpContext.RequestAborted = cts.Token; 523actionContext.HttpContext.RequestAborted = cts.Token;

NewtonsoftJsonResultExecutorTest.cs (1)

39context.HttpContext.RequestAborted = cts.Token;

src\Mvc\Mvc.Core\test\Infrastructure\JsonResultExecutorTestBase.cs (4)

368context.HttpContext.RequestAborted = cts.Token; 399context.HttpContext.RequestAborted = cts.Token; 433context.HttpContext.RequestAborted = cts.Token; 453context.HttpContext.RequestAborted = cts.Token;

SessionTests.cs (1)

1049context.RequestAborted = token;

Startup.cs (1)

26await Echo(webSocket, context.RequestAborted);

StartupWithWebSocket.cs (2)

32await ws.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello")), System.Net.WebSockets.WebSocketMessageType.Text, true, context.RequestAborted); 33await ws.CloseAsync(System.Net.WebSockets.WebSocketCloseStatus.NormalClosure, "done", context.RequestAborted);

ClientDisconnectTests.cs (3)

33ctx.RequestAborted.Register(() => requestAborted.SetResult(true)); 74await ctx.Response.Body.WriteAsync(data, ctx.RequestAborted); 329ctx.RequestAborted.Register(() => requestAborted.SetResult(true));

ResponseAbortTests.cs (3)

133tokenAborted = ctx.RequestAborted.IsCancellationRequested; 152var token = ctx.RequestAborted; 158Assert.True(ctx.RequestAborted.WaitHandle.WaitOne(10000));

ConnectionLimitTests.cs (1)

64while (!context.RequestAborted.IsCancellationRequested)

Http2\Http2ConnectionTests.cs (4)

3199context.RequestAborted.Register(() => 3319context.RequestAborted.Register(() => 4222context.RequestAborted.Register(() => 4326context.RequestAborted.Register(() =>

Http2\Http2StreamTests.cs (8)

3181context.RequestAborted.Register(() => 3214context.RequestAborted.Register(() => 3336context.RequestAborted.Register(() => 3376context.RequestAborted.Register(() => 5460Assert.False(context.RequestAborted.CanBeCanceled); 5542Assert.False(context.RequestAborted.CanBeCanceled); 5624Assert.False(context.RequestAborted.CanBeCanceled); 5708Assert.False(context.RequestAborted.CanBeCanceled);

Http2\Http2TestBase.cs (3)

272context.RequestAborted.Register(() => 295context.RequestAborted.Register(() => 315context.RequestAborted.Register(() =>

Http3\Http3StreamTests.cs (4)

1723Assert.False(context.RequestAborted.CanBeCanceled); 1784Assert.False(context.RequestAborted.CanBeCanceled); 1846Assert.False(context.RequestAborted.CanBeCanceled); 1911Assert.False(context.RequestAborted.CanBeCanceled);

HttpsTests.cs (1)

234var ct = httpContext.RequestAborted;

KeepAliveTimeoutTests.cs (1)

260var ct = httpContext.RequestAborted;

ResponseTests.cs (1)

1220httpContext.RequestAborted.Register(() =>

UpgradeTests.cs (2)

136while (!context.RequestAborted.IsCancellationRequested) 316while (!context.RequestAborted.IsCancellationRequested)

src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (1)

155context.RequestAborted.WaitHandle.WaitOne();

Http3\Http3RequestTests.cs (8)

460context.RequestAborted.Register(() => 542context.RequestAborted.Register(() => cancelledTcs.SetResult()); 660context.RequestAborted.Register(() => cancelledTcs.SetResult()); 976context.RequestAborted.Register(() => 1180context.RequestAborted.Register(() => 1294context.RequestAborted.Register(() => 2001context.RequestAborted.Register(() => requestAbortedTcs.SetResult()); 2117context.RequestAborted.Register(() => requestAbortedTcs.SetResult());

HttpClientHttp2InteropTests.cs (3)

914context.RequestAborted.Register(() => serverResult.SetResult()); 955context.RequestAborted.Register(() => serverResult.SetResult()); 995context.RequestAborted.Register(() => serverResult.SetResult());

CookieAuthenticationHandler.cs (6)

172ticket = await Options.SessionStore.RetrieveAsync(claim.Value, Context, Context.RequestAborted); 187await Options.SessionStore.RemoveAsync(_sessionKey!, Context, Context.RequestAborted); 264await Options.SessionStore.RenewAsync(_sessionKey, ticket, Context, Context.RequestAborted); 342await Options.SessionStore.RenewAsync(_sessionKey, ticket, Context, Context.RequestAborted); 346_sessionKey = await Options.SessionStore.StoreAsync(ticket, Context, Context.RequestAborted); 392await Options.SessionStore.RemoveAsync(_sessionKey, Context, Context.RequestAborted);

FacebookHandler.cs (2)

52var response = await Backchannel.GetAsync(endpoint, Context.RequestAborted); 58using (var payload = JsonDocument.Parse(await response.Content.ReadAsStringAsync(Context.RequestAborted)))

GoogleHandler.cs (2)

50var response = await Backchannel.SendAsync(request, Context.RequestAborted); 56using (var payload = JsonDocument.Parse(await response.Content.ReadAsStringAsync(Context.RequestAborted)))

JwtBearerHandler.cs (1)

253var configuration = await Options.ConfigurationManager.GetConfigurationAsync(Context.RequestAborted);

MicrosoftAccountHandler.cs (2)

46var response = await Backchannel.SendAsync(request, Context.RequestAborted); 52using (var payload = JsonDocument.Parse(await response.Content.ReadAsStringAsync(Context.RequestAborted)))

OAuthHandler.cs (2)

222var response = await Backchannel.SendAsync(requestMessage, Context.RequestAborted); 223var body = await response.Content.ReadAsStringAsync(Context.RequestAborted);

OpenIdConnectHandler.cs (11)

TwitterHandler.cs (5)

266return await Backchannel.SendAsync(request, Context.RequestAborted); 275var responseText = await response.Content.ReadAsStringAsync(Context.RequestAborted); 307var responseText = await response.Content.ReadAsStringAsync(Context.RequestAborted); 331var responseText = await response.Content.ReadAsStringAsync(Context.RequestAborted); 370var errorContentStream = await response.Content.ReadAsStreamAsync(Context.RequestAborted);

WsFederationHandler.cs (4)

89_configuration = await Options.ConfigurationManager.GetConfigurationAsync(Context.RequestAborted); 160var form = await Request.ReadFormAsync(Context.RequestAborted); 386_configuration = await Options.ConfigurationManager.GetConfigurationAsync(Context.RequestAborted); 422_configuration = await Options.ConfigurationManager.GetConfigurationAsync(Context.RequestAborted);

DeveloperExceptionPage\DeveloperExceptionPageMiddlewareImpl.cs (1)

120if ((ex is OperationCanceledException || ex is IOException) && context.RequestAborted.IsCancellationRequested)

ExceptionHandler\ExceptionHandlerMiddlewareImpl.cs (2)

117if ((edi.SourceException is OperationCanceledException || edi.SourceException is IOException) && context.RequestAborted.IsCancellationRequested) 175handled = await exceptionHandler.TryHandleAsync(context, edi.SourceException, context.RequestAborted);

HealthCheckMiddleware.cs (1)

46var result = await _healthCheckService.CheckHealthAsync(_healthCheckOptions.Predicate, httpContext.RequestAborted);

Internal\JsonTranscodingServerCallContext.cs (1)

170protected override CancellationToken CancellationTokenCore => HttpContext.RequestAborted;

Timeouts\RequestTimeoutsMiddleware.cs (2)

89if (context.RequestAborted.IsCancellationRequested) 98var originalToken = context.RequestAborted;

Internal\HttpConnectionContext.cs (2)

424TransportTask = transport.ProcessRequestAsync(context, context.RequestAborted); 484var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(Cancellation.Token, nonClonedContext.RequestAborted, timeoutSource.Token);

Internal\Transports\LongPollingServerTransport.cs (1)

75if (context.RequestAborted.IsCancellationRequested)

HttpResponseJsonExtensions.cs (5)

96return WriteAsJsonAsyncSlow(response.BodyWriter, value, options, response.HttpContext.RequestAborted); 127return WriteAsJsonAsyncSlow(response, value, jsonTypeInfo, response.HttpContext.RequestAborted); 169return WriteAsJsonAsyncSlow(response, value, jsonTypeInfo, response.HttpContext.RequestAborted); 276response.HttpContext.RequestAborted); 326return WriteAsJsonAsyncSlow(response.BodyWriter, value, type, context, response.HttpContext.RequestAborted);

RequestDelegateFactory.cs (1)

94private static readonly MemberExpression RequestAbortedExpr = Expression.Property(HttpContextExpr, typeof(HttpContext).GetProperty(nameof(HttpContext.RequestAborted))!);

SendFileResponseExtensions.cs (2)

93var localCancel = useRequestAborted ? response.HttpContext.RequestAborted : cancellationToken; 115var localCancel = useRequestAborted ? response.HttpContext.RequestAborted : cancellationToken;

RequestDelegateGenerator\RequestDelegateCreationTests.cs (2)

284Assert.False(httpContext.RequestAborted.IsCancellationRequested); 315Assert.False(httpContext.RequestAborted.IsCancellationRequested);

RequestDelegateGenerator\RequestDelegateCreationTests.Forms.cs (3)

938Assert.False(httpContext.RequestAborted.IsCancellationRequested); 970Assert.False(httpContext.RequestAborted.IsCancellationRequested); 1009Assert.False(httpContext.RequestAborted.IsCancellationRequested);

RequestDelegateGenerator\RequestDelegateCreationTests.JsonBody.cs (1)

482Assert.False(httpContext.RequestAborted.IsCancellationRequested);

RequestDelegateGenerator\RequestDelegateCreationTests.Logging.cs (13)

RequestDelegateGenerator\RequestDelegateCreationTests.QueryParameters.cs (1)

77Assert.False(httpContext.RequestAborted.IsCancellationRequested);

RequestDelegateGenerator\RequestDelegateCreationTests.SpecialTypes.cs (1)

63Assert.Equal(httpContext.RequestAborted, httpContext.Items["arg"]);

RequestTimeoutsMiddlewareBenchmark.cs (1)

46context.RequestAborted.ThrowIfCancellationRequested();

src\Shared\ResultsHelpers\FileResultHelper.cs (4)

39await StreamCopyOperation.CopyToAsync(fileStream, outputStream, count: null, bufferSize: 64 * 1024, cancel: context.RequestAborted); 44await StreamCopyOperation.CopyToAsync(fileStream, outputStream, rangeLength, BufferSize, context.RequestAborted); 64await outputStream.WriteAsync(buffer, context.RequestAborted); 78await outputStream.WriteAsync(buffer.Slice(from, length), context.RequestAborted);

Timeouts\RequestTimeoutsMiddlewareTests.cs (3)

266throw new OperationCanceledException(context.RequestAborted); 331Assert.Equal(ctsLinker.ReplacedToken, context.RequestAborted); 335Assert.Equal(originalCancellationToken, context.RequestAborted);

AspNetRoleManager.cs (1)

34_cancel = contextAccessor?.HttpContext?.RequestAborted ?? CancellationToken.None;

AspNetUserManager.cs (1)

42_cancel = services?.GetService<IHttpContextAccessor>()?.HttpContext?.RequestAborted ?? CancellationToken.None;

Areas\Identity\Pages\V4\Account\Manage\ExternalLogins.cshtml.cs (1)

100passwordHash = await userPasswordStore.GetPasswordHashAsync(user, HttpContext.RequestAborted);

Areas\Identity\Pages\V5\Account\Manage\ExternalLogins.cshtml.cs (1)

100passwordHash = await userPasswordStore.GetPasswordHashAsync(user, HttpContext.RequestAborted);

Formatters\SystemTextJsonOutputFormatter.cs (3)

94await JsonSerializer.SerializeAsync(responseWriter, context.Object, jsonTypeInfo, httpContext.RequestAborted); 98await JsonSerializer.SerializeAsync(responseWriter, context.Object, SerializerOptions, httpContext.RequestAborted); 101catch (OperationCanceledException) when (context.HttpContext.RequestAborted.IsCancellationRequested) { }

Infrastructure\SystemTextJsonResultExecutor.cs (5)

69await JsonSerializer.SerializeAsync(responseWriter, value, objectType, jsonSerializerOptions, context.HttpContext.RequestAborted); 71catch (OperationCanceledException) when (context.HttpContext.RequestAborted.IsCancellationRequested) { } 82await JsonSerializer.SerializeAsync(transcodingStream, value, objectType, jsonSerializerOptions, context.HttpContext.RequestAborted); 83await transcodingStream.FlushAsync(context.HttpContext.RequestAborted); 85catch (OperationCanceledException) when (context.HttpContext.RequestAborted.IsCancellationRequested)

ModelBinding\Binders\CancellationTokenModelBinder.cs (1)

24var model = (object)bindingContext.HttpContext.RequestAborted;

src\Shared\ResultsHelpers\FileResultHelper.cs (4)

39await StreamCopyOperation.CopyToAsync(fileStream, outputStream, count: null, bufferSize: 64 * 1024, cancel: context.RequestAborted); 44await StreamCopyOperation.CopyToAsync(fileStream, outputStream, rangeLength, BufferSize, context.RequestAborted); 64await outputStream.WriteAsync(buffer, context.RequestAborted); 78await outputStream.WriteAsync(buffer.Slice(from, length), context.RequestAborted);

ModelBinding\Binders\CancellationTokenModelBinderTests.cs (1)

23Assert.Equal(bindingContext.HttpContext.RequestAborted, bindingContext.Result.Model);

XmlDataContractSerializerOutputFormatter.cs (2)

234value = await reader(value, context.HttpContext.RequestAborted); 236if (context.HttpContext.RequestAborted.IsCancellationRequested)

XmlSerializerOutputFormatter.cs (2)

212value = await reader(value, context.HttpContext.RequestAborted); 214if (context.HttpContext.RequestAborted.IsCancellationRequested)

BindingSourceMetadataProviderIntegrationTest.cs (1)

43var token = testContext.HttpContext.RequestAborted;

NewtonsoftJsonOutputFormatter.cs (3)

159value = await reader(value, context.HttpContext.RequestAborted); 161catch (OperationCanceledException) when (context.HttpContext.RequestAborted.IsCancellationRequested) { } 163if (context.HttpContext.RequestAborted.IsCancellationRequested)

NewtonsoftJsonResultExecutor.cs (3)

110value = await reader(value, context.HttpContext.RequestAborted); 112catch (OperationCanceledException) when (context.HttpContext.RequestAborted.IsCancellationRequested) { } 113if (context.HttpContext.RequestAborted.IsCancellationRequested)

Extensions\OpenApiEndpointRouteBuilderExtensions.cs (3)

46var document = await documentService.GetOpenApiDocumentAsync(context.RequestServices, context.RequestAborted); 62await context.Response.BodyWriter.WriteAsync(output.ToArray(), context.RequestAborted); 63await context.Response.BodyWriter.FlushAsync(context.RequestAborted);

OutputCacheMiddleware.cs (2)

103await policy.CacheRequestAsync(context, httpContext.RequestAborted); 170await policy.ServeResponseAsync(context, httpContext.RequestAborted);

RateLimitingMiddleware.cs (3)

146await thisRequestOnRejected(new OnRejectedContext() { HttpContext = context, Lease = leaseContext.Lease! }, context.RequestAborted); 159var waitTask = CombinedWaitAsync(context, context.RequestAborted); 237if (ex is OperationCanceledException && context.RequestAborted.IsCancellationRequested)

RequestDecompressionMiddlewareTests.cs (6)

228await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 299await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 375await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 474await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 558await context.Request.Body.CopyToAsync(ms, context.RequestAborted); 712await context.Request.Body.CopyToAsync(ms, context.RequestAborted);

ResponseCachingMiddleware.cs (1)

189await body.CopyToAsync(response.BodyWriter, context.HttpContext.RequestAborted);

RequestTests.cs (2)

512var ct = httpContext.RequestAborted; 572result.SetResult(httpContext.RequestAborted.IsCancellationRequested);

ResponseSendFileTests.cs (4)

487httpContext.RequestAborted.Register(() => cancellationReceived.SetResult()); 540httpContext.RequestAborted.Register(() => cancellationReceived.SetResult()); 587httpContext.RequestAborted.Register(() => cancellationReceived.SetResult()); 639httpContext.RequestAborted.Register(() => cancellationReceived.SetResult());

ServerTests.cs (2)

284var ct = httpContext.RequestAborted; 317CancellationToken ct = httpContext.RequestAborted;

SpaProxyMiddleware.cs (1)

56if (!await _spaProxyLaunchManager.IsSpaProxyRunning(context.RequestAborted))

Proxying\SpaProxy.cs (1)

63context.RequestAborted,

StaticAssetsInvoker.cs (1)

280public CancellationToken CancellationToken => _context.RequestAborted;

StaticFileContext.cs (2)

356await _context.Response.SendFileAsync(_fileInfo, 0, _length, _context.RequestAborted); 389await _context.Response.SendFileAsync(_fileInfo, start, length, _context.RequestAborted);

StaticFileMiddlewareTests.cs (1)

256Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");

WebSocketClient.cs (1)

146await _httpContext.Response.Body.FlushAsync(_httpContext.RequestAborted); // Send headers to the client

HttpContextBuilderTests.cs (4)

30Assert.True(context.RequestAborted.CanBeCanceled); 225Assert.True(c.RequestAborted.WaitHandle.WaitOne(TimeSpan.FromSeconds(10))); 226c.RequestAborted.ThrowIfCancellationRequested(); 336context.RequestAborted.Register(() => requestAborted.SetResult());

RequestLifetimeTests.cs (1)

21httpContext.RequestAborted.Register(() => requestAborted.SetResult());

ResponseResetTests.cs (1)

72httpContext.RequestAborted.Register(() => requestAborted.SetResult());

TestClientTests.cs (2)

838await sem.WaitAsync(ctx.RequestAborted); 867await Task.Delay(TimeSpan.FromSeconds(30), ctx.RequestAborted);

Startup.cs (2)

251var metadata = await options.ConfigurationManager.GetConfigurationAsync(context.RequestAborted); 261var tokenResponse = await options.Backchannel.PostAsync(metadata.TokenEndpoint, content, context.RequestAborted);

Startup.cs (2)

24var decompressedBody = await reader.ReadToEndAsync(context.RequestAborted); 26await context.Response.WriteAsync(decompressedBody, context.RequestAborted);

Startup.cs (3)

141var response = await context.Backchannel.SendAsync(request, context.HttpContext.RequestAborted); 202var response = await context.Backchannel.SendAsync(request, context.HttpContext.RequestAborted); 330var refreshResponse = await options.Backchannel.PostAsync(options.TokenEndpoint, content, context.RequestAborted);

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (4)

603var token = context.RequestAborted; 641context.RequestAborted.Register(() => 646beforeAbort = context.RequestAborted; 653afterAbort = context.RequestAborted;

src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (13)