1630 references to Token
AnalyzerRunner (1)
Program.cs (1)
50var cancellationToken = cts.Token;
ApiExplorerWebSite (2)
ActionDescriptorChangeProvider.cs (2)
23return new CancellationChangeToken(changeTokenSource.Token); 26return new CancellationChangeToken(ChangeToken.TokenSource.Token);
aspire (2)
Backchannel\ExtensionBackchannel.cs (1)
75var cancellationTask = Task.Delay(Timeout.Infinite, linkedCts.Token);
Commands\BaseCommand.cs (1)
33await updateNotifier.NotifyIfUpdateAvailableAsync(currentDirectory, cancellationToken: cts.Token);
Aspire.Cli.Tests (2)
Commands\RunCommandTests.cs (2)
224var pendingRun = result.InvokeAsync(cts.Token); 278var pendingRun = result.InvokeAsync(cts.Token);
Aspire.Components.Common.TestUtilities (1)
ActivityNotifier.cs (1)
22await foreach (var activity in WaitAsync(cts.Token))
Aspire.Dashboard (40)
Components\Controls\ApplicationName.razor.cs (1)
34await DashboardClient.WhenConnected.WaitAsync(_disposalCts.Token);
Components\Controls\Chart\ChartBase.cs (1)
71CancellationToken = _cts.Token;
Components\Controls\SpanDetails.razor.cs (1)
139_cts.Token).ConfigureAwait(false);
Components\Dialogs\ExemplarsDialog.razor.cs (1)
46_cts.Token).ConfigureAwait(false);
Components\Interactions\InteractionsProvider.cs (10)
99await waitForInteractionAvailableTask.WaitAsync(_cts.Token).ConfigureAwait(false); 103await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 149await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 199await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 217await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 246await currentDialogReference.Result.WaitAsync(_cts.Token); 248await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 271var interactions = DashboardClient.SubscribeInteractionsAsync(_cts.Token); 274await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 388await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false);
Components\Pages\ConsoleLogs.razor.cs (2)
39public CancellationToken CancellationToken => _cts.Token; 131_resourceSubscriptionToken = _resourceSubscriptionCts.Token;
Components\Pages\Resources.razor.cs (2)
240var (snapshot, subscription) = await DashboardClient.SubscribeResourcesAsync(_watchTaskCancellationTokenSource.Token); 255await foreach (var changes in subscription.WithCancellation(_watchTaskCancellationTokenSource.Token).ConfigureAwait(false))
Model\DashboardCommandExecutor.cs (1)
134closeToastCts.Token.Register(() =>
Model\MetricsHelpers.cs (2)
63await Task.Delay(TimeSpan.FromSeconds(0.5), cts.Token).ConfigureAwait(false); 66}, cts.Token);
Model\ResourceOutgoingPeerResolver.cs (2)
30var (snapshot, subscription) = await resourceService.SubscribeResourcesAsync(_watchContainersTokenSource.Token).ConfigureAwait(false); 43await foreach (var changes in subscription.WithCancellation(_watchContainersTokenSource.Token).ConfigureAwait(false))
ServiceClient\DashboardClient.cs (15)
89_clientCancellationToken = _cts.Token; 435using var call = _client!.WatchInteractions(headers: _headers, cancellationToken: cts.Token); 450await foreach (var update in _incomingInteractionChannel.Reader.ReadAllAsync(cts.Token).ConfigureAwait(false)) 465}, cts.Token); 470await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: cts.Token).ConfigureAwait(false)) 560await _initialDataReceivedTcs.Task.WaitAsync(cts.Token).ConfigureAwait(false); 574Subscription: StreamUpdatesAsync(cts.Token)); 617return StreamUpdatesAsync(_pendingInteractionCollection.ToList(), cts.Token); 652cancellationToken: combinedTokens.Token); 663await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: combinedTokens.Token).ConfigureAwait(false)) 673}, combinedTokens.Token); 675await foreach (var batch in channel.GetBatchesAsync(TimeSpan.FromMilliseconds(100), combinedTokens.Token).ConfigureAwait(false)) 699cancellationToken: combinedTokens.Token); 701await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: combinedTokens.Token).ConfigureAwait(false)) 735var response = await _client!.ExecuteResourceCommandAsync(request, headers: _headers, cancellationToken: combinedTokens.Token);
Utils\CallbackThrottler.cs (1)
22_cancellationToken = _cts.Token;
Utils\CancellationSeries.cs (1)
38var nextToken = nextCts.Token;
Aspire.Dashboard.Tests (6)
ChannelExtensionsTests.cs (4)
27await foreach (var batch in channel.GetBatchesAsync(cancellationToken: cts.Token)) 51await foreach (var batch in channel.GetBatchesAsync().WithCancellation(cts.Token)) 78await foreach (var batch in channel.GetBatchesAsync(minReadInterval).WithCancellation(cts.Token)) 122await foreach (var batch in channel.GetBatchesAsync(minReadInterval).WithCancellation(cts.Token))
Model\DashboardClientTests.cs (2)
57await foreach (var item in subscription.WithCancellation(cts.Token)) 168await foreach (var item in subscription.WithCancellation(cts.Token))
Aspire.EndToEnd.Tests (3)
tests\Shared\TemplatesTesting\AspireProject.cs (2)
359await WaitForDashboardToBeAvailableAsync(dashboardUrlToUse, _testOutput, cts.Token).ConfigureAwait(false); 384}, cts.Token).ConfigureAwait(false);
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
Aspire.Hosting (45)
ApplicationModel\ResourceLoggerService.cs (1)
421using var _ = _logStreamCts.Token.Register(() => channel.Writer.TryComplete());
ApplicationModel\ResourceNotificationService.cs (4)
127using var watchCts = CancellationTokenSource.CreateLinkedTokenSource(_disposing.Token, cancellationToken); 128var watchToken = watchCts.Token; 419using var watchCts = CancellationTokenSource.CreateLinkedTokenSource(_disposing.Token, cancellationToken); 420var watchToken = watchCts.Token;
Backchannel\BackchannelLoggerProvider.cs (1)
47_backgroundChannelRegistrationCts.Token);
Dashboard\DashboardLifecycleHook.cs (1)
72_dashboardLogsTask = WatchDashboardLogsAsync(_dashboardLogsCts.Token);
Dashboard\DashboardService.cs (8)
71await foreach (var interaction in updates.WithCancellation(cts.Token).ConfigureAwait(false)) 146await responseStream.WriteAsync(change, cts.Token).ConfigureAwait(false); 157}, cts.Token); 162await foreach (var request in requestStream.ReadAllAsync(cts.Token).ConfigureAwait(false)) 164await serviceData.SendInteractionRequestAsync(request, cts.Token).ConfigureAwait(false); 341await execute(cts.Token).ConfigureAwait(false); 343catch (OperationCanceledException) when (cts.Token.IsCancellationRequested) 347catch (IOException) when (cts.Token.IsCancellationRequested)
Dashboard\DashboardServiceData.cs (6)
33_resourcePublisher = new ResourcePublisher(_cts.Token); 36var cancellationToken = _cts.Token; 127using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 129await foreach (var item in sequence.WithCancellation(linked.Token).ConfigureAwait(false)) 144using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 146await foreach (var item in sequence.WithCancellation(linked.Token).ConfigureAwait(false))
Dashboard\ResourcePublisher.cs (1)
64await foreach (var batch in channel.GetBatchesAsync(cancellationToken: linked.Token).ConfigureAwait(false))
Dcp\DcpExecutor.cs (8)
216await StopAsync(disposeCts.Token).ConfigureAwait(false); 223var cancellationToken = _shutdownCancellation.Token; 377await _executorEvents.PublishAsync(new OnResourceChangedContext(_shutdownCancellation.Token, resourceType, appModelResource, resource.Metadata.Name, status, s => snapshotFactory(resource, s))).ConfigureAwait(false); 522await foreach (var batch in enumerable.WithCancellation(cancellation.Token).ConfigureAwait(false)) 540cancellation.Token); 594await _executorEvents.PublishAsync(new OnResourceChangedContext(_shutdownCancellation.Token, resourceKind, appModelResource, resourceName, status, s => 980await _executorEvents.PublishAsync(new OnResourceChangedContext(_shutdownCancellation.Token, resourceType, resource, er.DcpResourceName, new ResourceStatus(null, null, null), s => _snapshotBuilder.ToSnapshot((Executable)er.DcpResource, s))).ConfigureAwait(false); 1259await _executorEvents.PublishAsync(new OnResourceChangedContext(_shutdownCancellation.Token, KnownResourceTypes.Container, cr.ModelResource, cr.DcpResourceName, new ResourceStatus(null, null, null), s => _snapshotBuilder.ToSnapshot((Container)cr.DcpResource, s))).ConfigureAwait(false);
Dcp\DcpHost.cs (4)
99await Task.Delay(TimeSpan.FromSeconds(2), timeoutCancellation.Token).ConfigureAwait(false); 100dcpInfo = await _dependencyCheckService.GetDcpInfoAsync(force: true, cancellationToken: timeoutCancellation.Token).ConfigureAwait(false); 248var acceptedSocket = await socket.AcceptAsync(_shutdownCts.Token).ConfigureAwait(false); 249outputLoggers.Add(Task.Run(() => LogSocketOutputAsync(acceptedSocket, _shutdownCts.Token)));
Dcp\DcpKubernetesClient.cs (3)
54cancellationToken = cts.Token; 94cancellationToken = cts.Token; 120cancellationToken = cts.Token;
Health\ResourceHealthCheckService.cs (1)
322public CancellationToken CancellationToken => _cts.Token;
Orchestrator\ApplicationOrchestrator.cs (2)
79var waitForDependenciesTask = _notificationService.WaitForDependenciesAsync(@event.Resource, cts.Token); 91cts.Token);
Publishing\PublishingActivityProgressReporter.cs (1)
367_interactionServiceSubscriber = Task.Run(() => SubscribeToInteractionsAsync(_cancellationTokenSource.Token));
Utils\PeriodicRestartAsyncEnumerable.cs (4)
29var enumerable = await enumerableFactory(lastValue, cts.Token).ConfigureAwait(false); 30var enumerator = enumerable.GetAsyncEnumerator(cts.Token); 85var enumerable = await enumerableFactory(lastValue, cts.Token).ConfigureAwait(false); 86var enumerator = enumerable.GetAsyncEnumerator(cts.Token);
Aspire.Hosting.Azure.Tests (64)
AzureAIFoundryExtensionsTests.cs (2)
86await app.StartAsync(cts.Token); 91await rns.WaitForResourceAsync(resource.Name, [KnownResourceStates.FailedToStart, KnownResourceStates.Running], cts.Token);
AzureBicepProvisionerTests.cs (3)
61await app.StartAsync(cts.Token); 64await foreach (var resourceEvent in rns.WatchAsync(cts.Token).WithCancellation(cts.Token))
AzureCosmosDBEmulatorFunctionalTests.cs (19)
45var pendingStart = app.StartAsync(cts.Token); 47await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 53await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 91await app.StartAsync(cts.Token); 93await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 128}, cts.Token); 170await app.StartAsync(cts.Token); 173await rns.WaitForResourceHealthyAsync(cosmos1.Resource.Name, cts.Token); 200}, cts.Token); 218await app.StartAsync(cts.Token); 221await rns.WaitForResourceHealthyAsync(cosmos2.Resource.Name, cts.Token); 254}, cts.Token); 287await app.StartAsync(cts.Token); 290await rns.WaitForResourceHealthyAsync(cosmos.Resource.Name, cts.Token); 298await host.StartAsync(cts.Token); 303var result1 = await database.ReadAsync(cancellationToken: cts.Token); 306var result2 = await container.ReadContainerAsync(cancellationToken: cts.Token);
AzureEventHubsExtensionsTests.cs (7)
44var pendingStart = app.StartAsync(cts.Token); 46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 47await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 51await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 76await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token); 128await app.ResourceNotifications.WaitForResourceHealthyAsync(eventHubns.Resource.Name, cts.Token);
AzureServiceBusExtensionsTests.cs (13)
93var pendingStart = app.StartAsync(cts.Token); 95await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 97await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 101await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 103await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 136await rns.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 137await rns.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 142await sender.SendMessageAsync(new ServiceBusMessage("Hello, World!"), cts.Token); 145var message = await receiver.ReceiveMessageAsync(cancellationToken: cts.Token); 813await app.ResourceNotifications.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 814await app.ResourceNotifications.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 822await sender.SendMessageAsync(new ServiceBusMessage("Hello, World!"), cts.Token); 825var message = await receiver.ReceiveMessageAsync(cancellationToken: cts.Token);
AzureSignalREmulatorFunctionalTest.cs (6)
59var pendingStart = app.StartAsync(cts.Token); 60await app.ResourceNotifications.WaitForResourceAsync(signalR.Resource.Name, KnownResourceStates.Running, cts.Token); 61await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 65await app.ResourceNotifications.WaitForResourceHealthyAsync(signalR.Resource.Name, cts.Token); 67await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 124}, cts.Token);
AzureStorageEmulatorFunctionalTests.cs (13)
44var pendingStart = app.StartAsync(cts.Token); 48await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 50await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 54await rns.WaitForResourceHealthyAsync(blobs.Resource.Name, cts.Token); 55await rns.WaitForResourceHealthyAsync(queues.Resource.Name, cts.Token); 56await rns.WaitForResourceHealthyAsync(tables.Resource.Name, cts.Token); 58await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 90var pendingStart = app.StartAsync(cts.Token); 94await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 96await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 100await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cts.Token); 102await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 159await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cancellationToken: cts.Token);
DefaultUserPrincipalProviderTests.cs (1)
76() => provider.GetUserPrincipalAsync(cts.Token));
Aspire.Hosting.Containers.Tests (1)
DockerSocketBindMountTests.cs (1)
44cts.Token);
Aspire.Hosting.Garnet.Tests (7)
GarnetFunctionalTests.cs (7)
39var pendingStart = app.StartAsync(cts.Token); 41await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 43await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 47await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 95}, cts.Token); 176}, cts.Token);
Aspire.Hosting.Kafka.Tests (4)
KafkaFunctionalTests.cs (4)
98}, cts.Token); 104var result = consumer.Consume(cts.Token); 185}, cts.Token); 237var result = consumer.Consume(cts.Token);
Aspire.Hosting.MongoDB.Tests (10)
MongoDbFunctionalTests.cs (10)
51var pendingStart = app.StartAsync(cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 55await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 59await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 61await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 99}, cts.Token); 160}, cts.Token); 214}, cts.Token); 328}, cts.Token); 419}, cts.Token);
Aspire.Hosting.MySql.Tests (68)
MySqlFunctionalTests.cs (68)
48var pendingStart = app.StartAsync(cts.Token); 50await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 52await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 56await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 58await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 62await app.StopAsync(cts.Token); 83await app.StartAsync(cts.Token); 85await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 98await host.StartAsync(cts.Token); 109}, cts.Token); 155await app.StartAsync(cts.Token); 157await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 172await host.StartAsync(cts.Token); 180}, cts.Token); 197}, cts.Token); 203await app.StopAsync(cts.Token); 224await app.StartAsync(cts.Token); 226await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 234[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 241await host.StartAsync(cts.Token); 249}, cts.Token); 261}, cts.Token); 268await app.StopAsync(cts.Token); 329await app.StartAsync(cts.Token); 331await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 337[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 344await host.StartAsync(cts.Token); 352}, cts.Token); 366}, cts.Token); 415await app.StartAsync(cts.Token); 417await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 423[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 430await host.StartAsync(cts.Token); 438}, cts.Token); 452}, cts.Token); 485await app.StartAsync(cts.Token); 487await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 493[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 500await host.StartAsync(cts.Token); 508}, cts.Token); 516}, cts.Token); 523}, cts.Token); 531}, cts.Token); 575await app.StartAsync(cts.Token); 579var mySqlId = await GetContainerIdAsync(rns, "resource", cts.Token); 585mySqlId2 = await GetContainerIdAsync(rns, "resource2", cts.Token); 588var phpMyAdminId = await GetContainerIdAsync(rns, "phpmyadmin", cts.Token);; 590await app.StopAsync(cts.Token).WaitAsync(cts.Token); 646await app.StartAsync(cts.Token); 658await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 675}, cts.Token); 721await app.StartAsync(cts.Token); 733await app.ResourceNotifications.WaitForResourceHealthyAsync(mysql.Resource.Name, cts.Token); 746}, cts.Token); 748await app.StopAsync(cts.Token); 778await app.StartAsync(cts.Token); 794await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 800await conn.OpenAsync(cts.Token); 823await app.StartAsync(cts.Token); 832await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 838await conn.OpenAsync(cts.Token);
Aspire.Hosting.Nats.Tests (5)
NatsFunctionalTests.cs (5)
341var pendingStart = app.StartAsync(cts.Token); 343await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 345await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 349await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 351await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.NodeJs.Tests (4)
NodeAppFixture.cs (2)
45await _app.StartAsync(cts.Token); 47await WaitReadyStateAsync(cts.Token);
NodeFunctionalTests.cs (2)
28var response = await nodeClient.GetStringAsync("/", cts.Token); 41var response = await npmClient.GetStringAsync("/", cts.Token);
Aspire.Hosting.Oracle.Tests (23)
OracleFunctionalTests.cs (23)
45await app.StartAsync(cts.Token); 47await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 60await dbContext.Database.EnsureCreatedAsync(cts.Token); 63await dbContext.SaveChangesAsync(cts.Token); 65var cars = await dbContext.Cars.ToListAsync(cts.Token); 128await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 145await dbContext.Database.EnsureCreatedAsync(cts.Token); 149await dbContext.SaveChangesAsync(cts.Token); 158}, cts.Token); 188await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 204var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 214}, cts.Token); 297await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 317}, cts.Token); 319var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 394await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 414}, cts.Token); 416var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 459var pendingStart = app.StartAsync(cts.Token); 461await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 463await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 467await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 469await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.PostgreSQL.Tests (31)
PostgresFunctionalTests.cs (31)
129await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token); 141}, cts.Token); 234await app.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 266}, cts.Token); 296await app.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 325}, cts.Token); 408await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 416}, cts.Token); 430}, cts.Token); 494await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 502}, cts.Token); 516}, cts.Token); 561await app.StartAsync(cts.Token); 565var postgresId = await GetContainerIdAsync(rns, "resource", cts.Token); 567var pgWebId = await GetContainerIdAsync(rns, "pgweb", cts.Token); 569var pgadminId = await GetContainerIdAsync(rns, "pgadmin", cts.Token); 571await app.StopAsync(cts.Token).WaitAsync(TimeSpan.FromMinutes(1), cts.Token); 608await app.StartAsync(cts.Token); 620await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 626await conn.OpenAsync(cts.Token); 649await app.StartAsync(cts.Token); 661await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 667await conn.OpenAsync(cts.Token); 718await app.StartAsync(cts.Token); 730await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token); 743}, cts.Token); 745await app.StopAsync(cts.Token); 775await app.StartAsync(cts.Token); 791await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 797await conn.OpenAsync(cts.Token);
Aspire.Hosting.Qdrant.Tests (8)
QdrantFunctionalTests.cs (8)
63}, cts.Token); 144}, cts.Token); 191}, cts.Token); 272var pendingStart = app.StartAsync(cts.Token); 274await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 276await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 280await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, (re => re.Snapshot.HealthStatus == HealthStatus.Healthy), cts.Token); 282await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Redis.Tests (16)
RedisFunctionalTests.cs (16)
50var pendingStart = app.StartAsync(cts.Token); 52await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 54await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 58await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 60await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 146await rns.WaitForResourceAsync(redisInsightBuilder.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 151await AcceptRedisInsightEula(client, cts.Token); 153var response = await client.GetAsync("/api/databases", cts.Token); 156var databases = await response.Content.ReadFromJsonAsync<List<RedisInsightDatabaseModel>>(cts.Token); 184var testConnectionResponse = await client.GetAsync($"/api/databases/{db.Id}/connect", cts2.Token); 478await rns.WaitForResourceAsync(redisInsightBuilder1.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 483await AcceptRedisInsightEula(httpClient, cts.Token); 513await rns.WaitForResourceAsync(redisInsightBuilder2.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 518await EnsureRedisInsightEulaAccepted(httpClient, cts.Token); 616await app.ResourceNotifications.WaitForResourceHealthyAsync(redis.Resource.Name, cts.Token); 617await app.ResourceNotifications.WaitForResourceHealthyAsync(redisCommander.Name, cts.Token);
Aspire.Hosting.SqlServer.Tests (32)
SqlServerFunctionalTests.cs (32)
42var pendingStart = app.StartAsync(cts.Token); 44await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 46await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 50await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 52await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 77await app.StartAsync(cts.Token); 106}, cts.Token); 110await dbContext.Database.EnsureCreatedAsync(cts.Token); 112await dbContext.SaveChangesAsync(cts.Token); 113var cars = await dbContext.Cars.ToListAsync(cts.Token); 179await app1.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 217}, cts.Token); 237}, cts.Token); 264await app2.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 290}, cts.Token); 296using var results = await command.ExecuteReaderAsync(cts.Token); 298Assert.True(await results.ReadAsync(cts.Token)); 300Assert.False(await results.ReadAsync(cts.Token)); 364await app.StartAsync(cts.Token); 376await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 394}, cts.Token); 417await app.StartAsync(cts.Token); 427await host.StartAsync(cts.Token); 429await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 443}, cts.Token); 489await app.StartAsync(cts.Token); 501await app.ResourceNotifications.WaitForResourceHealthyAsync(sqlserver.Resource.Name, cts.Token); 515}, cts.Token); 517await app.StopAsync(cts.Token); 547await app.StartAsync(cts.Token); 563await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 569await conn.OpenAsync(cts.Token);
Aspire.Hosting.Testing (13)
DistributedApplicationFactory.cs (13)
49using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposingCts.Token); 51return await _builderTcs.Task.WaitAsync(linkedCts.Token).ConfigureAwait(false); 59using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposingCts.Token); 61return await _appTcs.Task.WaitAsync(linkedCts.Token).ConfigureAwait(false); 72using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _disposingCts.Token); 74await _startedTcs.Task.WaitAsync(linkedCts.Token).ConfigureAwait(false); 427var app = await factory(_args, cts.Token).ConfigureAwait(false); 523await _exitTcs.Task.WaitAsync(shutdownTimeoutCts.Token).ConfigureAwait(false); 536await app.StopAsync().WaitAsync(shutdownTimeoutCts.Token).ConfigureAwait(false); 545await app.DisposeAsync().AsTask().WaitAsync(shutdownTimeoutCts.Token).ConfigureAwait(false); 603await asyncDisposable.DisposeAsync().AsTask().WaitAsync(appFactory._disposingCts.Token).ConfigureAwait(false); 615using var linkedToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, appFactory._disposingCts.Token); 616await innerHost.StartAsync(linkedToken.Token).ConfigureAwait(false);
Aspire.Hosting.Testing.Tests (30)
ResourceLoggerForwarderServiceTests.cs (3)
144ApplicationStarted = _startedCts.Token; 145ApplicationStopping = _stoppingCts.Token; 146ApplicationStopped = _stoppedCts.Token;
TestingBuilderTests.cs (21)
451genericEntryPoint ? DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>([$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token) 452: DistributedApplicationTestingBuilder.CreateAsync(typeof(Projects.TestingAppHost1_AppHost), [$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token)); 459? await DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>([$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token) 460: await DistributedApplicationTestingBuilder.CreateAsync(typeof(Projects.TestingAppHost1_AppHost), [$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token); 465using var app = await builder.BuildAsync().WaitAsync(cts.Token); 470var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app.StartAsync().WaitAsync(cts.Token)); 475await app.StartAsync().WaitAsync(cts.Token); 479await app.DisposeAsync().AsTask().WaitAsync(cts.Token); 494using var builder = await DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>(["--add-unknown-container"], cts.Token).WaitAsync(cts.Token); 496await using var app = await builder.BuildAsync(cts.Token).WaitAsync(cts.Token); 517cts.Token).WaitAsync(cts.Token); 532app = await builder.BuildAsync(cts.Token).WaitAsync(cts.Token); 541await app.DisposeAsync().AsTask().WaitAsync(cts.Token);
TestingFactoryCrashTests.cs (3)
27var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => factory.StartAsync().WaitAsync(cts.Token)); 32await factory.StartAsync().WaitAsync(cts.Token); 35await factory.DisposeAsync().AsTask().WaitAsync(cts.Token);
tests\Aspire.Hosting.Tests\Utils\LoggerNotificationExtensions.cs (3)
84_ = Task.Run(() => WatchNotifications(app, resourceName, predicate, tcs, watchCts), watchCts.Token); 132await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(cancellationTokenSource.Token).ConfigureAwait(false)) 162await foreach (var logEvent in resourceLoggerService.WatchAsync(resourceId).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))
Aspire.Hosting.Tests (116)
Codespaces\CodespacesUrlRewriterTests.cs (6)
33await app.StartAsync(abortToken.Token); 39while (!abortToken.Token.IsCancellationRequested) 51await app.StopAsync(abortToken.Token); 70await app.StartAsync(abortToken.Token); 87abortToken.Token); 99await app.StopAsync(abortToken.Token);
Dashboard\DashboardServiceTests.cs (4)
181var context = TestServerCallContext.Create(cancellationToken: cts.Token); 235var context = TestServerCallContext.Create(cancellationToken: cts.Token); 304var context = TestServerCallContext.Create(cancellationToken: cts.Token); 340var context = TestServerCallContext.Create(cancellationToken: cts.Token);
Dashboard\ResourcePublisherTests.cs (7)
17ResourcePublisher publisher = new(cts.Token); 70ResourcePublisher publisher = new(cts.Token); 91var enumerator1 = subscription1.GetAsyncEnumerator(cts.Token); 92var enumerator2 = subscription2.GetAsyncEnumerator(cts.Token); 117ResourcePublisher publisher = new(cts.Token); 138ResourcePublisher publisher = new(cts.Token); 165await foreach (var item in subscription.WithCancellation(cts.Token).ConfigureAwait(false))
Dcp\DcpExecutorTests.cs (2)
593var watchLogsEnumerator = watchLogs.GetAsyncEnumerator(watchCts.Token); 1228await appExecutor.RunApplicationAsync(tokenSource.Token);
DistributedApplicationTests.cs (4)
65await testProgram.RunAsync(cts.Token); 106await testProgram.RunAsync(cts.Token); 632var token = cts.Token; 1102var token = cts.Token;
Health\ResourceHealthCheckServiceTests.cs (11)
228await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 234await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, abortTokenSource.Token).DefaultTimeout(); 243await app.StopAsync(abortTokenSource.Token).TimeoutAfter(TestConstants.LongTimeoutTimeSpan); 269await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 286await app.StopAsync(abortTokenSource.Token).DefaultTimeout(); 312await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 318await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, abortTokenSource.Token).DefaultTimeout(); 320var firstCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 323var secondCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 326var thirdCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 328await app.StopAsync(abortTokenSource.Token).DefaultTimeout();
InteractionServiceTests.cs (1)
48var resultTask = interactionService.PromptConfirmationAsync("Are you sure?", "Confirmation", cancellationToken: cts.Token);
Publishing\PublishingActivityProgressReporterTests.cs (1)
499var activity = await activityReader.ReadAsync(cts.Token);
Publishing\ResourceContainerImageBuilderTests.cs (2)
29await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 45await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token);
ResourceNotificationTests.cs (6)
69var enumerableTask = GetValuesAsync(cts.Token); 122var enumerableTask = GetValuesAsync(cts.Token); 179var waitTask = notificationService.WaitForResourceAsync("MYreSouRCe1", "sOmeSTAtE", cts.Token); 271var waitTask = notificationService.WaitForResourceAsync("myResource1", "SomeState", cts.Token); 303var waitTask = notificationService.WaitForResourceAsync("myResource1", "SomeState", cts.Token); 450ApplicationStopping = _stoppingCts.Token;
SlimTestProgramTests.cs (3)
30await EnsureServicesAreRunning(testProgram, cts.Token); 55await EnsureServicesAreRunning(testProgram, cts.Token); 74await EnsureServicesAreRunning(testProgram, cts.Token);
TestProgramFixture.cs (2)
35await _app.StartAsync(cts.Token); 37await WaitReadyStateAsync(cts.Token);
Utils\LoggerNotificationExtensions.cs (3)
84_ = Task.Run(() => WatchNotifications(app, resourceName, predicate, tcs, watchCts), watchCts.Token); 132await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(cancellationTokenSource.Token).ConfigureAwait(false)) 162await foreach (var logEvent in resourceLoggerService.WatchAsync(resourceId).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))
Utils\PeriodicRestartAsyncEnumerableTests.cs (2)
23await foreach (var _ in PeriodicRestartAsyncEnumerable.CreateAsync(innerFactory, restartInterval: TimeSpan.FromSeconds(2), cancellationToken: cts.Token).ConfigureAwait(false)) 46await foreach (var _ in PeriodicRestartAsyncEnumerable.CreateAsync(innerFactory, restartInterval: TimeSpan.FromMilliseconds(100), cancellationToken: cts.Token).ConfigureAwait(false))
WaitForTests.cs (48)
30await app.StartAsync(abortCts.Token); 32await app.ResourceNotifications.WaitForResourceAsync(throwingResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 33await app.ResourceNotifications.WaitForResourceAsync(dependingContainerResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 34await app.ResourceNotifications.WaitForResourceAsync(dependingExecutableResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 36await app.StopAsync(abortCts.Token); 104var startTask = app.StartAsync(startupCts.Token); 107await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 135var startTask = app.StartAsync(startupCts.Token); 138await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 168var startTask = app.StartAsync(startupCts.Token); 175await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 212var startTask = app.StartAsync(startupCts.Token); 216await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 223await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token); 323var startTask = app.StartAsync(startupCts.Token); 327await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 334await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token); 357var startTask = app.StartAsync(startupCts.Token); 361await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 368await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 376await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 404var startTask = app.StartAsync(startupCts.Token); 408await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 415await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 423await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 446var startTask = app.StartAsync(startupCts.Token); 453await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 468await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token); 493var startTask = app.StartAsync(startupCts.Token); 500await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token); 515await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 548var startTask = app.StartAsync(startupCts.Token); 555await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token); 571await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 602var startTask = app.StartAsync(startupCts.Token); 609await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 623await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 653var startTask = app.StartAsync(startupCts.Token); 660await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 668await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 676await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 706var startTask = app.StartAsync(startupCts.Token); 713await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 721await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 729await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 755var startTask = app.StartAsync(startupCts.Token); 762await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 770await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token);
WithHttpCommandTests.cs (6)
385await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(watchCts.Token).WithCancellation(watchCts.Token)) 394}, watchCts.Token); 455await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(watchCts.Token).WithCancellation(watchCts.Token)) 464}, watchCts.Token);
WithUrlsTests.cs (8)
339await foreach (var notification in rns.WatchAsync(cts.Token).WithCancellation(cts.Token)) 375await foreach (var notification in rns.WatchAsync(cts.Token).WithCancellation(cts.Token)) 463await foreach (var notification in rns.WatchAsync(cts.Token).WithCancellation(cts.Token)) 584await foreach (var notification in rns.WatchAsync(cts.Token).WithCancellation(cts.Token))
Aspire.Hosting.Valkey.Tests (5)
ValkeyFunctionalTests.cs (5)
218var pendingStart = app.StartAsync(cts.Token); 220await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 222await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 226await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 228await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Yarp.Tests (1)
YarpFunctionalTests.cs (1)
96await app.ResourceNotifications.WaitForResourceHealthyAsync(yarp.Resource.Name, cts.Token);
Aspire.MongoDB.Driver.Tests (1)
ConformanceTests.cs (1)
113service.ListDatabases(source.Token);
Aspire.MongoDB.Driver.v3.Tests (1)
tests\Aspire.MongoDB.Driver.Tests\ConformanceTests.cs (1)
113service.ListDatabases(source.Token);
Aspire.Playground.Tests (4)
ProjectSpecificTests.cs (1)
163return app.WaitForAllTextAsync(logTexts, resourceName, cts.Token);
tests\Aspire.Hosting.Tests\Utils\LoggerNotificationExtensions.cs (3)
84_ = Task.Run(() => WatchNotifications(app, resourceName, predicate, tcs, watchCts), watchCts.Token); 132await foreach (var resourceEvent in app.ResourceNotifications.WatchAsync(cancellationTokenSource.Token).ConfigureAwait(false)) 162await foreach (var logEvent in resourceLoggerService.WatchAsync(resourceId).WithCancellation(cancellationTokenSource.Token).ConfigureAwait(false))
Aspire.Templates.Tests (3)
tests\Shared\TemplatesTesting\AspireProject.cs (2)
359await WaitForDashboardToBeAvailableAsync(dashboardUrlToUse, _testOutput, cts.Token).ConfigureAwait(false); 384}, cts.Token).ConfigureAwait(false);
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
ClientSample (2)
HubSample.cs (2)
78if (!await ConnectAsync(connection, closedTokenSource.Token)) 94if (line == null || closedTokenSource.Token.IsCancellationRequested)
csc (2)
src\Compilers\Shared\BuildServerConnection.cs (2)
300var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 301var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
CustomResources.AppHost (1)
TestResource.cs (1)
56while (await timer.WaitForNextTickAsync(_tokenSource.Token))
dotnet-svcutil-lib (8)
FrameworkFork\System.ServiceModel\Internals\System\Runtime\TaskHelpers.cs (1)
168var completedTask = await Task.WhenAny(task, Task.Delay(timeout, cts.Token));
FrameworkFork\System.ServiceModel\Internals\System\Runtime\TimeoutHelper.cs (2)
310var token = tokenSource.Token; 326tokenTask = Task.FromResult(new CancellationTokenSource(millisecondsTimeout).Token);
FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\HttpChannelFactory.cs (1)
937_httpResponseMessage = await _httpClient.SendAsync(_httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, _httpSendCts.Token);
FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\SslStreamSecurityUpgradeProvider.cs (3)
288SecurityToken token = _serverTokenProvider.GetTokenAsync(cts.Token).GetAwaiter().GetResult(); 527_clientToken = (X509SecurityToken)_clientCertificateProvider.GetTokenAsync(cts.Token).GetAwaiter().GetResult(); 541_clientToken = (X509SecurityToken)(await _clientCertificateProvider.GetTokenAsync(cts.Token));
Tool.cs (1)
71cancellationToken = cancellationSource.Token;
GenerateDocumentationAndConfigFiles (3)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
HelixTestRunner (11)
ProcessUtil.cs (1)
192await Task.WhenAny(processLifetimeTask.Task, Task.Delay(TimeSpan.FromSeconds(5), cancel.Token));
TestRunner.cs (10)
140cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token); 148cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token); 156cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token); 178cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token); 187cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token); 206cancellationToken: new CancellationTokenSource(TimeSpan.FromMinutes(2)).Token); 245cancellationToken: cts.Token); 247if (cts.Token.IsCancellationRequested) 267cancellationToken: cts.Token); 269if (cts.Token.IsCancellationRequested)
HtmlGenerationWebSite (1)
SignalTokenProviderService.cs (1)
21var changeToken = new CancellationChangeToken(cancellationTokenSource.Token);
http2cat (1)
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
HttpStress (3)
Program.cs (3)
218Task<HttpResponseMessage> t = ctx.HttpClient.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, cts.Token); 305req.Content = new CancelableContent(cts.Token); 306Task<HttpResponseMessage> t = ctx.HttpClient.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, cts.Token);
IIS.FunctionalTests (1)
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
IIS.LongTests (1)
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
IIS.NewHandler.FunctionalTests (1)
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
IIS.NewShim.FunctionalTests (1)
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
IIS.Tests (2)
ClientDisconnectTests.cs (2)
157await ctx.Response.Body.WriteAsync(data, cancellationTokenSource.Token); 196var task = ctx.Request.Body.ReadAsync(data, cancellationTokenSource.Token);
IISExpress.FunctionalTests (1)
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
InMemory.FunctionalTests (13)
ConnectionMiddlewareTests.cs (1)
200stopTask = server.StopAsync(shutdownCts.Token);
EventSourceTests.cs (1)
302await Assert.ThrowsAnyAsync<Exception>(() => sslStream.AuthenticateAsClientAsync(clientAuthOptions, handshakeCts.Token));
Http2\Http2StreamTests.cs (1)
3831var writeTask = context.Response.WriteAsync("hello,", cts.Token);
KeepAliveTimeoutTests.cs (2)
143await using (var server = CreateServer(testContext, longRunningCt: cts.Token)) 213await using (var server = CreateServer(testContext, upgradeCt: cts.Token))
RequestTests.cs (2)
121await context.Request.Body.FillEntireBufferAsync(data, cts.Token).DefaultTimeout(); 135var task = context.Request.Body.ReadAsync(data, 0, data.Length, cts.Token);
ResponseTests.cs (3)
156await context.Response.WriteAsync("hello", cts.Token).DefaultTimeout(); 161var writeTask = context.Response.BodyWriter.WriteAsync(new Memory<byte>(data, 0, data.Length), cts.Token).AsTask().DefaultTimeout(); 168writeTask = context.Response.BodyWriter.WriteAsync(new Memory<byte>(data, 0, data.Length), cts.Token).AsTask().DefaultTimeout();
src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (2)
1014ConnectionClosedRequested = ConnectionClosingCts.Token; 1015ConnectionClosed = ConnectionClosedCts.Token;
TestTransport\InMemoryTransportConnection.cs (1)
38ConnectionClosed = _connectionClosedTokenSource.Token;
InProcessWebSite (1)
src\Servers\IIS\IIS\test\testassets\InProcessWebSite\Startup.cs (1)
1015await server.StopAsync(cts.Token);
IntegrationTestsWebsite (1)
Infrastructure\DynamicEndpointDataSource.cs (1)
28_cct = new CancellationChangeToken(_cts.Token);
Interop.FunctionalTests (6)
Http3\Http3RequestTests.cs (2)
495var responseTask = client.SendAsync(request, cts.Token); 734var responseTask = client.SendAsync(request, cts.Token);
HttpClientHttp2InteropTests.cs (4)
216await stream.WriteAsync(Content, 0, Content.Length, timer.Token).DefaultTimeout(); 236read = await stream.ReadAsync(buffer, 0, buffer.Length, timer.Token).DefaultTimeout(); 251read = await stream.ReadAsync(buffer, 0, buffer.Length, timer.Token).DefaultTimeout(); 932var requestTask = client.GetAsync(url, requestCancellation.Token);
InteropClient (2)
InteropClient.cs (2)
488using (var call = client.StreamingInputCall(cancellationToken: cts.Token)) 505using (var call = client.FullDuplexCall(cancellationToken: cts.Token))
InteropTests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Metrics (7)
Program.cs (1)
32return (int)RunAsync(args, tokenSource.Token).GetAwaiter().GetResult();
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Metrics.Legacy (7)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\RoslynAnalyzers\Tools\Metrics\Program.cs (1)
32return (int)RunAsync(args, tokenSource.Token).GetAwaiter().GetResult();
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.AspNetCore.Components (2)
NavigationManager.cs (1)
372var cancellationToken = cts.Token;
Routing\Router.cs (1)
355var navigateContext = new NavigationContext(path, _onNavigateCts.Token);
Microsoft.AspNetCore.Components.Endpoints (3)
Builder\RazorComponentEndpointDataSource.cs (2)
64_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token); 166_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
DependencyInjection\HotReloadService.cs (1)
25public IChangeToken GetChangeToken() => new CancellationChangeToken(_tokenSource.Token);
Microsoft.AspNetCore.Components.QuickGrid (1)
QuickGrid.razor.cs (1)
323startIndex, Pagination?.ItemsPerPage, _sortByColumn, _sortByAscending, thisLoadCts.Token);
Microsoft.AspNetCore.Components.Server (5)
Circuits\CircuitRegistry.cs (1)
155new CancellationChangeToken(cancellationTokenSource.Token),
Circuits\DefaultInMemoryCircuitPersistenceProvider.cs (1)
63ExpirationTokens = { new CancellationChangeToken(cancellationTokenSource.Token) },
Circuits\RemoteJSDataStream.cs (1)
259return new(linkedCts, linkedCts.Token);
Circuits\RemoteJSRuntime.cs (1)
191cancellationTokenSource.Token.Register(() =>
Circuits\RevalidatingServerAuthenticationStateProvider.cs (1)
42_ = RevalidationLoop(authenticationStateTask, _loopCancellationTokenSource.Token);
Microsoft.AspNetCore.Components.Server.Tests (5)
Circuits\RemoteJSDataStreamTest.cs (4)
296var token1 = isToken1Cancelable ? cts.Token : CancellationToken.None; 297var token2 = isToken1Cancelable ? CancellationToken.None : cts.Token; 328using var linkedCts = RemoteJSDataStream.ValueLinkedCancellationTokenSource.Create(cts1.Token, cts2.Token);
Circuits\RevalidatingServerAuthenticationStateProviderTest.cs (1)
206validationTcs.TrySetCanceled(new CancellationTokenSource().Token);
Microsoft.AspNetCore.Components.Tests (2)
ComponentBaseTest.cs (1)
363cts.Token.ThrowIfCancellationRequested();
RendererTest.cs (1)
4129cancellationTokenSource.Token.ThrowIfCancellationRequested();
Microsoft.AspNetCore.Components.Web (3)
Forms\InputFile\BrowserFileStream.cs (2)
35OpenReadStreamTask = OpenReadStreamAsync(_openReadStreamCts.Token); 105return await stream.ReadAsync(destination, _copyFileDataCts.Token);
Virtualization\Virtualize.cs (1)
409cancellationToken = _refreshCts.Token;
Microsoft.AspNetCore.Components.WebAssembly.Server (2)
DebugProxyLauncher.cs (1)
87ctr = cts.Token.Register(() =>
TargetPickerUi.cs (1)
137var token = source.Token;
Microsoft.AspNetCore.Components.WebAssembly.Tests (4)
Hosting\WebAssemblyHostTest.cs (4)
29var task = host.RunAsyncCore(cts.Token, cultureProvider); 47var task = host.RunAsyncCore(cts.Token, cultureProvider); 50var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => host.RunAsyncCore(cts.Token)); 76var task = host.RunAsyncCore(cts.Token, cultureProvider);
Microsoft.AspNetCore.ConcurrencyLimiter.Tests (2)
ConcurrencyLimiterEventSourceTests.cs (2)
59var lengthValues = eventListener.GetCounterValues("queue-length", timeoutTokenSource.Token); 100var durationValues = eventListener.GetCounterValues("queue-duration", timeoutTokenSource.Token);
Microsoft.AspNetCore.Connections.Abstractions (1)
DefaultConnectionContext.cs (1)
55ConnectionClosed = _connectionClosedTokenSource.Token;
Microsoft.AspNetCore.DataProtection (1)
KeyManagement\XmlKeyManager.cs (1)
285return Interlocked.CompareExchange<CancellationTokenSource?>(ref _cacheExpirationTokenSource, null, null).Token;
Microsoft.AspNetCore.DataProtection.Tests (14)
KeyManagement\CacheableKeyRingTests.cs (2)
24var cacheableKeyRing = new CacheableKeyRing(cts.Token, now.AddHours(1), keyRing); 39var cacheableKeyRing = new CacheableKeyRing(cts.Token, now.AddHours(1), keyRing);
KeyManagement\KeyRingProviderTests.cs (12)
31getCacheExpirationTokenReturnValues: new[] { expirationCts.Token }, 69getCacheExpirationTokenReturnValues: new[] { expirationCts.Token }, 115getCacheExpirationTokenReturnValues: new[] { expirationCts1.Token, expirationCts2.Token }, 204getCacheExpirationTokenReturnValues: new[] { expirationCts1.Token, expirationCts2.Token }, 288getCacheExpirationTokenReturnValues: new[] { expirationCts1.Token, expirationCts2.Token }, 334getCacheExpirationTokenReturnValues: new[] { expirationCts.Token }, 372getCacheExpirationTokenReturnValues: new[] { expirationCts.Token }, 732.Returns(new CacheableKeyRing(cts.Token, StringToDateTime("2015-03-02 00:00:00Z"), originalKeyRing)); 825expirationToken: cts.Token,
Microsoft.AspNetCore.Diagnostics.Middleware (1)
Latency\RequestLatencyTelemetryMiddleware.cs (1)
93exports.Add(latencyDataExporter.ExportAsync(latencyData, tokenSource.Token));
Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (2)
JsonTranscodingServerCallContextTests.cs (2)
25var httpContext = CreateHttpContext(cancellationToken: cts.Token); 32Assert.Equal(cts.Token, ct);
Microsoft.AspNetCore.Hosting (7)
Internal\ApplicationLifetime.cs (3)
34public CancellationToken ApplicationStarted => _startedSource.Token; 40public CancellationToken ApplicationStopping => _stoppingSource.Token; 47public CancellationToken ApplicationStopped => _stoppedSource.Token;
Internal\WebHost.cs (1)
291cancellationToken = cts.Token;
WebHostExtensions.cs (3)
27await host.StopAsync(cts.Token); 54await host.WaitForTokenShutdownAsync(cts.Token); 96await host.RunAsync(cts.Token, "Application started. Press Ctrl+C to shut down.");
Microsoft.AspNetCore.Hosting.Tests (11)
HostingApplicationDiagnosticsTests.cs (4)
40timeoutTokenSource.Token.Register(() => Logger.LogError("Timeout while waiting for counter value.")); 42var totalRequestValues = eventListener.GetCounterValues("total-requests", timeoutTokenSource.Token); 43var currentRequestValues = eventListener.GetCounterValues("current-requests", timeoutTokenSource.Token); 44var failedRequestValues = eventListener.GetCounterValues("failed-requests", timeoutTokenSource.Token);
Internal\HostingEventSourceTests.cs (4)
193timeoutTokenSource.Token.Register(() => Logger.LogError("Timeout while waiting for counter value.")); 195var totalRequestValues = eventListener.GetCounterValues("total-requests", timeoutTokenSource.Token); 196var currentRequestValues = eventListener.GetCounterValues("current-requests", timeoutTokenSource.Token); 197var failedRequestValues = eventListener.GetCounterValues("failed-requests", timeoutTokenSource.Token);
WebHostTests.cs (3)
171var runInBackground = host.RunAsync(cts.Token); 226var task = host.StopAsync(cts.Token); 300var task = host.StopAsync(cts.Token);
Microsoft.AspNetCore.Http (3)
Timeouts\CancellationTokenLinker.cs (1)
17var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(originalToken, timeoutCts.Token);
Timeouts\HttpRequestTimeoutFeature.cs (1)
15public CancellationToken RequestTimeoutToken => _timeoutCancellationTokenSource.Token;
Timeouts\RequestTimeoutsMiddleware.cs (1)
106context.RequestAborted = linkedCts.Token;
Microsoft.AspNetCore.Http.Connections (10)
Internal\HttpConnectionContext.cs (7)
109ConnectionClosed = _connectionClosedTokenSource.Token; 112ConnectionClosedRequested = _connectionCloseRequested.Token; 484var tokenSource = CancellationTokenSource.CreateLinkedTokenSource(Cancellation.Token, nonClonedContext.RequestAborted, timeoutSource.Token); 490var longPolling = new LongPollingServerTransport(timeoutSource.Token, Application.Input, loggerFactory, this); 493TransportTask = longPolling.ProcessRequestAsync(nonClonedContext, tokenSource.Token); 651SendingToken = _sendCts.Token;
Internal\Transports\WebSocketsServerTransport.cs (3)
83var resultTask = await Task.WhenAny(sending, Task.Delay(_options.CloseTimeout, delayCts.Token)); 111var resultTask = await Task.WhenAny(receiving, Task.Delay(_options.CloseTimeout, delayCts.Token)); 133var token = _connection.Cancellation?.Token ?? default;
Microsoft.AspNetCore.Http.Connections.Client (9)
Internal\LongPollingTransport.cs (1)
76var receiving = Poll(url, _transportCts.Token);
Internal\ServerSentEventsTransport.cs (2)
93var receiving = ProcessEventStream(response, _transportCts.Token); 94var sending = SendUtils.SendMessages(url, _application, _httpClient, _logger, _inputCts.Token);
Internal\WebSocketsTransport.cs (6)
367var resultTask = await Task.WhenAny(sending, Task.Delay(_closeTimeout, _stopCts.Token)).ConfigureAwait(false); 443var result = await socket.ReceiveAsync(Memory<byte>.Empty, _stopCts.Token).ConfigureAwait(false); 461var receiveResult = await socket.ReceiveAsync(memory, _stopCts.Token).ConfigureAwait(false); 562await socket.SendAsync(buffer, _webSocketMessageType, _stopCts.Token).ConfigureAwait(false); 602await socket.CloseOutputAsync(error != null ? WebSocketCloseStatus.InternalServerError : WebSocketCloseStatus.NormalClosure, "", _stopCts.Token).ConfigureAwait(false); 608await socket.CloseAsync(error != null ? WebSocketCloseStatus.InternalServerError : WebSocketCloseStatus.NormalClosure, "", _stopCts.Token).ConfigureAwait(false);
Microsoft.AspNetCore.Http.Connections.Tests (8)
ApplicationLifetime.cs (3)
16public CancellationToken ApplicationStarted => _startedSource.Token; 18public CancellationToken ApplicationStopping => _stoppingSource.Token; 20public CancellationToken ApplicationStopped => _stoppedSource.Token;
HttpConnectionDispatcherTests.cs (4)
460context.RequestAborted = cts.Token; 523context.RequestAborted = cts.Token; 2908RequestAborted = _cts.Token; 3116context.RequestAborted = cts.Token;
LongPollingTests.cs (1)
54await poll.ProcessRequestAsync(context, cts.Token).DefaultTimeout();
Microsoft.AspNetCore.Http.Extensions.Tests (9)
HttpRequestJsonExtensionsTests.cs (1)
144var readTask = context.Request.ReadFromJsonAsync<List<int>>(cts.Token);
HttpResponseJsonExtensionsTests.cs (5)
132var writeTask = context.Response.WriteAsJsonAsync(1, cts.Token); 317context.RequestAborted = cts.Token; 351context.RequestAborted = cts.Token; 389await Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Response.WriteAsJsonAsync(AsyncEnumerable(), typeof(IAsyncEnumerable<int>), cts.Token)); 423await Assert.ThrowsAnyAsync<OperationCanceledException>(() => context.Response.WriteAsJsonAsync(AsyncEnumerable(), cts.Token));
RequestDelegateFactoryTests.cs (2)
1226httpContext.RequestAborted = cts.Token; 3753public CancellationToken RequestAborted { get => _requestAbortedCts.Token; set => throw new NotImplementedException(); }
RequestDelegateGenerator\RequestDelegateCreationTests.SpecialTypes.cs (1)
59httpContext.RequestAborted = cts.Token;
Microsoft.AspNetCore.Http.Microbenchmarks (1)
RequestTimeoutsMiddlewareBenchmark.cs (1)
121context.RequestAborted = cts.Token;
Microsoft.AspNetCore.Http.Results.Tests (2)
ServerSentEventsResultTests.cs (2)
225httpContext.RequestAborted = cts.Token; 230var events = GetEvents(cts.Token);
Microsoft.AspNetCore.Http.Tests (1)
Timeouts\RequestTimeoutsMiddlewareTests.cs (1)
374ReplacedToken = cts.Token;
Microsoft.AspNetCore.HttpLogging (2)
FileLoggerProcessor.cs (2)
131await WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token); 144await Task.Delay(_flushInterval, _cancellationTokenSource.Token);
Microsoft.AspNetCore.InternalTesting (2)
xunit\AspNetTestInvoker.cs (2)
44await lifecycleHook.OnTestStartAsync(context, CancellationTokenSource.Token).ConfigureAwait(false); 55await lifecycleHook.OnTestEndAsync(context, exception, CancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.AspNetCore.InternalTesting.Tests (4)
TaskExtensionsTest.cs (4)
17await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).TimeoutAfter(TimeSpan.FromMilliseconds(50))); 37await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).DefaultTimeout(TimeSpan.FromMilliseconds(50))); 45await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).DefaultTimeout(50)); 53await Assert.ThrowsAsync<TimeoutException>(async () => await Task.Delay(30000, cts.Token).DefaultTimeout(50));
Microsoft.AspNetCore.Mvc (1)
HotReloadService.cs (1)
64IChangeToken IActionDescriptorChangeProvider.GetChangeToken() => new CancellationChangeToken(_tokenSource.Token);
Microsoft.AspNetCore.Mvc.Core (2)
Infrastructure\DefaultActionDescriptorCollectionProvider.cs (1)
165_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
Routing\ActionEndpointDataSourceBase.cs (1)
135_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
Microsoft.AspNetCore.Mvc.Core.Test (9)
Formatters\SystemTextJsonOutputFormatterTest.cs (1)
126actionContext.HttpContext.RequestAborted = cts.Token;
Infrastructure\AsyncEnumerableReaderTest.cs (2)
214await reader(enumerable, cts.Token); 217Assert.Equal(cts.Token, token);
Infrastructure\DefaultActionDescriptorCollectionProviderTest.cs (1)
181return new CancellationChangeToken(TokenSource.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;
Routing\ActionEndpointDataSourceBaseTest.cs (1)
85var changeToken = new CancellationChangeToken(cts.Token);
Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (2)
XmlDataContractSerializerOutputFormatterTest.cs (1)
734outputFormatterContext.HttpContext.RequestAborted = cts.Token;
XmlSerializerOutputFormatterTest.cs (1)
516outputFormatterContext.HttpContext.RequestAborted = cts.Token;
Microsoft.AspNetCore.Mvc.IntegrationTests (1)
ModelBindingTestHelper.cs (1)
212public CancellationToken RequestAborted { get => _cts.Token; set => throw new NotImplementedException(); }
Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (11)
NewtonsoftJsonOutputFormatterTest.cs (3)
444actionContext.HttpContext.RequestAborted = cts.Token; 489actionContext.HttpContext.RequestAborted = cts.Token; 523actionContext.HttpContext.RequestAborted = cts.Token;
NewtonsoftJsonResultExecutorTest.cs (2)
39context.HttpContext.RequestAborted = cts.Token; 52Assert.Equal(cts.Token, token);
src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (2)
214await reader(enumerable, cts.Token); 217Assert.Equal(cts.Token, 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;
Microsoft.AspNetCore.Mvc.Razor.Test (3)
RazorViewEngineTest.cs (3)
171var changeToken = new CancellationChangeToken(cancellationTokenSource.Token); 906var changeToken = new CancellationChangeToken(cancellationTokenSource.Token); 1005var changeToken = new CancellationChangeToken(cancellationTokenSource.Token);
Microsoft.AspNetCore.Mvc.RazorPages.Test (1)
src\Mvc\Mvc.Core\test\Routing\ActionEndpointDataSourceBaseTest.cs (1)
85var changeToken = new CancellationChangeToken(cts.Token);
Microsoft.AspNetCore.Mvc.TagHelpers (1)
CacheTagHelper.cs (1)
95options.AddExpirationToken(new CancellationChangeToken(tokenSource.Token));
Microsoft.AspNetCore.Mvc.TagHelpers.Test (1)
CacheTagHelperTest.cs (1)
491.AddExpirationToken(new CancellationChangeToken(tokenSource.Token));
Microsoft.AspNetCore.OpenApi.Tests (6)
Extensions\OpenApiServiceCollectionExtensionsTests.cs (1)
299await documentProvider.GetOpenApiDocumentAsync(cts.Token);
Transformers\DocumentTransformerTests.cs (1)
273await VerifyOpenApiDocument(builder, options, _ => { }, cts.Token);
Transformers\OperationTransformerTests.cs (1)
604await VerifyOpenApiDocument(builder, options, _ => { }, cts.Token);
Transformers\SchemaTransformerTests.cs (3)
137Assert.Equal(cts.Token, cancellationToken); 142await VerifyOpenApiDocument(builder, options, document => { }, cts.Token); 889await VerifyOpenApiDocument(builder, options, _ => { }, cts.Token);
Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (1)
RedisOutputCacheStore.cs (1)
105await ExecuteGarbageCollectionAsync(GetExpirationTimestamp(TimeSpan.Zero), _disposalCancellation.Token).ConfigureAwait(false);
Microsoft.AspNetCore.OutputCaching.Tests (6)
CachedResponseBodyTests.cs (6)
35var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token); 36var copyTask = RecyclableReadOnlySequenceSegment.CopyToAsync(body, pipe.Writer, cts.Token).AsTask().ContinueWith(t => pipe.Writer.CompleteAsync(t.Exception)); 59var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token); 60var copyTask = CopyDataAsync(body, pipe.Writer, cts.Token); 84var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token); 85var copyTask = CopyDataAsync(body, pipe.Writer, cts.Token);
Microsoft.AspNetCore.ResponseCaching.Tests (6)
CachedResponseBodyTests.cs (6)
43var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token); 44var copyTask = body.CopyToAsync(pipe.Writer, cts.Token).ContinueWith(_ => pipe.Writer.CompleteAsync()); 65var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token); 66var copyTask = CopyDataAsync(body, pipe.Writer, cts.Token); 89var receiverTask = ReceiveDataAsync(pipe.Reader, receivedSegments, cts.Token); 90var copyTask = CopyDataAsync(body, pipe.Writer, cts.Token);
Microsoft.AspNetCore.Routing (1)
CompositeEndpointDataSource.cs (1)
259_consumerChangeToken = new CancellationChangeToken(cts.Token);
Microsoft.AspNetCore.Routing.Tests (1)
TestObjects\DynamicEndpointDataSource.cs (1)
49_changeToken = new CancellationChangeToken(_cts.Token);
Microsoft.AspNetCore.Server.HttpSys (2)
NativeInterop\DisconnectListener.cs (1)
60var returnToken = cts.Token;
RequestProcessing\RequestContext.cs (1)
60_disconnectToken = _requestAbortSource.Token;
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (56)
Listener\RequestBodyTests.cs (9)
59Task<int> task = context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 81int read = await context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 84read = await context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 106int read = await context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 109read = await context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 130int read = await context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 132var readTask = context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 155int read = await context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token); 158var readTask = context.Request.Body.ReadAsync(input, 0, input.Length, cts.Token);
Listener\ResponseBodyTests.cs (14)
112await context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 113await context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 134await context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 135await context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 157var writeTask = context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 177var writeTask = context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 197await context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 200var writeTask = context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 219await context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 222var writeTask = context.Response.Body.WriteAsync(new byte[10], 0, 10, cts.Token); 239var responseTask = SendRequestAsync(address, cts.Token); 275var responseTask = SendRequestAsync(address, cts.Token); 310var responseTask = SendRequestAsync(address, cts.Token); 338var responseTask = SendRequestAsync(address, cts.Token);
ResponseSendFileTests.cs (16)
340await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 341await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 358await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 359await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 379var writeTask = httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 407var writeTask = httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 434await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 436var writeTask = httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 461await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 463var writeTask = httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 502await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 507httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token)); 519var responseTask = SendRequestAsync(address, cts.Token); 562var responseTask = SendRequestAsync(address, cts.Token); 589await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token); 600await httpContext.Response.SendFileAsync(AbsoluteFilePath, 0, null, cts.Token);
ServerTests.cs (16)
158await server.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token); 201await server.StopAsync(new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token); 432var stopTask1 = server.StopAsync(cts.Token); 433var stopTask2 = server.StopAsync(cts.Token); 434var stopTask3 = server.StopAsync(cts.Token); 466var stopTask1 = server.StopAsync(cts.Token); 467var stopTask2 = server.StopAsync(cts.Token); 468var stopTask3 = server.StopAsync(cts.Token); 503var stopTask1 = server.StopAsync(cts.Token); 504var stopTask2 = server.StopAsync(new CancellationTokenSource().Token); 505var stopTask3 = server.StopAsync(new CancellationTokenSource().Token); 540var stopTask1 = server.StopAsync(new CancellationTokenSource().Token); 541var stopTask2 = server.StopAsync(cts.Token); 542var stopTask3 = server.StopAsync(new CancellationTokenSource().Token); 578stopTask1 = server.StopAsync(new CancellationTokenSource().Token); 579stopTask2 = server.StopAsync(new CancellationTokenSource().Token);
src\Shared\Http2cat\Http2CatHostedService.cs (1)
110var http2Utilities = new Http2Utilities(context, _logger, _stopTokenSource.Token);
Microsoft.AspNetCore.Server.IIS (1)
Core\IISHttpContext.IHttpRequestLifetimeFeature.cs (1)
38return _abortedCts.Token;
Microsoft.AspNetCore.Server.IntegrationTesting (3)
Deployers\SelfHostDeployer.cs (1)
201return (url: actualUrl ?? hintUrl, hostExitToken: hostExitTokenSource.Token);
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Microsoft.AspNetCore.Server.IntegrationTesting.IIS (2)
IISDeployer.cs (1)
122hostShutdownToken: _hostShutdownToken.Token,
IISExpressDeployer.cs (1)
263return (url: url, hostExitToken: hostExitTokenSource.Token);
Microsoft.AspNetCore.Server.Kestrel.Core (10)
Internal\Http\HttpProtocol.cs (1)
303return _abortedCts.Token;
Internal\Http3\Http3Connection.cs (2)
363var streamContext = await _multiplexedContext.AcceptAsync(_acceptStreamsCts.Token); 370if (_acceptStreamsCts.Token.IsCancellationRequested)
Internal\Infrastructure\KestrelConnection.cs (1)
35ConnectionClosedRequested = _connectionClosingCts.Token;
Internal\KestrelServerImpl.cs (3)
361using var cts = CancellationTokenSource.CreateLinkedTokenSource(_stopCts.Token); 371await _transportManager.StopEndpointsAsync(configsToStop, cts.Token).ConfigureAwait(false); 392await listenOption.BindAsync(AddressBindContext!, _stopCts.Token).ConfigureAwait(false);
Middleware\HttpsConnectionMiddleware.cs (3)
176await _tlsListener.OnTlsClientHelloAsync(context, cancellationTokenSource.Token); 180await DoOptionsBasedHandshakeAsync(context, sslStream, feature, cancellationTokenSource.Token); 185await sslStream.AuthenticateAsServerAsync(ServerOptionsCallback, state, cancellationTokenSource.Token);
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (3)
TlsListenerTests.cs (3)
73await Assert.ThrowsAnyAsync<OperationCanceledException>(() => listener.OnTlsClientHelloAsync(transportConnection, cts.Token)); 96await Assert.ThrowsAnyAsync<OperationCanceledException>(() => listener.OnTlsClientHelloAsync(transportConnection, cts.Token)); 117var listenerTask = listener.OnTlsClientHelloAsync(transportConnection, cts.Token);
Microsoft.AspNetCore.Server.Kestrel.Microbenchmarks (2)
src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (2)
1014ConnectionClosedRequested = ConnectionClosingCts.Token; 1015ConnectionClosed = ConnectionClosedCts.Token;
Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes (2)
Internal\NamedPipeConnection.cs (1)
48ConnectionClosed = _connectionClosedTokenSource.Token;
Internal\NamedPipeConnectionListener.cs (1)
44_listeningToken = _listeningTokenSource.Token;
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic (2)
Internal\QuicConnectionContext.cs (1)
43ConnectionClosed = _connectionClosedTokenSource.Token;
Internal\QuicStreamContext.cs (1)
128return _streamClosedTokenSource.Token;
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (1)
QuicConnectionContextTests.cs (1)
93var acceptStreamTask = serverConnection.AcceptAsync(cts.Token);
Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets (1)
Internal\SocketConnection.cs (1)
59ConnectionClosed = _connectionClosedTokenSource.Token;
Microsoft.AspNetCore.Session (10)
DistributedSession.cs (10)
221cts.Token.ThrowIfCancellationRequested(); 222var data = await _cache.GetAsync(_sessionKey, cts.Token); 235throw new OperationCanceledException("Timed out loading the session.", oex, cts.Token); 257cts.Token.ThrowIfCancellationRequested(); 258var data = await _cache.GetAsync(_sessionKey, cts.Token); 278cts.Token.ThrowIfCancellationRequested(); 283cts.Token); 290throw new OperationCanceledException("Timed out committing the session.", oex, cts.Token); 297await _cache.RefreshAsync(_sessionKey, cts.Token); 302throw new OperationCanceledException("Timed out refreshing the session.", oex, cts.Token);
Microsoft.AspNetCore.Session.Tests (3)
SessionTests.cs (3)
802var token = cts.Token; 983var token = cts.Token; 1047var token = cts.Token;
Microsoft.AspNetCore.SignalR.Client.Core (17)
HubConnection.cs (15)
285if (_state.StopCts.Token.IsCancellationRequested) 290using (CancellationTokenUtils.CreateLinkedToken(cancellationToken, _state.StopCts.Token, out var linkedToken)) 682var reader = await StreamAsChannelCoreAsync(methodName, typeof(T), args, cts.Token).ConfigureAwait(false); 686while (await reader.WaitToReadAsync(cts.Token).ConfigureAwait(false)) 941while (await reader.WaitToReadAsync(tokenSource.Token).ConfigureAwait(false)) 943while (!tokenSource.Token.IsCancellationRequested && reader.TryRead(out var item)) 958await foreach (var streamValue in stream.WithCancellation(tokenSource.Token).ConfigureAwait(false)) 969await SendWithLock(connectionState, new StreamItemMessage(streamId, item), tokenSource.Token).ConfigureAwait(false); 1516using (CancellationTokenUtils.CreateLinkedToken(cancellationToken, handshakeCts.Token, out var linkedToken)) 1610connectionState.UploadStreamToken = uploadStreamSource.Token; 1849await Task.Delay(nextRetryDelay.Value, _state.StopCts.Token).ConfigureAwait(false); 1860CompleteClose(GetOperationCanceledException("Connection stopped during reconnect delay. Done reconnecting.", ex, _state.StopCts.Token)); 1876await StartAsyncCore(_state.StopCts.Token).ConfigureAwait(false); 1897CompleteClose(GetOperationCanceledException("Connection stopped during reconnect attempt. Done reconnecting.", ex, _state.StopCts.Token)); 1954return new OperationCanceledException(message, innerException, _state.StopCts.Token);
src\SignalR\common\Shared\AsyncEnumerableAdapters.cs (1)
84var enumerator = _asyncEnumerable.GetAsyncEnumerator(_cts.Token);
src\SignalR\common\Shared\CreateLinkedToken.cs (1)
29linkedToken = cts.Token;
Microsoft.AspNetCore.SignalR.Client.FunctionalTests (7)
HubConnectionTests.cs (6)
577var stream = connection.StreamAsync<int>("Stream", 5, cts.Token); 611var stream = connection.StreamAsync<int>("Stream", 1000, cts.Token); 896var channel = await connection.StreamAsChannelAsync<int>("StreamEchoInt", stream, cts.Token).DefaultTimeout(); 940var enumerator = stream.GetAsyncEnumerator(cts.Token); 979var channel = await connection.StreamAsChannelAsync<int>("Stream", 1000, cts.Token).DefaultTimeout(); 1021await Assert.ThrowsAnyAsync<OperationCanceledException>(() => connection.StreamAsChannelAsync<int>("Stream", 5, cts.Token).DefaultTimeout());
HubConnectionTests.Tracing.cs (1)
404var stream = connection.StreamAsync<int>("Stream", 1000, cts.Token);
Microsoft.AspNetCore.SignalR.Client.Tests (15)
HttpConnectionTests.ConnectionLifecycle.cs (3)
407var startTask = connection.StartAsync(cts.Token); 447var ex = await Assert.ThrowsAsync<AggregateException>(async () => await connection.StartAsync(cts.Token)).DefaultTimeout(); 530var ex = await Assert.ThrowsAsync<AggregateException>(async () => await connection.StartAsync(cts.Token).DefaultTimeout());
HubConnectionTests.ConnectionLifecycle.cs (1)
588var startTask = hubConnection.StartAsync(cts.Token);
HubConnectionTests.cs (7)
175var invokeTask = hubConnection.InvokeAsync<int>("testMethod", cancellationToken: cts.Token).DefaultTimeout(); 233var sendTask = hubConnection.SendAsync("testMethod", new byte[100], cts.Token); 293await using var e = asyncEnumerable.GetAsyncEnumerator(cts.Token); 322var asyncEnumerable = hubConnection.StreamAsync<int>("Stream", 1, cts.Token); 324await using var e = asyncEnumerable.GetAsyncEnumerator(cts.Token); 555var invokeTask = hubConnection.InvokeAsync<object>("UploadMethod", channel.Reader, cts.Token); 587var invokeTask = hubConnection.InvokeAsync<object>("UploadMethod", channel.Reader, cts.Token);
HubServerProxyGeneratorTests.cs (2)
178var token = cts.Token; 265var token = cts.Token;
TestHttpMessageHandler.cs (2)
111var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, deleteCts.Token); 115using (cts.Token.Register(() => tcs.TrySetResult()))
Microsoft.AspNetCore.SignalR.Core (6)
HubConnectionContext.cs (2)
81ConnectionAborted = _connectionAbortedTokenSource.Token; 501using (var registration = cts.Token.UnsafeRegister(_cancelReader, input))
Internal\DefaultHubDispatcher.cs (2)
557await using var enumerator = descriptor.FromReturnedStream(result, streamCts.Token); 737arguments[parameterPointer] = cts.Token;
src\SignalR\common\Shared\AsyncEnumerableAdapters.cs (1)
84var enumerator = _asyncEnumerable.GetAsyncEnumerator(_cts.Token);
src\SignalR\common\Shared\CreateLinkedToken.cs (1)
29linkedToken = cts.Token;
Microsoft.AspNetCore.SignalR.Specification.Tests (3)
HubLifetimeManagerTestBase.cs (1)
358var invoke1 = manager1.InvokeConnectionAsync<int>(connection1.ConnectionId, "Result", new object[] { "test" }, cts.Token);
Internal\TaskExtensions.cs (2)
25if (task == await Task.WhenAny(task, Task.Delay(timeout, cts.Token))) 49if (task == await Task.WhenAny(task, Task.Delay(timeout, cts.Token)))
Microsoft.AspNetCore.SignalR.StackExchangeRedis (1)
src\SignalR\common\Shared\CreateLinkedToken.cs (1)
29linkedToken = cts.Token;
Microsoft.AspNetCore.SignalR.Tests (20)
DefaultHubLifetimeManagerTests.cs (9)
35var sendTask = manager.SendAllAsync("Hello", new object[] { "World" }, cts.Token).DefaultTimeout(); 65var sendTask = manager.SendAllExceptAsync("Hello", new object[] { "World" }, new List<string> { connection1.ConnectionId }, cts.Token).DefaultTimeout(); 89var sendTask = manager.SendConnectionAsync(connection1.ConnectionId, "Hello", new object[] { "World" }, cts.Token).DefaultTimeout(); 111var sendTask = manager.SendConnectionsAsync(new List<string> { connection1.ConnectionId }, "Hello", new object[] { "World" }, cts.Token).DefaultTimeout(); 134var sendTask = manager.SendGroupAsync("group", "Hello", new object[] { "World" }, cts.Token).DefaultTimeout(); 161var sendTask = manager.SendGroupExceptAsync("group", "Hello", new object[] { "World" }, new List<string> { connection1.ConnectionId }, cts.Token).DefaultTimeout(); 186var sendTask = manager.SendGroupsAsync(new List<string> { "group" }, "Hello", new object[] { "World" }, cts.Token).DefaultTimeout(); 211var sendTask = manager.SendUserAsync("user", "Hello", new object[] { "World" }, cts.Token).DefaultTimeout(); 241var sendTask = manager.SendUsersAsync(new List<string> { "user1", "user2" }, "Hello", new object[] { "World" }, cts.Token).DefaultTimeout();
HubConnectionHandlerTests.ClientResult.cs (2)
373var resultTask = context.Clients.Client(connectionId).GetClientResultWithCancellation(1, cts.Token); 418var resultTask = context.Clients.Client(connectionId).InvokeAsync<int>(nameof(MethodHub.GetClientResult), 1, cts.Token);
HubConnectionHandlerTests.cs (1)
2265public CancellationToken ConnectionClosedRequested { get => _cts.Token; set => throw new NotImplementedException(); }
Internal\TypedClientBuilderTests.cs (8)
102var task1 = typedProxy.Method("foo", cts1.Token); 106var task2 = typedProxy.NoArgumentMethod(cts2.Token); 116Assert.Equal(cts1.Token, send1.CancellationToken); 123Assert.Equal(cts2.Token, send2.CancellationToken); 250var task1 = typedProxy.MethodReturning("foo", cts1.Token); 254var task2 = typedProxy.NoArgumentMethodReturning(cts2.Token); 264Assert.Equal(cts1.Token, send1.CancellationToken); 271Assert.Equal(cts2.Token, send2.CancellationToken);
Microsoft.AspNetCore.SignalR.Tests.Utils (1)
src\Shared\SignalR\InProcessTestServer.cs (1)
118await _host.StartAsync(cts.Token);
Microsoft.AspNetCore.SpaProxy (2)
SpaProxyLaunchManager.cs (2)
81var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token); 112var response = await httpClient.GetAsync(_options.ServerUrl, cancellationTokenSource.Token);
Microsoft.AspNetCore.SpaServices.Extensions (2)
AngularCli\AngularCliMiddleware.cs (1)
115cancellationTokenSource.Token);
Proxying\SpaProxy.cs (1)
64applicationStoppingToken).Token;
Microsoft.AspNetCore.SpaServices.Extensions.Tests (2)
SpaServicesExtensionsTests.cs (2)
82ApplicationStopping = _applicationStoppingSource.Token; 85ApplicationStopped = _applicationStoppedSource.Token;
Microsoft.AspNetCore.StaticAssets (2)
StaticAssetEndpointDataSource.cs (2)
39_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token); 115_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
Microsoft.AspNetCore.TestHost (1)
RequestLifetimeFeature.cs (1)
15RequestAborted = _cancellationTokenSource.Token;
Microsoft.AspNetCore.TestHost.Tests (5)
ClientHandlerTests.cs (1)
478Task<int> readTask = responseStream.ReadAsync(new byte[100], 0, 100, cts.Token);
HttpContextBuilderTests.cs (2)
232var contextTask = server.SendAsync(c => { }, cts.Token); 259var readTask = responseStream.ReadAsync(new byte[100], 0, 100, cts.Token);
TestClientTests.cs (2)
734await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await client.ConnectAsync(new Uri("http://localhost"), tokenSource.Token)); 880var response = await Assert.ThrowsAnyAsync<OperationCanceledException>(() => client.GetAsync("http://localhost:12345", cts.Token));
Microsoft.AspNetCore.WebSockets.ConformanceTests (7)
Autobahn\AutobahnTester.cs (2)
38var pinger = new Timer(state => Pinger((CancellationToken)state), pingCts.Token, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10)); 165}, logger, CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, result.HostShutdownToken).Token);
AutobahnTests.cs (5)
55using (cts.Token.Register(() => logger.LogError("Test run is taking longer than maximum duration of {timeoutMinutes:0.00} minutes. Aborting...", TestTimeout.TotalMinutes))) 60await tester.DeployTestAndAddToSpec(ServerType.Kestrel, ssl: false, environment: "ManagedSockets", cancellationToken: cts.Token); 61await tester.DeployTestAndAddToSpec(ServerType.Kestrel, ssl: true, environment: "ManagedSockets", cancellationToken: cts.Token); 68await tester.DeployTestAndAddToSpec(ServerType.HttpSys, ssl: false, environment: "ManagedSockets", cancellationToken: cts.Token); 71result = await tester.Run(cts.Token);
Microsoft.AspNetCore.WebSockets.Tests (1)
WebSocketMiddlewareTests.cs (1)
601var response = await serverSocket.ReceiveAsync(new ArraySegment<byte>(new byte[1024]), cts.Token);
Microsoft.Build (12)
BackEnd\BuildManager\BuildManager.cs (5)
1389_executionCancellationTokenSource!.Token); 1438_projectCacheService!.PostCacheRequest(cacheRequest, _executionCancellationTokenSource!.Token); 1516_executionCancellationTokenSource!.Token, 2013_projectCacheService!.InitializePluginsForGraph(projectGraph, submission.BuildRequestData.TargetNames, _executionCancellationTokenSource!.Token); 2520_projectCacheService.HandleBuildResultAsync(configuration, result, buildEventContext, _executionCancellationTokenSource!.Token).Wait();
BackEnd\Components\Communications\NodeProviderOutOfProcBase.cs (1)
853await Task.WhenAny(Task.Delay(100, _packetQueueDrainDelayCancellation.Token));
BackEnd\Components\Logging\LoggingService.cs (1)
1365var completeAdding = _loggingEventProcessingCancellation.Token;
BackEnd\Components\RequestBuilder\RequestBuilder.cs (4)
676_cancellationTokenSource.Token, 696_cancellationTokenSource.Token, 708_cancellationTokenSource.Token, 1199allTargets, _requestEntry.RequestConfiguration.BaseLookup, _cancellationTokenSource.Token);
Logging\TerminalLogger\TerminalLogger.cs (1)
1054while (!_cts.Token.WaitHandle.WaitOne(1_000 / 30))
Microsoft.Build.Engine.UnitTests (1)
BackEnd\TargetBuilder_Tests.cs (1)
1400BuildResult result = builder.BuildTargets(GetProjectLoggingContext(entry), entry, this, target, CreateStandardLookup(project), source.Token).Result;
Microsoft.Build.Tasks.CodeAnalysis (4)
src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (2)
572cancellationToken: _sharedCompileCts.Token); 574responseTask.Wait(_sharedCompileCts.Token);
src\Compilers\Shared\BuildServerConnection.cs (2)
300var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 301var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Microsoft.Build.Tasks.CodeAnalysis.Sdk (4)
src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (2)
572cancellationToken: _sharedCompileCts.Token); 574responseTask.Wait(_sharedCompileCts.Token);
src\Compilers\Shared\BuildServerConnection.cs (2)
300var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 301var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Microsoft.Build.Tasks.Core (7)
AssemblyDependency\Node\OutOfProcRarNode.cs (2)
91Task nodeEndpointTasks = Task.Run(() => RunNodeEndpointsAsync(linkedCts.Token), linkedCts.Token);
DownloadFile.cs (1)
96CancellationToken cancellationToken = _cancellationTokenSource.Token;
FileIO\GetFileHash.cs (2)
81var parallelOptions = new ParallelOptions() { CancellationToken = _cancellationTokenSource.Token }; 94var hash = ComputeHash(algorithmFactory, file.ItemSpec, _cancellationTokenSource.Token);
FileIO\VerifyFileHash.cs (1)
60byte[] hash = GetFileHash.ComputeHash(algorithmFactory, File, _cancellationTokenSource.Token);
Unzip.cs (1)
263stream.CopyToAsync(destination, _DefaultCopyBufferSize, _cancellationToken.Token)
Microsoft.Build.Tasks.UnitTests (1)
DownloadFile_Tests.cs (1)
263throw new OperationCanceledException(timeout.Token);
Microsoft.CodeAnalysis (2)
CommandLine\CommonCompiler.cs (2)
1134analyzerDriver.ApplyProgrammaticSuppressions(diagnostics, compilation, analyzerCts.Token); 1536analyzerCts.Token);
Microsoft.CodeAnalysis.Analyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.AnalyzerUtilities (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.BannedApiAnalyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.CodeStyle (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.CSharp.EditorFeatures (1)
EventHookup\EventHookupSessionManager_EventHookupSession.cs (1)
97var cancellationToken = _cancellationTokenSource.Token;
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (2)
Diagnostics\DiagnosticAnalyzerTests.cs (1)
4249var diagnostics = await getDiagnosticsAsync(cancellationSource.Token).ConfigureAwait(false);
Diagnostics\DiagnosticSuppressorTests.cs (1)
679var cancellationToken = suppressor.CancellationTokenSource.Token;
Microsoft.CodeAnalysis.CSharp.Features.UnitTests (1)
SemanticSearch\CSharpSemanticSearchServiceTests.cs (1)
311() => service.ExecuteQueryAsync(solution, compileResult.QueryId, observer, options, traceSource, cancellationSource.Token));
Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (3)
InteractiveSessionTests.cs (3)
2048var state3 = await s3.RunAsync(globals, catchException: e => true, cancellationToken: cancellationSource.Token); 2082var state3 = await s3.RunAsync(globals, catchException: e => true, cancellationToken: cancellationSource.Token); 2117s3.RunAsync(globals, catchException: e => e is not OperationCanceledException, cancellationToken: cancellationSource.Token));
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (4)
SourceGeneration\GeneratorDriverTests.cs (2)
764driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var outputDiagnostics, cts.Token) 2603Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token));
SourceGeneration\SyntaxAwareGeneratorTests.cs (2)
1996Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token)); 2025Assert.Throws<OperationCanceledException>(() => driver = driver.RunGenerators(compilation, cancellationToken: cts.Token));
Microsoft.CodeAnalysis.EditorFeatures (36)
AutomaticCompletion\BraceCompletionSessionProvider.cs (1)
102return cancellationTokenSource.Token;
BackgroundWorkIndicator\BackgroundWorkIndicatorContext.cs (1)
75public CancellationToken UserCancellationToken => _cancellationTokenSource.Token;
Classification\Syntactic\SyntacticClassificationTaggerProvider.TagComputer.cs (1)
101_disposalCancellationSource.Token);
EditAndContinue\ActiveStatementTrackingService.cs (2)
165var cancellationToken = _cancellationSource.Token; 196var cancellationToken = _cancellationSource.Token;
GoOrFind\AbstractGoOrFindNavigationService.cs (2)
165var cancellationToken = cancellationTokenSource.Token; 223var cancellationToken = cancellationTokenSource.Token;
InlineRename\InlineRenameSession.cs (4)
312var cancellationToken = _cancellationTokenSource.Token; 475using (Logger.LogBlock(FunctionId.Rename_ApplyReplacementText, replacementText, _cancellationTokenSource.Token)) 538var cancellationToken = _conflictResolutionTaskCancellationSource.Token; 569var cancellationToken = _conflictResolutionTaskCancellationSource.Token;
InlineRename\UI\SmartRename\SmartRenameViewModel.cs (1)
194GetSuggestionsTaskAsync(isAutomaticOnInitialization, _cancellationTokenSource.Token).CompletesAsyncOperation(listenerToken);
IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (2)
154() => GetHighlightedListAndUpdatedFilters(session, itemsToBeIncluded, threadLocalPatternMatchHelper, cancellationTokenSource.Token), 155cancellationTokenSource.Token);
IntelliSense\ModelComputation.cs (1)
58_stopCancellationToken = _stopTokenSource.Token;
Interactive\InteractiveSession.cs (1)
91_shutdownCancellationSource.Token);
NavigateTo\NavigateToItemProvider.cs (2)
123_ = searcher.SearchAsync(searchScope, _cancellationTokenSource.Token) 125.ReportNonFatalErrorUnlessCancelledAsync(_cancellationTokenSource.Token);
NavigationBar\NavigationBarController.cs (3)
106_nonFrozenComputationCancellationSeries = new(_cancellationTokenSource.Token); 113_cancellationTokenSource.Token); 119_cancellationTokenSource.Token);
NavigationBar\NavigationBarController_ModelComputation.cs (2)
51return await ComputeModelAndSelectItemAsync(frozenPartialSemantics: false, linkedTokenSource.Token).ConfigureAwait(false); 53catch (OperationCanceledException ex) when (ExceptionUtilities.IsCurrentOperationBeingCancelled(ex, linkedTokenSource.Token))
QuickInfo\OnTheFlyDocsView.xaml.cs (1)
159ResultsRequested += (_, _) => PopulateAIDocumentationElements(_cancellationTokenSource.Token);
RenameTracking\RenameTrackingTaggerProvider.TrackingSession.cs (1)
64_cancellationToken = _cancellationTokenSource.Token;
Shared\Utilities\ThreadingContext.cs (1)
63public CancellationToken DisposalToken => _disposalTokenSource.Token;
Suggestions\SuggestedActionsSource.cs (1)
162cancellationToken = linkedTokenSource.Token;
Tagging\AbstractAsynchronousTaggerProvider.TagSource.cs (4)
149_nonFrozenComputationCancellationSeries = new(_disposalTokenSource.Token); 159_disposalTokenSource.Token); 166_disposalTokenSource.Token); 181_disposalTokenSource.Token);
Tagging\AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs (5)
146_disposalTokenSource.Token).VerifyCompleted(); 218await RecomputeTagsAsync(highPriority, frozenPartialSemantics, calledFromJtfRun: false, linkedTokenSource.Token).ConfigureAwait(false); 221catch (OperationCanceledException ex) when (ExceptionUtilities.IsCurrentOperationBeingCancelled(ex, linkedTokenSource.Token)) 728if (_disposalTokenSource.Token.IsCancellationRequested) 742this.RecomputeTagsAsync(highPriority: true, _dataSource.SupportsFrozenPartialSemantics, calledFromJtfRun: true, _disposalTokenSource.Token));
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (2)
Threading\WpfTestRunner.cs (2)
72return invoker.RunAsync().JoinUsingDispatcher(CancellationTokenSource.Token); 80}, CancellationTokenSource.Token, TaskCreationOptions.None, new SynchronizationContextTaskScheduler(sta.DispatcherSynchronizationContext));
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities2 (2)
Intellisense\TestState.vb (2)
274Await Task.WhenAny(sessionComplete.Task, Task.Delay(TimeSpan.FromSeconds(2), cancellationSource.Token)) 609Using registration = ct.Token.Register(Sub() tcs.TrySetCanceled(), useSynchronizationContext:=False)
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)
Utilities\AsynchronousOperationListenerTests.cs (2)
65_tokenSource.Token.ThrowIfCancellationRequested(); 68}, _tokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
Microsoft.CodeAnalysis.ExternalAccess.Copilot (2)
Internal\SemanticSearch\CopilotSemanticSearchQueryExecutor.cs (2)
86cancellationSource.Token).ConfigureAwait(false); 115cancellationSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.ExternalAccess.Razor.Features (1)
Cohost\RazorStartupServiceFactory.cs (1)
73this.InitializeRazorAsync(clientCapabilities, context, _disposalTokenSource.Token).ReportNonFatalErrorAsync();
Microsoft.CodeAnalysis.Features (11)
AddImport\AbstractAddImportFeatureService.cs (5)
249linkedTokenSource.Token).ConfigureAwait(false); 251catch (OperationCanceledException ex) when (ex.CancellationToken == linkedTokenSource.Token) 306linkedTokenSource.Token).ConfigureAwait(false); 308catch (OperationCanceledException ex) when (ex.CancellationToken == linkedTokenSource.Token) 356linkedTokenSource.Token.ThrowIfCancellationRequested();
CodeFixes\Service\CodeFixService.cs (1)
126var linkedToken = linkedTokenSource.Token;
CodeLens\CodeLensFindReferenceProgress.cs (2)
43public CancellationToken CancellationToken => _aggregateCancellationTokenSource.Token; 97? GetPartialLocations(symbol, _aggregateCancellationTokenSource.Token)
ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.cs (1)
48_shutdownToken = _shutdownNotificationSource.Token;
ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingAsyncWorkItemQueue.cs (1)
237return source.Token;
SemanticSearch\QueryExecutionContext.cs (1)
54await Parallel.ForEachAsync(solution.Projects, symbolEnumerationCancellationSource.Token, async (project, cancellationToken) =>
Microsoft.CodeAnalysis.InteractiveHost (4)
Interactive\Core\InteractiveHost.LazyRemoteService.cs (1)
55=> _lazyInitializedService.GetValueAsync(_cancellationSource.Token);
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
Microsoft.CodeAnalysis.LanguageServer (5)
BrokeredServices\ServiceBrokerFactory.cs (2)
67_container = await BrokeredServiceContainer.CreateAsync(_exportProvider, _cancellationTokenSource.Token); 87_bridgeCompletionTask = bridgeProvider.SetupBrokeredServicesBridgeAsync(brokeredServicePipeName, _container!, _cancellationTokenSource.Token);
HostWorkspace\FileWatching\LspFileChangeWatcher.cs (2)
232_registrationTask = changeWatcher._clientLanguageServerManager.SendRequestAsync("client/registerCapability", registrationParams, _cancellationTokenSource.Token).AsTask(); 233_registrationTask.ReportNonFatalErrorUnlessCancelledAsync(_cancellationTokenSource.Token).CompletesAsyncOperation(asyncToken);
Program.cs (1)
85while (!Debugger.IsAttached && !timeoutSource.Token.IsCancellationRequested)
Microsoft.CodeAnalysis.LanguageServer.Protocol (10)
Handler\AbstractRefreshQueue.cs (1)
73_disposalTokenSource.Token);
Handler\SourceGenerators\SourceGeneratorRefreshQueue.cs (4)
50_disposalTokenSource.Token); 71.ReportNonFatalErrorUnlessCancelledAsync(_disposalTokenSource.Token); 115if (await oldProject.GetDependentVersionAsync(_disposalTokenSource.Token).ConfigureAwait(false) != 116await newProject.GetDependentVersionAsync(_disposalTokenSource.Token).ConfigureAwait(false))
src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\RequestExecutionQueue.cs (5)
84public CancellationToken CancellationToken => _cancelSource.Token; 166var combinedTokenSource = _cancelSource.Token.CombineWith(requestCancellationToken); 204queueItem = await _queue.DequeueAsync(_cancelSource.Token).ConfigureAwait(false); 206catch (OperationCanceledException ex) when (ex.CancellationToken == _cancelSource.Token) 235cancellationToken = currentWorkCts.Token;
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (1)
Ordering\RequestOrderingTests.cs (1)
143var waitables = StartTestRun(testLspServer, requests, cts.Token);
Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.PublicApiAnalyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.Remote.ServiceHub (3)
Host\RemoteWorkspace.InFlightSolution.cs (1)
81return _cancellationTokenSource_doNotAccessDirectly.Token;
Services\ProcessTelemetry\RemoteProcessTelemetryService.cs (1)
67_performanceReporter = new PerformanceReporter(telemetrySession, diagnosticAnalyzerPerformanceTracker, _shutdownCancellationSource.Token);
Services\SemanticClassification\RemoteSemanticClassificationService.Caching.cs (1)
67_cancellationTokenSource.Token);
Microsoft.CodeAnalysis.ResxSourceGenerator (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Microsoft.CodeAnalysis.Test.Utilities (2)
Diagnostics\CommonDiagnosticAnalyzers.cs (2)
2677public CancellationToken CancellationToken => _cancellationTokenSource.Token; 2919public CancellationToken CancellationToken => _cancellationTokenSource.Token;
Microsoft.CodeAnalysis.Threading.Package (1)
CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
Microsoft.CodeAnalysis.UnitTests (3)
AsyncQueueTests.cs (3)
167var task = queue.DequeueAsync(cts.Token); 179var task = queue.DequeueAsync(cts.Token); 196var task = queue.DequeueAsync(cts.Token);
Microsoft.CodeAnalysis.Workspaces (13)
FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (1)
52_tokenSource.Token);
Remote\IRemoteKeepAliveService.cs (2)
40_cancellationTokenSource.Token).AsTask(); 45var cancellationToken = _cancellationTokenSource.Token;
Shared\TestHooks\AsynchronousOperationListener.cs (2)
49var expeditedDelayCancellationToken = _expeditedDelayCancellationTokenSource.Token; 58var delayTask = Task.Delay(delay, cancellationTokenSource.Token);
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
Storage\SQLite\v2\SQLitePersistentStorage.cs (1)
117_shutdownTokenSource.Token);
Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (1)
465_project._asynchronousFileChangeProcessingCancellationTokenSource.Token);
Workspace\ProjectSystem\ProjectSystemProject.cs (1)
204_asynchronousFileChangeProcessingCancellationTokenSource.Token);
Workspace\Workspace.cs (2)
88_workQueueTokenSource.Token); 103_updateSourceGeneratorsQueueTokenSource.Token);
Microsoft.CodeAnalysis.Workspaces.MSBuild (1)
Rpc\RpcClient.cs (1)
58while ((line = await _receivingStreamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (1)
Rpc\RpcServer.cs (1)
65while ((line = await _streamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (2)
RpcTests.cs (1)
213await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await rpcPair.Client.InvokeAsync<string>(targetObject: 0, nameof(ObjectWithHelloMethod.Hello), [], tokenSource.Token));
src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (1)
65while ((line = await _streamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)
MEF\UseExportProviderAttribute.cs (1)
140taskJoiner.JoinUsingDispatcher(waiter, timeoutTokenSource.Token);
Microsoft.CodeAnalysis.Workspaces.UnitTests (27)
UtilityTest\AsyncLazyTests.cs (9)
72lazy.GetValue(requestCancellationTokenSource.Token); 89var asyncContinuation = lazy.GetValueAsync(requestCancellationTokenSource.Token).ContinueWith(antecedent => 185doGetValue(lazy, cancellationTokenSource.Token); 190Assert.Equal(cancellationTokenSource.Token, oce.CancellationToken); 208var task = lazy.GetValueAsync(cancellationTokenSource.Token); 219Assert.Equal(cancellationTokenSource.Token, operationCancelledException.CancellationToken); 252lazy.GetValue(requestCancellationTokenSource.Token); 336var asynchronousRequestToBeCancelled = lazy.GetValueAsync(cancellationTokenSource.Token); 396var asynchronousRequest = Task.Run(() => lazy.GetValueAsync(asynchronousRequestCancellationToken.Token));
UtilityTest\CancellationSeriesTests.cs (4)
65using var series = new CancellationSeries(cts.Token); 81var token = series.CreateNext(cts.Token); 91using var series = new CancellationSeries(cts.Token); 107var token = series.CreateNext(cts.Token);
UtilityTest\SpecializedTasksTests.cs (14)
108var cancellationToken = cts.Token; 153var cancellationToken = cts.Token; 185var cancellationToken = cts.Token; 209var cancellationToken = cts.Token; 215cts.Token.ThrowIfCancellationRequested(); 243Func<StateType, CancellationToken, ValueTask<IntermediateType>> func = (_, _) => new(Task.FromCanceled<IntermediateType>(unexpectedCts.Token)); 275unexpectedCts.Token.ThrowIfCancellationRequested(); 309var cancellationToken = cts.Token; 310Func<StateType, CancellationToken, ValueTask<IntermediateType>> func = (_, _) => new(Task.FromCanceled<IntermediateType>(unexpectedCts.Token)); 336var cancellationToken = cts.Token; 342unexpectedCts.Token.ThrowIfCancellationRequested(); 445var cancellationToken = cts.Token; 470var cancellationToken = cts.Token; 495var cancellationToken = cts.Token;
Microsoft.CommonLanguageServerProtocol.Framework.Package (5)
RequestExecutionQueue.cs (5)
84public CancellationToken CancellationToken => _cancelSource.Token; 166var combinedTokenSource = _cancelSource.Token.CombineWith(requestCancellationToken); 204queueItem = await _queue.DequeueAsync(_cancelSource.Token).ConfigureAwait(false); 206catch (OperationCanceledException ex) when (ex.CancellationToken == _cancelSource.Token) 235cancellationToken = currentWorkCts.Token;
Microsoft.DotNet.Arcade.Sdk (2)
src\DownloadFile.cs (2)
184var httpResponse = await httpClient.GetAsync(uri, _cancellationSource.Token).ConfigureAwait(false); 211e is Tasks.TaskCanceledException && ((Tasks.TaskCanceledException)e).CancellationToken != _cancellationSource.Token)
Microsoft.DotNet.ArcadeAzureIntegration (1)
AzureCliCredentialWithAzNoUpdateWrapper.cs (1)
96await process.WaitForExitAsync(tokenSource.Token);
Microsoft.DotNet.Build.Tasks.Feed (8)
src\BlobFeedAction.cs (1)
25private static readonly CancellationToken CancellationToken = TokenSource.Token;
src\common\UploadToAzure.cs (2)
19private static readonly CancellationToken CancellationToken = TokenSource.Token; 121await blobReference.UploadAsync(localFileStream, timeoutTokenSource.Token);
src\PublishArtifactsInManifestBase.cs (4)
943using HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, timeoutTokenSource.Token); 946using var stream = await response.Content.ReadAsStreamAsync(timeoutTokenSource.Token); 947await stream.CopyToAsync(fs, timeoutTokenSource.Token); 979using HttpResponseMessage response = await client.GetAsync(uri, timeoutTokenSource.Token);
src\PublishBuildToMaestro.cs (1)
86await PushMetadataAsync(_tokenSource.Token);
Microsoft.DotNet.Build.Tasks.Installers (1)
src\ExecWithRetries.cs (1)
105Task.Delay(delay, _cancelTokenSource.Token).Wait();
Microsoft.DotNet.Helix.Sdk (3)
DownloadFromResultsContainer.cs (1)
61await Task.WhenAll(WorkItems.Select(wi => DownloadFilesForWorkItem(wi, directory.FullName, _cancellationSource.Token)));
HelixTask.cs (2)
61System.Threading.Tasks.Task.Run(() => ExecuteCore(_cancel.Token)).GetAwaiter().GetResult(); 71catch (OperationCanceledException ocex) when (ocex.CancellationToken == _cancel.Token)
Microsoft.DotNet.Internal.SymbolHelper (1)
SymbolUploadHelper.cs (1)
450ct = lcts.Token;
Microsoft.Extensions.AI.Abstractions.Tests (8)
ChatCompletion\ChatClientExtensionsTests.cs (4)
117Assert.Equal(cts.Token, cancellationToken); 123ChatResponse response = await client.GetResponseAsync("hello", expectedOptions, cts.Token); 144Assert.Equal(cts.Token, cancellationToken); 151await foreach (var update in client.GetStreamingResponseAsync("hello", expectedOptions, cts.Token))
Embeddings\DelegatingEmbeddingGeneratorTests.cs (1)
26var expectedCancellationToken = cts.Token;
SpeechToText\SpeechToTextClientExtensionsTests.cs (1)
75cts.Token))
SpeechToText\SpeechToTextClientTests.cs (2)
36cts.Token); 64cts.Token))
Microsoft.Extensions.AI.OpenAI.Tests (2)
OpenAISpeechToTextClientTests.cs (2)
117=> client.GetTextAsync(fileStream, cancellationToken: cancellationTokenSource.Token)); 132.GetStreamingTextAsync(fileStream, cancellationToken: cancellationTokenSource.Token)
Microsoft.Extensions.AI.Templates.Tests (2)
Infrastructure\TestCommand.cs (2)
102await exitedTcs.Task.WaitAsync(timeoutCts.Token).ConfigureAwait(false); 103await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Microsoft.Extensions.AI.Tests (53)
ChatCompletion\ConfigureOptionsChatClientTests.cs (4)
46Assert.Equal(cts.Token, cancellationToken); 53Assert.Equal(cts.Token, cancellationToken); 76var response = await client.GetResponseAsync(Array.Empty<ChatMessage>(), providedOptions, cts.Token); 80await using var e = client.GetStreamingResponseAsync(Array.Empty<ChatMessage>(), providedOptions, cts.Token).GetAsyncEnumerator();
ChatCompletion\FunctionInvokingChatClientTests.cs (4)
950Assert.Equal(cts.Token, actualCancellationToken); 967var result = await service.GetResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(chat), options, cts.Token); 1049Assert.Equal(cts.Token, actualCancellationToken); 1061var result = await service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(chat), options, cts.Token).ToChatResponseAsync();
ChatCompletion\UseDelegateChatClientTests.cs (19)
40Assert.Equal(expectedCts.Token, cancellationToken); 49Assert.Equal(expectedCts.Token, cancellationToken); 60Assert.Equal(expectedCts.Token, cancellationToken); 67ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 71response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync(); 89Assert.Equal(expectedCts.Token, cancellationToken); 100Assert.Equal(expectedCts.Token, cancellationToken); 110ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 113response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync(); 131Assert.Equal(expectedCts.Token, cancellationToken); 142Assert.Equal(expectedCts.Token, cancellationToken); 161ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 164response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync(); 182Assert.Equal(expectedCts.Token, cancellationToken); 191Assert.Equal(expectedCts.Token, cancellationToken); 203Assert.Equal(expectedCts.Token, cancellationToken); 213Assert.Equal(expectedCts.Token, cancellationToken); 232ChatResponse response = await client.GetResponseAsync(expectedMessages, expectedOptions, expectedCts.Token); 235response = await client.GetStreamingResponseAsync(expectedMessages, expectedOptions, expectedCts.Token).ToChatResponseAsync();
Embeddings\ConfigureOptionsEmbeddingGeneratorTests.cs (2)
43Assert.Equal(cts.Token, cancellationToken); 66var embeddings = await generator.GenerateAsync([], providedOptions, cts.Token);
Embeddings\UseDelegateEmbeddingGeneratorTests.cs (3)
39Assert.Equal(expectedCts.Token, cancellationToken); 50Assert.Equal(expectedCts.Token, cancellationToken); 60GeneratedEmbeddings<Embedding<float>> actual = await generator.GenerateAsync(expectedValues, expectedOptions, expectedCts.Token);
Functions\AIFunctionFactoryTest.cs (17)
83foreach (CancellationToken ctArg in new[] { cts.Token, default }) 595Assert.Equal(cts.Token, cancellationToken); 600object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 618Assert.Equal(cts.Token, cancellationToken); 623object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 641Assert.Equal(cts.Token, cancellationToken); 646object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 664Assert.Equal(cts.Token, cancellationToken); 669object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 687Assert.Equal(cts.Token, cancellationToken); 692object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 710Assert.Equal(cts.Token, cancellationToken); 715object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 733Assert.Equal(cts.Token, cancellationToken); 738object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 756Assert.Equal(cts.Token, cancellationToken); 762object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token);
SpeechToText\ConfigureOptionsSpeechToTextClientTests.cs (4)
47Assert.Equal(cts.Token, cancellationToken); 54Assert.Equal(cts.Token, cancellationToken); 78var response = await client.GetTextAsync(audioSpeechStream, providedOptions, cts.Token); 83await using var e = client.GetStreamingTextAsync(audioSpeechStream2, providedOptions, cts.Token).GetAsyncEnumerator();
Microsoft.Extensions.ApiDescription.Client.Tests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Microsoft.Extensions.Caching.Hybrid (2)
Internal\DefaultHybridCache.L2.cs (1)
147BufferChunk buffer = await GetFromL2DirectAsync(TagKeyPrefix + tag, cts.Token).ConfigureAwait(false);
Internal\DefaultHybridCache.StampedeState.cs (1)
50SharedToken = _sharedCancellation.Token;
Microsoft.Extensions.Caching.Hybrid.Tests (8)
StampedeTests.cs (8)
92var token = cts?.Token ?? CancellationToken.None; 206}, cancellationToken: cancels[i].Token).AsTask(); 226Assert.Equal(cancels[i].Token, ex.CancellationToken); // each gets the correct blame 284}, cancellationToken: cancels[i].Token).AsTask(); 309Assert.Equal(cancels[i].Token, ex.CancellationToken); // each gets the correct blame 334var token = cts?.Token ?? CancellationToken.None; 374var token = cts?.Token ?? CancellationToken.None; 418var token = cts?.Token ?? CancellationToken.None;
Microsoft.Extensions.Configuration (1)
ConfigurationReloadToken.cs (1)
42_cts.Token,
Microsoft.Extensions.Diagnostics.HealthChecks (3)
DefaultHealthCheckService.cs (1)
103checkCancellationToken = timeoutCancellationTokenSource.Token;
HealthCheckPublisherHostedService.cs (2)
154cancellation = CancellationTokenSource.CreateLinkedTokenSource(_stopping.Token); 158await RunAsyncCore(timerOptions, cancellation.Token).ConfigureAwait(false);
Microsoft.Extensions.Diagnostics.HealthChecks.Common.Tests (3)
MockHostApplicationLifetime.cs (3)
24ApplicationStarted = _started.Token; 25ApplicationStopping = _stopping.Token; 26ApplicationStopped = _stopped.Token;
Microsoft.Extensions.Diagnostics.HealthChecks.Tests (2)
DefaultHealthCheckServiceTest.cs (2)
262var task = service.CheckHealthAsync(cancel.Token); 577var token = cts.Token;
Microsoft.Extensions.Diagnostics.Probes.Tests (5)
TcpEndpointProbesServiceTests.cs (5)
42await tcpEndpointProbesService.StartAsync(cts.Token); 43await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 52await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 61await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 92await tcpEndpointProbesService.StartAsync(cts.Token);
Microsoft.Extensions.Diagnostics.Testing (1)
Metrics\MetricCollector.cs (1)
260await WaitForMeasurementsAsync(minCount, cancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Diagnostics.Testing.Tests (1)
Metrics\MetricCollectorTests.cs (1)
284var wait = collector.WaitForMeasurementsAsync(1, cts.Token);
Microsoft.Extensions.FileProviders.Physical (4)
PhysicalFilesWatcher.cs (2)
179var cancellationChangeToken = new CancellationChangeToken(cancellationTokenSource.Token); 214var cancellationChangeToken = new CancellationChangeToken(cancellationTokenSource.Token);
PollingFileChangeToken.cs (1)
70_changeToken = new CancellationChangeToken(_tokenSource.Token);
PollingWildCardChangeToken.cs (1)
80_changeToken = new CancellationChangeToken(_tokenSource.Token);
Microsoft.Extensions.Hosting (5)
Internal\ApplicationLifetime.cs (3)
39public CancellationToken ApplicationStarted => _startedSource.Token; 45public CancellationToken ApplicationStopping => _stoppingSource.Token; 52public CancellationToken ApplicationStopped => _stoppedSource.Token;
Internal\Host.cs (2)
81cancellationToken = cts.Token; 225cancellationToken = cts.Token;
Microsoft.Extensions.Hosting.Abstractions (3)
BackgroundService.cs (2)
46_executeTask = Task.Run(() => ExecuteAsync(_stoppingCts.Token), _stoppingCts.Token);
HostingAbstractionsHostExtensions.cs (1)
35await host.StopAsync(cts.Token).ConfigureAwait(false);
Microsoft.Extensions.Hosting.Testing (8)
FakeHost.cs (6)
74await _host.StartAsync(cancellationTokenSource.Token).ConfigureAwait(false); 80cancellationTokenSource.Token); 81await _host.StartAsync(linkedTokenSource.Token).ConfigureAwait(false); 97await _host.StopAsync(cancellationTokenSource.Token).ConfigureAwait(false); 103cancellationTokenSource.Token); 104await _host.StopAsync(linkedTokenSource.Token).ConfigureAwait(false);
HostTerminatorService.cs (2)
56timeoutTokenSource.Token); 59await _host.StopAsync(combinedTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Hosting.Testing.Tests (11)
FakeHostTests.cs (8)
62.Setup(x => x.StartAsync(It.Is<CancellationToken>(y => y != tokenSource.Token))) 68await sut.StartAsync(tokenSource.Token); 81.Setup(x => x.StartAsync(It.Is<CancellationToken>(y => y != cancellationTokenSource.Token))) 88_ = sut.StartAsync(cancellationTokenSource.Token); 121.Setup(x => x.StopAsync(It.Is<CancellationToken>(y => y != tokenSource.Token))) 127await sut.StopAsync(tokenSource.Token); 141.Setup(x => x.StopAsync(It.Is<CancellationToken>(y => y != cancellationTokenSource.Token))) 148_ = sut.StopAsync(cancellationTokenSource.Token);
HostingFakesExtensionsTests.cs (3)
31serviceMock.Setup(x => x.StartAsync(tokenSource.Token)).Returns(Task.CompletedTask); 32serviceMock.Setup(x => x.StopAsync(tokenSource.Token)).Returns(Task.CompletedTask); 34await serviceMock.Object.StartAndStopAsync(tokenSource.Token);
Microsoft.Extensions.Http.Diagnostics (2)
Logging\Internal\HttpRequestBodyReader.cs (1)
76return await ReadFromStreamAsync(request, readSizeLimit, joinedTokenSource.Token).ConfigureAwait(false);
Logging\Internal\HttpResponseBodyReader.cs (1)
81return await ReadFromStreamAsync(response, readSizeLimit, joinedTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Http.Diagnostics.Tests (2)
Logging\HttpResponseBodyReaderTest.cs (2)
188var responseBody = await httpResponseBodyReader.ReadAsync(httpResponse, cts.Token); 199var act = async () => await responseStream.ReadAsync(buffer, 0, BodySize, cts.Token);
Microsoft.Extensions.Http.Polly.Tests (1)
PolicyHttpMessageHandlerTest.cs (1)
396var token = cts.Token;
Microsoft.Extensions.Http.Resilience.PerformanceTests (2)
RetryBenchmark.cs (1)
30_cancellationToken = new CancellationTokenSource().Token;
StandardResilienceBenchmark.cs (1)
30_cancellationToken = new CancellationTokenSource().Token;
Microsoft.Extensions.Http.Resilience.Tests (11)
Hedging\HedgingTests.cs (9)
107using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 127using var _ = await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token); 152async () => await SendRequest(client, request, asynchronous, _cancellationTokenSource.Token)); 174async () => 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);
Resilience\ResilienceHandlerTest.cs (2)
135cancellationToken.Should().Be(source.Token); 140var response = await InvokeHandler(invoker, request, asynchronous, source.Token);
Microsoft.Extensions.Logging.AzureAppServices (3)
BatchingLoggerProvider.cs (3)
110await WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token).ConfigureAwait(false); 121await IntervalAsync(_interval, _cancellationTokenSource.Token).ConfigureAwait(false); 143if (!_messageQueue.TryAdd(new LogMessage(timestamp, message), millisecondsTimeout: 0, cancellationToken: _cancellationTokenSource.Token))
Microsoft.Extensions.Logging.EventSource (1)
LoggingEventSource.cs (1)
389return new CancellationChangeToken(cts.Token);
Microsoft.Extensions.ML (2)
ModelLoaders\UriModelLoader.cs (1)
77cancellation = CancellationTokenSource.CreateLinkedTokenSource(_stopping.Token);
ModelReloadToken.cs (1)
42public IDisposable RegisterChangeCallback(Action<object> callback, object state) => _cts.Token.Register(callback, state);
Microsoft.Extensions.Primitives (2)
CompositeChangeToken.cs (2)
58return _cancellationTokenSource.Token.Register(callback, state); 66if (_cancellationTokenSource != null && _cancellationTokenSource.Token.IsCancellationRequested)
Microsoft.Extensions.ServiceDiscovery (2)
ServiceEndpointWatcher.cs (2)
80var disposalToken = _disposalCancellation.Token; 132var cancellationToken = _disposalCancellation.Token;
Microsoft.Extensions.ServiceDiscovery.Dns (6)
DnsServiceEndpointProviderBase.cs (3)
43_lastChangeToken = new CancellationChangeToken(cancellation.Token); 58protected CancellationToken ShutdownToken => _disposeCancellation.Token; 133_lastChangeToken = new CancellationChangeToken(cancellation.Token);
Resolver\DnsResolver.cs (3)
472return await SendQueryToServerAsync(serverEndPoint, name, dnsSafeName, queryType, attempt, cts.Token).ConfigureAwait(false); 479Debug.Assert(cts.Token.IsCancellationRequested); 882CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, pendingRequestsCts.Token);
Microsoft.Extensions.ServiceDiscovery.Dns.Tests (4)
Resolver\CancellationTests.cs (4)
21var ex = await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await Resolver.ResolveIPAddressesAsync("example.com", AddressFamily.InterNetwork, cts.Token)); 23Assert.Equal(cts.Token, ex.CancellationToken); 31var task = Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await Resolver.ResolveIPAddressesAsync("example.com", AddressFamily.InterNetwork, cts.Token)); 40Assert.Equal(cts.Token, ex.CancellationToken);
Microsoft.Extensions.ServiceDiscovery.Tests (7)
ServiceEndpointResolverTests.cs (7)
90collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 93if (cts[0].Token.IsCancellationRequested) 142collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 145if (cts[0].Token.IsCancellationRequested) 178collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 181if (cts[0].Token.IsCancellationRequested) 230collection.AddChangeToken(new CancellationChangeToken(cts[0].Token));
Microsoft.Extensions.TimeProvider.Testing.Tests (5)
FakeTimeProviderTests.cs (5)
318var delay = timeProvider.Delay(_infiniteTimeout, cs.Token); 334var task = fakeTimeProvider.Delay(TimeSpan.FromMilliseconds(10000), cancellationTokenSource.Token); 340Assert.False(cancellationTokenSource.Token.IsCancellationRequested); 351await Assert.ThrowsAsync<TaskCanceledException>(() => timeProvider.Delay(TimeSpan.FromTicks(1), cts.Token)); 433var t = source.Task.WaitAsync(_infiniteTimeout, timeProvider, cts.Token);
Microsoft.JSInterop (7)
JSObjectReferenceExtensions.cs (3)
98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 166var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
JSRuntime.cs (1)
117return await InvokeAsync<TValue>(targetInstanceId, identifier, callType, cts.Token, args);
JSRuntimeExtensions.cs (3)
98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 166var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
Microsoft.JSInterop.Tests (4)
Infrastructure\DotNetDispatcherTest.cs (2)
327var task = jsRuntime.InvokeAsync<TestDTO>("unimportant", cts.Token); 390var task = jsRuntime.InvokeAsync<TestDTO>("unimportant", cts.Token);
JSRuntimeTest.cs (2)
77var task = runtime.InvokeAsync<object>("test identifier 1", cts.Token, new object[] { "arg1", 123, true }); 94var task = runtime.InvokeAsync<object>("test identifier 1", cts.Token, new object[] { "arg1", 123, true });
Microsoft.Maui (1)
ImageSources\ImageSourceServiceResultManager.cs (1)
30 _sourceCancellation?.Token ?? default;
Microsoft.Maui.Controls (2)
StreamImageSource.cs (1)
43 stream = await Stream(CancellationTokenSource.Token);
UriImageSource.cs (1)
65 stream = await GetStreamAsync(Uri, CancellationTokenSource.Token);
Microsoft.Maui.Essentials (1)
Types\Shared\Utils.shared.cs (1)
31 return cancelTokenSrc.Token;
Microsoft.Maui.Resizetizer (1)
AsyncTask.cs (1)
41 public CancellationToken CancellationToken => cts.Token;
Microsoft.ML.AutoML (3)
AutoMLExperiment\AutoMLExperiment.cs (2)
254var stopTrialManager = new CancellationTokenStopTrainingManager(trialCancellationTokenSource.Token, null); 273var trialResult = await runner.RunAsync(trialSettings, trialCancellationTokenSource.Token);
AutoMLExperiment\IStopTrainingManager.cs (1)
68_cancellationTokenTrainingStopManager = new CancellationTokenStopTrainingManager(_cts.Token, channel);
Microsoft.ML.AutoML.Tests (5)
AutoMLExperimentTests.cs (3)
57var runExperimentAction = async () => await experiment.RunAsync(cts.Token); 143var res = await experiment.RunAsync(cts.Token); 176var res = await experiment.RunAsync(cts.Token);
StopTrainingManagerTests.cs (2)
29var manager = new CancellationTokenStopTrainingManager(cts.Token, null); 74var cancellationManager = new CancellationTokenStopTrainingManager(cts.Token, null);
Microsoft.ML.Core (2)
Utilities\ResourceManagerUtils.cs (1)
160var t = Task.Run(() => DownloadResource(env, ch, client, new Uri(url), filePath, fileName, downloadCancel.Token));
Utilities\ThreadUtils.cs (1)
192public CancellationToken Token => _ctSource.Token;
Microsoft.ML.Maml (1)
MAML.cs (1)
65var progressTrackerTask = Task.Run(() => TrackProgress(env, progressCancel.Token));
Microsoft.ML.Sweeper (1)
AsyncSweeper.cs (1)
282return await _paramChannel.Reader.ReadAsync(_cts.Token);
Microsoft.VisualBasic.Forms (2)
Microsoft\VisualBasic\ApplicationServices\WindowsFormsApplicationBase.vb (2)
1069cancellationToken:=tokenSource.Token) 1083cancellationToken:=tokenSource.Token).ConfigureAwait(continueOnCapturedContext:=False)
Microsoft.VisualBasic.Forms.Tests (2)
System\Windows\Forms\SingleInstanceHelpersTests.vb (2)
59cancellationToken:=tokenSource.Token) 64cancellationToken:=tokenSource.Token) _
Microsoft.VisualBasic.Tests (1)
Microsoft\VisualBasic\ApplicationServices\SingleInstanceTests.cs (1)
62var awaitable = SendSecondInstanceArgsAsync(pipeName, args, tokenSource.Token).ConfigureAwait(false);
Microsoft.VisualStudio.IntegrationTest.Setup (2)
AsyncCompletionTracker.cs (2)
60var item = await ((ISelectedItemProvider)e.CompletionSession).GetSelectedItemAsync(GetSelectedItemOptions.WaitForContextAndComputation, cancellationSource.Token); 62}, cancellationSource.Token);
Microsoft.VisualStudio.LanguageServices (18)
CallHierarchy\Finders\AbstractCallFinder.cs (1)
68await SearchAsync(workspace, searchScope, callback, _cancellationSource.Token).ConfigureAwait(false);
FindReferences\Contexts\AbstractTableDataSourceFindUsagesContext.cs (2)
167CancellationTokenSource.Token); 179CancellationTokenSource.Token);
FindReferences\StreamingFindUsagesPresenter.cs (1)
203return (context, context.CancellationTokenSource!.Token);
KeybindingReset\KeybindingResetDetector.cs (1)
164var cancellationToken = _cancellationTokenSource.Token;
MoveStaticMembers\VisualStudioMoveStaticMembersOptionsService.cs (3)
107var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationTokenSource.Token); 109var existingTypes = selectedType.ContainingNamespace.GetAllTypes(cancellationTokenSource.Token).ToImmutableArray(); 128cancellationTokenSource.Token);
PdbSourceDocument\PdbSourceDocumentOutputWindowLogger.cs (1)
47_cancellationTokenSource.Token);
ProjectSystem\RuleSets\VisualStudioRuleSetManager.RuleSetFile.cs (1)
42_disposalToken = _disposalCancellationSource.Token;
PullMemberUp\VisualStudioPullMemberUpService.cs (2)
62cancellationTokenSource.Token); 63var memberToDependentsMap = SymbolDependentsBuilder.FindMemberToDependentsMap(membersInType, document.Project, cancellationTokenSource.Token);
Remote\VisualStudioWorkspaceServiceHubConnector.cs (2)
41_checksumUpdater = new SolutionChecksumUpdater(workspace, _listenerProvider, _disposalCancellationSource.Token); 45_remoteClientInitializationTask = service.TryGetRemoteHostClientAsync(_disposalCancellationSource.Token);
Workspace\SourceGeneratedFileManager.cs (4)
294_cancellationTokenSource.Token); 456if (await oldProject.GetDependentVersionAsync(_cancellationTokenSource.Token).ConfigureAwait(false) != 457await newProject.GetDependentVersionAsync(_cancellationTokenSource.Token).ConfigureAwait(false)) 466var cancellationToken = _cancellationTokenSource.Token;
Microsoft.VisualStudio.LanguageServices.CodeLens (2)
ReferenceCodeLensProvider.cs (2)
99await Task.Delay(TimeSpan.FromSeconds(1.5), _cancellationTokenSource.Token).ConfigureAwait(false); 111_cancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.VisualStudio.LanguageServices.CSharp (2)
SemanticSearch\SemanticSearchPresenterController.cs (1)
33await executor.ExecuteAsync(query, queryDocument: null, workspace.CurrentSolution, queryCancellationSource.Token).ConfigureAwait(false);
SemanticSearch\SemanticSearchToolWindowImpl.cs (1)
391_ = ExecuteAsync(cancellationSource.Token).ReportNonFatalErrorAsync().CompletesAsyncOperation(completionToken);
Microsoft.VisualStudio.LanguageServices.UnitTests (13)
SymbolSearch\SymbolSearchUpdateEngineTests.vb (13)
46Await service.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 74Await service.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 111Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 153Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 187Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 234Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 276Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 324Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 383Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 427Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 480Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 539Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token) 594Await searchService.UpdateContinuouslyAsync(PackageSourceHelper.NugetOrgSourceName, "TestDirectory", cancellationTokenSource.Token)
MSBuild (3)
XMake.cs (3)
283s_buildCancellationSource.Token) == ExitType.Success) ? 0 : 1); 3475RarNodeShutdownReason rarShutdownReason = rarNode.Run(out nodeException, s_buildCancellationSource.Token); 4577replayEventSource.Replay(binaryLogFilePath, s_buildCancellationSource.Token);
Nats.Backend (1)
Program.cs (1)
29await foreach (var msg in nats.SubscribeAsync<AppEvent>("events.>", cancellationToken: _cts.Token).ConfigureAwait(false))
RazorBuildWebSite (2)
UpdateableFileProvider.cs (2)
69return new CancellationChangeToken(_pagesTokenSource.Token); 87ChangeToken = new CancellationChangeToken(TokenSource.Token);
Replay (2)
src\Compilers\Shared\BuildServerConnection.cs (2)
300var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 301var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Roslyn.Diagnostics.Analyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
Roslyn.VisualStudio.DiagnosticsWindow (4)
OptionPages\ForceLowMemoryMode.cs (4)
91_cancellationTokenSource.Token.ThrowIfCancellationRequested(); 114_cancellationTokenSource.Token.ThrowIfCancellationRequested(); 121_cancellationTokenSource.Token.ThrowIfCancellationRequested(); 139await Task.Delay(MonitorDelay, _cancellationTokenSource.Token).ConfigureAwait(false);
Roslyn.VisualStudio.Next.UnitTests (3)
Services\ServiceHubServicesTests.cs (1)
166cancellationTokenSource.Token);
Services\VisualStudioDiagnosticAnalyzerExecutorTests.cs (2)
123var task = Task.Run(() => AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType, isHostAnalyzer: false, source.Token)); 138Assert.True(ex is OperationCanceledException, $"cancellationToken : {source.Token.IsCancellationRequested}/r/n{ex}");
RunTests (3)
Program.cs (3)
75result = await RunCoreAsync(options, cts.Token); 79result = await RunAsync(options, cts.Token); 102var runTask = RunAsync(options, cts.Token);
Sockets.FunctionalTests (1)
src\Servers\Kestrel\test\FunctionalTests\Http2\ShutdownTests.cs (1)
203var stopServerTask = server.StopAsync(cts.Token).DefaultTimeout();
Stress.AppHost (1)
TestResource.cs (1)
74while (await timer.WaitForNextTickAsync(_tokenSource.Token))
System.Collections.Concurrent (9)
System\Collections\Concurrent\BlockingCollection.cs (9)
418cancellationToken, _producersCancellationTokenSource.Token); 419waitForSemaphoreWasSuccessful = _freeNodes.Wait(millisecondsTimeout, linkedTokenSource.Token); 667linkedTokenSource ??= CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _consumersCancellationTokenSource.Token); 668waitForSemaphoreWasSuccessful = _occupiedNodes.Wait(millisecondsTimeout, linkedTokenSource.Token); 984handles.Add(linkedTokenSource.Token.WaitHandle); // add the combined token to the handles list 1064tokensList.Add(c._producersCancellationTokenSource.Token); 1076tokensList.Add(collections[i]._consumersCancellationTokenSource.Token); 1386handles.Add(linkedTokenSource.Token.WaitHandle); // add the combined token to the handles list 1619using CancellationTokenSource linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _consumersCancellationTokenSource.Token);
System.Data.Odbc (1)
Common\System\Data\ProviderBase\DbConnectionFactory.cs (1)
89}, cancellationTokenSource.Token, TaskContinuationOptions.LongRunning, TaskScheduler.Default)!;
System.Diagnostics.DiagnosticSource (3)
System\Diagnostics\Metrics\AggregationManager.cs (3)
257cancelToken = _cts.Token; 263while (!_cts.Token.IsCancellationRequested) 291CancellationToken cancelToken = _cts.Token;
System.Diagnostics.Process (2)
System\Diagnostics\AsyncStreamReader.cs (1)
97int bytesRead = await _stream.ReadAsync(new Memory<byte>(_byteBuffer), _cts.Token).ConfigureAwait(false);
System\Diagnostics\ProcessWaitState.Unix.cs (1)
466(cts = new CancellationTokenSource(remainingTimeout)).Token;
System.IO.FileSystem.Watcher (1)
System\IO\FileSystemWatcher.Linux.cs (1)
66IncludeSubdirectories, NotifyFilter, cancellation.Token);
System.IO.Pipelines (7)
System\IO\Pipelines\StreamPipeReader.cs (6)
262await reader.InnerStream.ReadAsync(Memory<byte>.Empty, tokenSource.Token).ConfigureAwait(false); 271int length = await reader.InnerStream.ReadAsync(buffer, tokenSource.Token).ConfigureAwait(false); 339FlushResult flushResult = await destination.WriteAsync(segment.Memory.Slice(segmentIndex), tokenSource.Token).ConfigureAwait(false); 370await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false); 410await destination.WriteAsync(segment.Memory.Slice(segmentIndex), tokenSource.Token).ConfigureAwait(false); 431await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false);
System\IO\Pipelines\StreamPipeWriter.cs (1)
313CancellationToken localToken = InternalTokenSource.Token;
System.IO.Pipes (2)
System\IO\Pipes\NamedPipeServerStream.Unix.cs (2)
83CancellationTokenSource linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_internalTokenSource.Token, cancellationToken); 86acceptedSocket = await _instance!.ListeningSocket.AcceptAsync(linkedTokenSource.Token).ConfigureAwait(false);
System.IO.Ports (2)
System\IO\Ports\SerialStream.Unix.cs (2)
427Task<int> t = ReadAsync(array, offset, count, cts?.Token ?? CancellationToken.None); 564Task t = WriteAsync(array, offset, count, cts?.Token ?? CancellationToken.None);
System.Linq.Parallel (2)
System\Linq\Parallel\QueryOperators\QuerySettings.cs (1)
154CancellationTokenSource.CreateLinkedTokenSource(settings.CancellationState.InternalCancellationTokenSource.Token, settings.CancellationState.ExternalCancellationToken);
System\Linq\Parallel\Scheduling\CancellationState.cs (1)
37return MergedCancellationTokenSource.Token;
System.Net.Http (38)
System\Net\Http\HttpClient.cs (13)
188response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 207using Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 210await responseStream.CopyToAsync(buffer, cts.Token).ConfigureAwait(false); 260response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 283using Stream responseStream = c.TryReadAsStream() ?? await c.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 286await responseStream.CopyToAsync(buffer, cts.Token).ConfigureAwait(false); 334response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 468response = base.Send(request, cts.Token); 480response.Content.LoadIntoBuffer(_maxResponseContentBufferSize, cts.Token); 523response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 535await response.Content.LoadIntoBufferAsync(_maxResponseContentBufferSize, cts.Token).ConfigureAwait(false); 614e = toThrow = CancellationHelper.CreateOperationCanceledException(e, cancellationToken.IsCancellationRequested ? cancellationToken : cts.Token); 798CancellationTokenSource cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, pendingRequestsCts.Token);
System\Net\Http\SocketsHttpHandler\ChunkedEncodingReadStream.cs (1)
512ctr = cts.Token.Register(static s => ((HttpConnection)s!).Dispose(), _connection);
System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http1.cs (2)
265connection = await CreateHttp11ConnectionAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false); 269connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ?
System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs (5)
187(Stream stream, TransportContext? transportContext, Activity? activity, IPEndPoint? remoteEndPoint) = await ConnectAsync(queueItem.Request, true, cts.Token).ConfigureAwait(false); 204connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, activity, remoteEndPoint, cts.Token).ConfigureAwait(false); 210await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, activity, remoteEndPoint, cts.Token).ConfigureAwait(false); 216connection = await ConstructHttp2ConnectionAsync(stream, queueItem.Request, activity, remoteEndPoint, cts.Token).ConfigureAwait(false); 221connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ?
System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http3.cs (3)
274QuicConnection quicConnection = await ConnectHelper.ConnectQuicAsync(queueItem.Request, new DnsEndPoint(authority.IdnHost, authority.Port), _poolManager.Settings._pooledConnectionIdleTimeout, _sslOptionsHttp3!, connection.StreamCapacityCallback, cts.Token).ConfigureAwait(false); 290connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ? 870altSvcBlocklistTimerCt = _altSvcBlocklistTimerCancellation.Token;
System\Net\Http\SocketsHttpHandler\ContentLengthReadStream.cs (1)
224ctr = cts.Token.Register(static s => ((HttpConnection)s!).Dispose(), _connection);
System\Net\Http\SocketsHttpHandler\Http2Stream.cs (7)
205sendRequestContent = await WaitFor100ContinueAsync(_requestBodyCancellationSource.Token).ConfigureAwait(false); 214ValueTask vt = _request.Content.InternalCopyToAsync(writeStream, context: null, _requestBodyCancellationSource.Token); 1271CancellationTokenRegistration linkedRegistration = cancellationToken.CanBeCanceled && cancellationToken != _requestBodyCancellationSource.Token ? 1298_creditWaiter = new CreditWaiter(_requestBodyCancellationSource.Token); 1302_creditWaiter.ResetForAwait(_requestBodyCancellationSource.Token); 1329await _connection.SendStreamDataAsync(StreamId, current, flush, _requestBodyCancellationSource.Token).ConfigureAwait(false); 1332catch (OperationCanceledException e) when (e.CancellationToken == _requestBodyCancellationSource.Token)
System\Net\Http\SocketsHttpHandler\Http3RequestStream.cs (6)
172await FlushSendBufferAsync(endStream: _request.Content == null, _requestBodyCancellationSource.Token).ConfigureAwait(false); 176? SendContentAsync(_request.Content, _requestBodyCancellationSource.Token) 181Task readResponseTask = ReadResponseAsync(_requestBodyCancellationSource.Token); 223await writesClosed.WaitAsync(_requestBodyCancellationSource.Token).ConfigureAwait(false); 248await DrainContentLength0Frames(_requestBodyCancellationSource.Token).ConfigureAwait(false); 329catch (OperationCanceledException ex) when (ex.CancellationToken == _requestBodyCancellationSource.Token || ex.CancellationToken == cancellationToken)
System.Net.Http.Json (2)
System\Net\Http\Json\HttpClientJsonExtensions.cs (2)
91return await deserializeMethod(readStream, jsonOptions, linkedCTS?.Token ?? cancellationToken).ConfigureAwait(false); 93catch (OperationCanceledException oce) when ((linkedCTS?.Token.IsCancellationRequested == true) && !cancellationToken.IsCancellationRequested)
System.Net.Mail (3)
System\Net\Mail\SmtpClient.cs (3)
428cts = CancellationTokenSource.CreateLinkedTokenSource(_pendingSendCts.Token, cancellationToken); 429cancellationToken = cts.Token; 433cancellationToken = _pendingSendCts.Token;
System.Net.Ping (3)
System\Net\NetworkInformation\Ping.cs (1)
719IPAddress address = await getAddress(getAddressArg, _timeoutOrCancellationSource.Token).ConfigureAwait(false);
System\Net\NetworkInformation\Ping.PingUtility.cs (1)
76CancellationToken timeoutOrCancellationToken = _timeoutOrCancellationSource!.Token;
System\Net\NetworkInformation\Ping.RawSocket.cs (1)
330CancellationToken timeoutOrCancellationToken = _timeoutOrCancellationSource!.Token;
System.Net.Quic (6)
System\Net\Quic\QuicConnection.cs (2)
85await connection.FinishConnectAsync(options, linkedCts.Token).ConfigureAwait(false); 147internal CancellationToken ConnectionShutdownToken => _shutdownTokenSource.Token;
System\Net\Quic\QuicListener.cs (2)
230using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token, connection.ConnectionShutdownToken); 231cancellationToken = linkedCts.Token;
System\Net\Quic\QuicStream.Stream.cs (2)
126int readLength = ReadAsync(new Memory<byte>(rentedBuffer, 0, buffer.Length), cts?.Token ?? default).AsTask().GetAwaiter().GetResult(); 187WriteAsync(buffer.ToArray(), cts?.Token ?? default).AsTask().GetAwaiter().GetResult();
System.Net.Requests (2)
System\Net\HttpWebRequest.cs (2)
1256_httpClient.SendAsync(_sendRequestMessage, completionOption, _sendRequestCts.Token) : 1257Task.FromResult(_httpClient.Send(_sendRequestMessage, completionOption, _sendRequestCts.Token));
System.Net.Security (1)
src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)
66Task<byte[]?> task = s_downloadBytes(uri, cts?.Token ?? default, async);
System.Net.Sockets (1)
System\Net\Sockets\SocketAsyncEventArgs.cs (1)
686CancellationToken cancellationToken = _multipleConnectCancellation?.Token ?? default;
System.Net.WebSockets (1)
System\Net\WebSockets\WebSocketStream.cs (1)
268ct = cts.Token;
System.Net.WebSockets.Client (4)
System\Net\WebSockets\WebSocketHandle.Managed.cs (4)
117CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _abortSource.Token); 128? client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, externalAndAbortCancellation.Token) 129: invoker.SendAsync(request, externalAndAbortCancellation.Token); 131externalAndAbortCancellation.Token.ThrowIfCancellationRequested(); // poll in case sends/receives in request/response didn't observe cancellation
System.Private.CoreLib (4)
src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipeEventDispatcher.Threads.cs (1)
18m_dispatchTask = Task.Factory.StartNew(() => DispatchEventsToEventListeners(sessionID, syncTimeUtc, syncTimeQPC, timeQPCFrequency, previousDispatchTask, m_dispatchTaskCancellationSource.Token), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
src\libraries\System.Private.CoreLib\src\System\IO\File.cs (1)
1640while ((line = await sr.ReadLineAsync(cts.Token).ConfigureAwait(false)) is not null)
src\libraries\System.Private.CoreLib\src\System\Threading\CancellationToken.cs (1)
19/// <see cref="CancellationTokenSource.Token">Token</see> property.
src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (1)
16/// the source's <see cref="Token">Token</see> property) that can be handed to operations that wish to be
System.Security.Cryptography (1)
src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (1)
66Task<byte[]?> task = s_downloadBytes(uri, cts?.Token ?? default, async);
System.Threading.Tasks.Dataflow (5)
Base\DataflowBlock.cs (5)
1070if (target._cts.Token.CanBeCanceled) 1072target._cts.Token.Register( 2009return Common.CreateTaskFromCancellation<int>(cts.Token); 2014var target = new ChooseTarget<T>(boxedCompleted, cts.Token); 2402}, this, Canceler.Token, Common.GetContinuationOptions(TaskContinuationOptions.ExecuteSynchronously), TaskScheduler.Default);
System.Threading.Tasks.Parallel (4)
System\Threading\Tasks\Parallel.ForEachAsync.cs (4)
156await state.LoopBody(element, state.Cancellation.Token); 301await state.LoopBody(element, state.Cancellation.Token); 456await state.LoopBody(element, state.Cancellation.Token); 718Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException(SR.Parallel_ForEach_NullEnumerator);
System.Windows.Forms.Tests (1)
System\Windows\Forms\ToolStripTests.cs (1)
7317await Assert.ThrowsAsync<TaskCanceledException>(() => Task.Delay(SystemInformation.MouseHoverTime * 2, cancellationTokenSource.Token));
Templates.Blazor.Tests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Templates.Blazor.WebAssembly.Auth.Tests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Templates.Blazor.WebAssembly.Tests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Templates.Mvc.Tests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Templates.Tests (2)
src\Shared\Process\ProcessEx.cs (2)
63_processTimeoutCts.Token.Register(() => 97public IEnumerable<string> OutputLinesAsEnumerable => _stdoutLines.GetConsumingEnumerable(_stdoutLinesCancellationSource.Token);
Test.Utilities (3)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
Text.Analyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\RoslynParallel.NetFramework.cs (3)
167await state.LoopBody(element, state.Cancellation.Token); 332await state.LoopBody(element, state.Cancellation.Token); 622Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
vbc (2)
src\Compilers\Shared\BuildServerConnection.cs (2)
300var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 301var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
VBCSCompiler (8)
src\Compilers\Server\VBCSCompiler\BuildServerController.cs (2)
56? RunShutdown(pipeName, cancellationToken: cancellationTokenSource.Token) 57: RunServer(pipeName, cancellationToken: cancellationTokenSource.Token);
src\Compilers\Server\VBCSCompiler\ClientConnectionHandler.cs (1)
117var compilationTask = ProcessCompilationRequestCoreAsync(CompilerServerHost, request, buildCancellationTokenSource.Token);
src\Compilers\Server\VBCSCompiler\NamedPipeClientConnection.cs (1)
74await BuildServerConnection.MonitorDisconnectAsync(Stream, request.RequestId, Logger, DisconnectCancellationTokenSource.Token).ConfigureAwait(false);
src\Compilers\Server\VBCSCompiler\NamedPipeClientConnectionHost.cs (2)
73var task = Task.Run(() => ListenCoreAsync(PipeName, Logger, _queue, _cancellationTokenSource.Token)); 145var listenResult = await _queue.DequeueAsync(_cancellationTokenSource.Token).ConfigureAwait(false);
src\Compilers\Shared\BuildServerConnection.cs (2)
300var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 301var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
VBCSCompiler.UnitTests (2)
BuildClientTests.cs (1)
150var connection = tryConnectToNamedPipe(Timeout.Infinite, cts.Token);
ServerUtil.cs (1)
102cancellationToken: cts.Token);
Wasm.Performance.Driver (2)
Program.cs (2)
48stressRunCancellation = new CancellationTokenSource(stressRunDuration).Token; 90using var registration = runCancellationToken.Token.Register(async () =>