1949 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 (15)
Backchannel\AuxiliaryBackchannelMonitor.cs (2)
140using var combined = CancellationTokenSource.CreateLinkedTokenSource(stoppingToken, timeout.Token); 142var command = await executionContext.CommandSelected.Task.WaitAsync(combined.Token).ConfigureAwait(false);
Backchannel\ExtensionBackchannel.cs (1)
92var cancellationTask = Task.Delay(Timeout.Infinite, linkedCts.Token);
NuGet\NuGetPackagePrefetcher.cs (2)
78using var combined = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeout.Token); 80var command = await executionContext.CommandSelected.Task.WaitAsync(combined.Token);
Program.cs (2)
589await DisplayFirstTimeUseNoticeIfNeededAsync(app.Services, args, cts.Token); 631var exitCode = await parseResult.InvokeAsync(invokeConfig, cts.Token);
Utils\CliDownloader.cs (2)
177using var response = await s_httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cts.Token); 181await response.Content.CopyToAsync(fileStream, cts.Token);
Utils\EnvironmentChecker\ContainerRuntimeCheck.cs (4)
119versionOutput = await versionProcess.StandardOutput.ReadToEndAsync(versionTimeoutCts.Token); 120await versionProcess.WaitForExitAsync(versionTimeoutCts.Token); 269await psProcess.WaitForExitAsync(psTimeoutCts.Token); 476await process.WaitForExitAsync(timeoutCts.Token);
Utils\EnvironmentChecker\DeprecatedWorkloadCheck.cs (2)
50output = await process.StandardOutput.ReadToEndAsync(timeoutCts.Token); 51await process.WaitForExitAsync(timeoutCts.Token);
Aspire.Cli.Tests (34)
Agents\AgentEnvironmentApplicatorTests.cs (2)
41await applicator.ApplyAsync(cts.Token).DefaultTimeout(); 43Assert.Equal(cts.Token, receivedToken);
Commands\AgentMcpCommandTests.cs (18)
72await _agentMcpCommand.ExecuteCommandAsync(parseResult, _cts.Token); 78}, _cts.Token); 81_mcpClient = await _testTransport.CreateClientAsync(_loggerFactory, _cts.Token); 123var tools = await _mcpClient.ListToolsAsync(cancellationToken: _cts.Token).DefaultTimeout(); 197await _mcpClient.CallToolAsync(KnownMcpTools.RefreshTools, cancellationToken: _cts.Token).DefaultTimeout(); 200var tools = await _mcpClient.ListToolsAsync(cancellationToken: _cts.Token).DefaultTimeout(); 272await _mcpClient.CallToolAsync(KnownMcpTools.RefreshTools, cancellationToken: _cts.Token).DefaultTimeout(); 277cancellationToken: _cts.Token).DefaultTimeout(); 345await _mcpClient.CallToolAsync(KnownMcpTools.RefreshTools, cancellationToken: _cts.Token).DefaultTimeout(); 348var result = await _mcpClient.CallToolAsync("db1_mcp_list_schemas", cancellationToken: _cts.Token).DefaultTimeout(); 363cancellationToken: _cts.Token).DefaultTimeout(); 392cancellationToken: _cts.Token).DefaultTimeout(); 408var notification = await notificationChannel.Reader.ReadAsync(_cts.Token).AsTask().DefaultTimeout(); 466var tools = await _mcpClient.ListToolsAsync(cancellationToken: _cts.Token).DefaultTimeout(); 487await notificationChannel.Reader.ReadAsync(timeoutCts.Token); 544var tools1 = await _mcpClient.ListToolsAsync(cancellationToken: _cts.Token).DefaultTimeout(); 545var tools2 = await _mcpClient.ListToolsAsync(cancellationToken: _cts.Token).DefaultTimeout(); 566cancellationToken: _cts.Token).DefaultTimeout());
Commands\RunCommandTests.cs (11)
322var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 377var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 547var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 617var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 687var pendingRun = result.InvokeAsync(cancellationToken: cts.Token); 751var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 810var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 869var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 928var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 1346var exitCode = await result.InvokeAsync(cancellationToken: cts.Token).DefaultTimeout(); 1416var pendingRun = result.InvokeAsync(cancellationToken: cts.Token);
Mcp\Docs\DocsFetcherTests.cs (1)
208var result = await fetcher.FetchDocsAsync(cts.Token);
Mcp\Docs\DocsIndexServiceTests.cs (1)
608() => service.EnsureIndexedAsync(cts.Token).AsTask());
Mcp\Docs\LlmsTxtParserTests.cs (1)
386async () => await LlmsTxtParser.ParseAsync(content, cts.Token));
Aspire.Components.Common.TestUtilities (1)
ActivityNotifier.cs (1)
22await foreach (var activity in WaitAsync(cts.Token))
Aspire.Dashboard (63)
Components\Controls\ApplicationName.razor.cs (1)
34await DashboardClient.WhenConnected.WaitAsync(_disposalCts.Token);
Components\Controls\AssistantChat.razor.cs (2)
139await _module.InvokeVoidAsync("scrollToBottomChatAssistant", _cts.Token, scrollOptions); 291catch (Exception ex) when (_cts.Token.IsCancellationRequested)
Components\Controls\Chart\ChartBase.cs (1)
66CancellationToken = _cts.Token;
Components\Controls\SpanDetails.razor.cs (1)
221_cts.Token).ConfigureAwait(false);
Components\Dialogs\ExemplarsDialog.razor.cs (1)
45_cts.Token).ConfigureAwait(false);
Components\Dialogs\ManageDataDialog.razor.cs (3)
155var (snapshot, subscription) = await DashboardClient.SubscribeResourcesAsync(_cts.Token); 170await foreach (var changes in subscription.WithCancellation(_cts.Token).ConfigureAwait(false)) 603using var memoryStream = await TelemetryExportService.ExportSelectedAsync(selectedResources, _cts.Token);
Components\Interactions\InteractionsProvider.cs (11)
57await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 140await waitForInteractionAvailableTask.WaitAsync(_cts.Token).ConfigureAwait(false); 144await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 191await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 244await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 265await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false); 295await currentDialogReference.Result.WaitAsync(_cts.Token); 297await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 338var interactions = DashboardClient.SubscribeInteractionsAsync(_cts.Token); 341await _semaphore.WaitAsync(_cts.Token).ConfigureAwait(false); 467await DashboardClient.SendInteractionRequestAsync(request, _cts.Token).ConfigureAwait(false);
Components\Pages\ConsoleLogs.razor.cs (3)
44public CancellationToken CancellationToken => _cts.Token; 53_cts.Token.Register(static state => 184_resourceSubscriptionToken = _resourceSubscriptionCts.Token;
Components\Pages\Resources.razor.cs (2)
295var (snapshot, subscription) = await DashboardClient.SubscribeResourcesAsync(_watchTaskCancellationTokenSource.Token); 310await foreach (var changes in subscription.WithCancellation(_watchTaskCancellationTokenSource.Token).ConfigureAwait(false))
Mcp\AspireResourceMcpTools.cs (1)
103await foreach (var entry in _dashboardClient.GetConsoleLogs(resourceName, subscribeConsoleLogsCts.Token).ConfigureAwait(false))
Model\Assistant\AIHelpers.cs (3)
311messageCts.Token.Register(responseCts.Cancel); 317var response = client.GetStreamingResponseAsync(chatMessages, chatOptions, responseCts.Token); 320await foreach (var update in response.WithCancellation(responseCts.Token).ConfigureAwait(false))
Model\Assistant\AssistantChatDataContext.cs (1)
261await foreach (var entry in _dashboardClient.GetConsoleLogs(resourceName, subscribeConsoleLogsCts.Token).ConfigureAwait(false))
Model\Assistant\AssistantChatViewModel.cs (11)
286await callback(_cts.Token).ConfigureAwait(false); 343var getInfoTask = _aiContextProvider.GetInfoAsync(_cts.Token); 423await callback(_cts.Token).ConfigureAwait(false); 482: CancellationTokenSource.CreateLinkedTokenSource(_cts.Token); 495catch (Exception ex) when (currentResponseCts.Token.IsCancellationRequested) 508var cancellationToken = responseCts.Token; 751conversationChangedTask = InvokeConversationChangedCallbackAsync(chatViewModel: null, _responseState, responseCts.Token); 772conversationChangedTask = InvokeConversationChangedCallbackAsync(chatViewModel: null, _responseState, responseCts.Token); 855await InvokeConversationChangedCallbackAsync(vm, ResponseState.Starting, _cts.Token).ConfigureAwait(false); 867await InvokeConversationChangedCallbackAsync(chatViewModel, ResponseState.Starting, _cts.Token).ConfigureAwait(false); 944await InvokeConversationChangedCallbackAsync(currentChatViewModel, ResponseState.Starting, _cts.Token).ConfigureAwait(false);
Model\DashboardCommandExecutor.cs (1)
132closeToastCts.Token.Register(() =>
Model\ResourceOutgoingPeerResolver.cs (2)
36var (snapshot, subscription) = await resourceService.SubscribeResourcesAsync(_watchContainersTokenSource.Token).ConfigureAwait(false); 49await foreach (var changes in subscription.WithCancellation(_watchContainersTokenSource.Token).ConfigureAwait(false))
Model\TraceLinkHelpers.cs (2)
80await Task.Delay(TimeSpan.FromSeconds(0.5), cts.Token).ConfigureAwait(false); 83}, cts.Token);
ServiceClient\DashboardClient.cs (15)
89_clientCancellationToken = _cts.Token; 454using var call = _client!.WatchInteractions(headers: _headers, cancellationToken: cts.Token); 469await foreach (var update in _incomingInteractionChannel.Reader.ReadAllAsync(cts.Token).ConfigureAwait(false)) 484}, cts.Token); 489await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: cts.Token).ConfigureAwait(false)) 601await _initialDataReceivedTcs.Task.WaitAsync(cts.Token).ConfigureAwait(false); 615Subscription: StreamUpdatesAsync(cts.Token)); 658return StreamUpdatesAsync(_pendingInteractionCollection.ToList(), cts.Token); 693cancellationToken: combinedTokens.Token); 704await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: combinedTokens.Token).ConfigureAwait(false)) 714}, combinedTokens.Token); 716await foreach (var batch in channel.Reader.ReadAllAsync(combinedTokens.Token).ConfigureAwait(false)) 733cancellationToken: combinedTokens.Token); 735await foreach (var response in call.ResponseStream.ReadAllAsync(cancellationToken: combinedTokens.Token).ConfigureAwait(false)) 769var 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 (22)
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))
Integration\TelemetryApiTests.cs (2)
437var response = await httpClient.GetAsync("/api/telemetry/spans?follow=true", HttpCompletionOption.ResponseHeadersRead, cts.Token).DefaultTimeout(); 468var response = await httpClient.GetAsync("/api/telemetry/logs?follow=true", HttpCompletionOption.ResponseHeadersRead, cts.Token).DefaultTimeout();
Model\DashboardClientTests.cs (2)
57await foreach (var item in subscription.WithCancellation(cts.Token)) 168await foreach (var item in subscription.WithCancellation(cts.Token))
TelemetryApiServiceTests.cs (4)
54await foreach (var item in service.FollowSpansAsync(null, null, null, cts.Token)) 101await foreach (var item in service.FollowLogsAsync(null, null, null, cts.Token)) 350await foreach (var item in service.FollowSpansAsync(["nonexistent-service"], null, null, cts.Token)) 397await foreach (var item in service.FollowLogsAsync(["nonexistent-service"], null, null, cts.Token))
TelemetryRepositoryTests\TelemetryRepositoryTests.cs (10)
394await foreach (var span in repository.WatchSpansAsync(resourceKey: null, cts.Token)) 456await foreach (var span in repository.WatchSpansAsync(resourceKey: null, cts.Token)) 512await foreach (var log in repository.WatchLogsAsync(resourceKey: null, filters: null, cts.Token)) 573await foreach (var log in repository.WatchLogsAsync(resourceKey: null, filters: null, cts.Token)) 659using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, doneCts.Token); 665await foreach (var span in repository.WatchSpansAsync(resourceKey: null, linkedCts.Token)) 733await foreach (var span in repository.WatchSpansAsync(new ResourceKey("service1", "inst1"), cts.Token)) 792await foreach (var log in repository.WatchLogsAsync(resourceKey: null, filters: filters, cts.Token)) 883await foreach (var log in repository.WatchLogsAsync(resourceKey: null, filters: filters, cts.Token))
Aspire.Deployment.EndToEnd.Tests (52)
AcaCompactNamingDeploymentTests.cs (2)
30cts.Token, TestContext.Current.CancellationToken); 32await DeployWithCompactNamingFixesStorageCollisionCore(linkedCts.Token);
AcaCompactNamingUpgradeDeploymentTests.cs (2)
29cts.Token, TestContext.Current.CancellationToken); 31await UpgradeFromGaToDevDoesNotDuplicateStorageAccountsCore(linkedCts.Token);
AcaCustomRegistryDeploymentTests.cs (2)
26cts.Token, TestContext.Current.CancellationToken); 27var cancellationToken = linkedCts.Token;
AcaDeploymentErrorOutputTests.cs (2)
32cts.Token, TestContext.Current.CancellationToken); 34await DeployWithInvalidLocation_ErrorOutputIsCleanCore(linkedCts.Token);
AcaExistingRegistryDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AcaManagedRedisDeploymentTests.cs (2)
26cts.Token, TestContext.Current.CancellationToken); 27var cancellationToken = linkedCts.Token;
AcaStarterDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AcrPurgeTaskDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AksStarterDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
AksStarterWithRedisDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AppServicePythonDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AppServiceReactDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureAppConfigDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureContainerRegistryDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureEventHubsDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureKeyVaultDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureLogAnalyticsDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureServiceBusDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
AzureStorageDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
PythonFastApiDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
VnetKeyVaultConnectivityDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
VnetKeyVaultInfraDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
VnetSqlServerConnectivityDeploymentTests.cs (2)
25cts.Token, TestContext.Current.CancellationToken); 26var cancellationToken = linkedCts.Token;
VnetSqlServerInfraDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
VnetStorageBlobConnectivityDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
VnetStorageBlobInfraDeploymentTests.cs (2)
24cts.Token, TestContext.Current.CancellationToken); 25var cancellationToken = linkedCts.Token;
Aspire.EndToEnd.Tests (3)
tests\Shared\TemplatesTesting\AspireProject.cs (2)
369await WaitForDashboardToBeAvailableAsync(dashboardUrlToUse, _testOutput, cts.Token).ConfigureAwait(false); 394}, cts.Token).ConfigureAwait(false);
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
Aspire.Hosting (73)
ApplicationModel\ResourceLoggerService.cs (3)
229using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_disposing.Token, cancellationToken); 248await foreach (var entry in channel.Reader.ReadAllAsync(linkedCts.Token).ConfigureAwait(false)) 438using var _ = _logStreamCts.Token.Register(() => channel.Writer.TryComplete());
ApplicationModel\ResourceNotificationService.cs (2)
474using var watchCts = CancellationTokenSource.CreateLinkedTokenSource(_disposing.Token, cancellationToken); 475var watchToken = watchCts.Token;
Backchannel\AppHostRpcTarget.cs (7)
27using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 28var linkedToken = linkedCts.Token; 62using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 63var linkedToken = linkedCts.Token; 73catch (OperationCanceledException) when (_shutdownCts.Token.IsCancellationRequested) 93using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 94var linkedToken = linkedCts.Token;
Backchannel\AuxiliaryBackchannelRpcTarget.cs (7)
251using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 257"healthy" => await WaitForHealthyAsync(notificationService, request.ResourceName, linkedCts.Token).ConfigureAwait(false), 258"up" => await WaitForRunningAsync(notificationService, request.ResourceName, linkedCts.Token).ConfigureAwait(false), 259"down" => await WaitForTerminalAsync(notificationService, request.ResourceName, linkedCts.Token).ConfigureAwait(false), 873using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token); 877var mcpClient = await McpClient.CreateAsync(transport, cancellationToken: linked.Token).ConfigureAwait(false); 880var toolsList = await mcpClient.ListToolsAsync(cancellationToken: linked.Token).ConfigureAwait(false);
Dashboard\DashboardEventHandlers.cs (1)
85_dashboardLogsTask = WatchDashboardLogsAsync(_dashboardLogsCts.Token);
Dashboard\DashboardService.cs (8)
75await foreach (var interaction in updates.WithCancellation(cts.Token).ConfigureAwait(false)) 176await responseStream.WriteAsync(change, cts.Token).ConfigureAwait(false); 187}, cts.Token); 192await foreach (var request in requestStream.ReadAllAsync(cts.Token).ConfigureAwait(false)) 194await serviceData.SendInteractionRequestAsync(request, cts.Token).ConfigureAwait(false); 385await execute(cts.Token).ConfigureAwait(false); 387catch (OperationCanceledException) when (cts.Token.IsCancellationRequested) 391catch (IOException) when (cts.Token.IsCancellationRequested)
Dashboard\DashboardServiceData.cs (6)
33_resourcePublisher = new ResourcePublisher(_cts.Token); 36var cancellationToken = _cts.Token; 133using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 135await foreach (var item in sequence.WithCancellation(linked.Token).ConfigureAwait(false)) 150using var linked = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _cts.Token); 152await 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)
362await StopAsync(disposeCts.Token).ConfigureAwait(false); 369var cancellationToken = _shutdownCancellation.Token; 528await _executorEvents.PublishAsync(new OnResourceChangedContext(_shutdownCancellation.Token, resourceType, appModelResource, resource.Metadata.Name, status, s => snapshotFactory(resource, s))).ConfigureAwait(false); 725await foreach (var batch in enumerable.WithCancellation(cancellation.Token).ConfigureAwait(false)) 743cancellation.Token); 798await _executorEvents.PublishAsync(new OnResourceChangedContext(_shutdownCancellation.Token, resourceKind, appModelResource, resourceName, status, s => 1617_shutdownCancellation.Token, resourceType, resource, 2041await _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 (8)
100await Task.Delay(TimeSpan.FromSeconds(2), timeoutCancellation.Token).ConfigureAwait(false); 101dcpInfo = await _dependencyCheckService.GetDcpInfoAsync(force: true, cancellationToken: timeoutCancellation.Token).ConfigureAwait(false); 266var acceptedSocket = await socket.AcceptAsync(_shutdownCts.Token).ConfigureAwait(false); 267outputLoggers.Add(Task.Run(() => LogSocketOutputAsync(acceptedSocket, _shutdownCts.Token))); 405var notificationCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, _shutdownCts.Token); 413var notificationTask = _interactionService.PromptNotificationAsync(title, message, options, notificationCts.Token); 417while (await timer.WaitForNextTickAsync(notificationCts.Token).ConfigureAwait(false)) 421var dcpInfo = await _dependencyCheckService.GetDcpInfoAsync(force: true, cancellationToken: notificationCts.Token).ConfigureAwait(false);
Dcp\DcpKubernetesClient.cs (3)
54cancellationToken = cts.Token; 94cancellationToken = cts.Token; 120cancellationToken = cts.Token;
Dcp\ResourceLogSource.cs (1)
35cancellationToken = ownedCts.Token;
Devcontainers\DevcontainerSettingsWriter.cs (3)
63_processingTask = Task.Run(ProcessPortUpdatesAsync, _processingCancellation.Token); 72while (await reader.WaitToReadAsync(_processingCancellation.Token).ConfigureAwait(false)) 83await WriteSettingsAsync(batch, _processingCancellation.Token).ConfigureAwait(false);
Health\ResourceHealthCheckService.cs (1)
328public CancellationToken CancellationToken => _cts.Token;
IInteractionService.cs (1)
165var currentToken = _currentCts.Token;
InteractionService.cs (4)
89var newState = new Interaction(title, message, options, new Interaction.MessageBoxInteractionInfo(intent: options.Intent ?? MessageIntent.None), interactionCts.Token); 162var newState = new Interaction(title, message, options, new Interaction.InputsInteractionInfo(inputCollection), interactionCts.Token); 202var refreshOptions = new QueueLoadOptions(_logger, interactionCts.Token, input, inputCollection, _serviceProvider); 230var newState = new Interaction(title, message, options, new Interaction.NotificationInteractionInfo(intent: options.Intent ?? MessageIntent.None, linkText: options.LinkText, linkUrl: options.LinkUrl), interactionCts.Token);
Orchestrator\ApplicationOrchestrator.cs (2)
97var waitForDependenciesTask = _notificationService.WaitForDependenciesAsync(@event.Resource, cts.Token); 109cts.Token);
Orchestrator\ParameterProcessor.cs (1)
81await HandleUnresolvedParametersAsync(_unresolvedParameters, cts.Token).ConfigureAwait(false);
Pipelines\DistributedApplicationPipeline.cs (1)
597context.CancellationToken = linkedCts.Token;
Pipelines\PipelineActivityReporter.cs (1)
29_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.Kusto.Tests (24)
KustoFunctionalTests.cs (24)
47using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 53await app.StartAsync(cts.Token); 56await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cancellationToken: cts.Token); 60hb.Configuration["ConnectionStrings:KustoConnection"] = await kusto.Resource.ConnectionStringExpression.GetValueAsync(cts.Token); 70await host.StartAsync(cts.Token); 74var result = await _resiliencePipeline.ExecuteAsync(async cancellationToken => await ExecuteQueryAsync(client, cancellationToken), cts.Token); 97using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 105await app.StartAsync(cts.Token); 108await rns.WaitForResourceHealthyAsync(kustoDb.Resource.Name, cancellationToken: cts.Token); 112hb.Configuration["ConnectionStrings:KustoTestDbConnection"] = await kustoDb.Resource.ConnectionStringExpression.GetValueAsync(cts.Token); 128await host.StartAsync(cts.Token); 131await _resiliencePipeline.ExecuteAsync(async cancellationToken => await SeedDataAsync(admin), cts.Token); 135var results = await _resiliencePipeline.ExecuteAsync(async cancellationToken => await ReadDataAsync(client, cancellationToken), cts.Token); 175using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 185await app.StartAsync(cts.Token); 188await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cts.Token); 202using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 212await app.StartAsync(cts.Token); 215await rns.WaitForResourceHealthyAsync(kusto.Resource.Name, cts.Token); 218await rns.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 219await rns.WaitForResourceAsync(db2.Resource.Name, KnownResourceStates.FailedToStart, cts.Token); 233using var cts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, TestContext.Current.CancellationToken); 251await app.StartAsync(cts.Token); 254await rns.WaitForResourceHealthyAsync(kustoDb.Resource.Name, cts.Token);
Aspire.Hosting.Azure.Tests (72)
AzureAIFoundryExtensionsTests.cs (2)
87await app.StartAsync(cts.Token); 92await rns.WaitForResourceAsync(resource.Name, [KnownResourceStates.FailedToStart, KnownResourceStates.Running], cts.Token);
AzureBicepProvisionerTests.cs (3)
66await app.StartAsync(cts.Token); 69await 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); 129}, cts.Token); 171await app.StartAsync(cts.Token); 174await rns.WaitForResourceHealthyAsync(cosmos1.Resource.Name, cts.Token); 201}, cts.Token); 219await app.StartAsync(cts.Token); 222await rns.WaitForResourceHealthyAsync(cosmos2.Resource.Name, cts.Token); 256}, cts.Token); 289await app.StartAsync(cts.Token); 292await rns.WaitForResourceHealthyAsync(cosmos.Resource.Name, cts.Token); 301await host.StartAsync(cts.Token); 306var result1 = await database.ReadAsync(cancellationToken: cts.Token); 309var result2 = await container.ReadContainerAsync(cancellationToken: cts.Token);
AzureDeployerTests.cs (1)
1643var runTask = Task.Run(() => app.RunAsync(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)
94var pendingStart = app.StartAsync(cts.Token); 96await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 98await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 102await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 104await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 137await rns.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 138await rns.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 143await sender.SendMessageAsync(new ServiceBusMessage("Hello, World!"), cts.Token); 146var message = await receiver.ReceiveMessageAsync(cancellationToken: cts.Token); 814await app.ResourceNotifications.WaitForResourceAsync(serviceBus.Resource.Name, KnownResourceStates.Running, cts.Token); 815await app.ResourceNotifications.WaitForResourceHealthyAsync(serviceBus.Resource.Name, cts.Token); 823await sender.SendMessageAsync(new ServiceBusMessage("Hello, World!"), cts.Token); 826var 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 (20)
45var pendingStart = app.StartAsync(cts.Token); 49await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 51await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 55await rns.WaitForResourceHealthyAsync(blobs.Resource.Name, cts.Token); 56await rns.WaitForResourceHealthyAsync(queues.Resource.Name, cts.Token); 57await rns.WaitForResourceHealthyAsync(tables.Resource.Name, cts.Token); 59await 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); 133var pendingStart = app.StartAsync(cts.Token); 137await rns.WaitForResourceAsync(storage.Resource.Name, KnownResourceStates.Running, cts.Token); 139await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 143await rns.WaitForResourceHealthyAsync(testQueue.Resource.Name, cts.Token); 145await rns.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 191await rns.WaitForResourceHealthyAsync(storage.Resource.Name, cts.Token); 223await rns.WaitForResourceHealthyAsync(blobContainer.Resource.Name, cancellationToken: cts.Token); 263await rns.WaitForResourceHealthyAsync(queue.Resource.Name, cancellationToken: cts.Token);
DefaultUserPrincipalProviderTests.cs (1)
76() => provider.GetUserPrincipalAsync(cts.Token));
Aspire.Hosting.Containers.Tests (1)
DockerSocketBindMountTests.cs (1)
43cts.Token);
Aspire.Hosting.DevTunnels (1)
src\Shared\CoalescingAsyncOperation.cs (1)
45current = _runningTask = ExecuteWrapperAsync(_cts.Token);
Aspire.Hosting.DotnetTool.Tests (6)
DotnetToolFunctionalTests.cs.cs (6)
21await app.StartAsync(cts.Token); 23await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 24var terminalState = await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.TerminalStates, cts.Token); 44await app.StartAsync(cts.Token); 46await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 47var terminalState = await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.TerminalStates, cts.Token);
Aspire.Hosting.Garnet.Tests (7)
GarnetFunctionalTests.cs (7)
38var pendingStart = app.StartAsync(cts.Token); 40await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 42await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 46await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 48await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 95}, cts.Token); 177}, cts.Token);
Aspire.Hosting.GitHub.Models.Tests (5)
GitHubModelsFunctionalTests.cs (5)
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);
Aspire.Hosting.JavaScript.Tests (4)
NodeAppFixture.cs (2)
43await _app.StartAsync(cts.Token); 45await WaitReadyStateAsync(cts.Token);
NodeFunctionalTests.cs (2)
26var response = await nodeClient.GetStringAsync("/", cts.Token); 38var response = await npmClient.GetStringAsync("/", cts.Token);
Aspire.Hosting.Kafka.Tests (4)
KafkaFunctionalTests.cs (4)
100}, cts.Token); 106var result = consumer.Consume(cts.Token); 189}, cts.Token); 242var result = consumer.Consume(cts.Token);
Aspire.Hosting.MongoDB.Tests (10)
MongoDbFunctionalTests.cs (10)
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); 99}, cts.Token); 163}, cts.Token); 218}, cts.Token); 332}, cts.Token); 423}, cts.Token);
Aspire.Hosting.MySql.Tests (68)
MySqlFunctionalTests.cs (68)
47var pendingStart = app.StartAsync(cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 55await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 57await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 61await app.StopAsync(cts.Token); 82await app.StartAsync(cts.Token); 84await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 98await host.StartAsync(cts.Token); 109}, cts.Token); 157await app.StartAsync(cts.Token); 159await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 175await host.StartAsync(cts.Token); 183}, cts.Token); 200}, cts.Token); 206await app.StopAsync(cts.Token); 227await app.StartAsync(cts.Token); 229await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 238[$"ConnectionStrings:{db2.Resource.Name}"] = await db2.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 245await host.StartAsync(cts.Token); 253}, cts.Token); 265}, cts.Token); 272await app.StopAsync(cts.Token); 333await app.StartAsync(cts.Token); 335await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 341[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 348await host.StartAsync(cts.Token); 356}, cts.Token); 370}, cts.Token); 419await app.StartAsync(cts.Token); 421await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 427[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 434await host.StartAsync(cts.Token); 442}, cts.Token); 456}, cts.Token); 489await app.StartAsync(cts.Token); 491await app.WaitForTextAsync(s_mySqlReadyText, cts.Token).WaitAsync(cts.Token); 498[$"ConnectionStrings:{db.Resource.Name}"] = await db.Resource.ConnectionStringExpression.GetValueAsync(cts.Token) 505await host.StartAsync(cts.Token); 513}, cts.Token); 521}, cts.Token); 528}, cts.Token); 536}, cts.Token); 580await app.StartAsync(cts.Token); 584var mySqlId = await GetContainerIdAsync(rns, "resource", cts.Token); 590mySqlId2 = await GetContainerIdAsync(rns, "resource2", cts.Token); 593var phpMyAdminId = await GetContainerIdAsync(rns, "phpmyadmin", cts.Token);; 595await app.StopAsync(cts.Token).WaitAsync(cts.Token); 651await app.StartAsync(cts.Token); 664await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 681}, cts.Token); 727await app.StartAsync(cts.Token); 740await app.ResourceNotifications.WaitForResourceHealthyAsync(mysql.Resource.Name, cts.Token); 753}, cts.Token); 755await app.StopAsync(cts.Token); 785await app.StartAsync(cts.Token); 802await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 808await conn.OpenAsync(cts.Token); 831await app.StartAsync(cts.Token); 841await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 847await conn.OpenAsync(cts.Token);
Aspire.Hosting.Nats.Tests (5)
NatsFunctionalTests.cs (5)
345var pendingStart = app.StartAsync(cts.Token); 347await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 349await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 353await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 355await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.OpenAI (3)
OpenAIHealthCheck.cs (3)
72resp = await client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, cts.Token).ConfigureAwait(false); 90using var stream = await resp.Content.ReadAsStreamAsync(cts.Token).ConfigureAwait(false); 91using var doc = await JsonDocument.ParseAsync(stream, cancellationToken: cts.Token).ConfigureAwait(false);
Aspire.Hosting.OpenAI.Tests (10)
OpenAIFunctionalTests.cs (10)
41var pendingStart = app.StartAsync(cts.Token); 43await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 45await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 49await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 88var pendingStart = app.StartAsync(cts.Token); 90await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 92await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 96await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 98await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Oracle.Tests (23)
OracleFunctionalTests.cs (23)
44await app.StartAsync(cts.Token); 46await 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); 130await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 148await dbContext.Database.EnsureCreatedAsync(cts.Token); 152await dbContext.SaveChangesAsync(cts.Token); 161}, cts.Token); 191await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 208var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 218}, cts.Token); 301await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 321}, cts.Token); 323var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 398await app.WaitForTextAsync(DatabaseReadyText, cancellationToken: cts.Token); 418}, cts.Token); 420var brands = await dbContext.Cars.ToListAsync(cancellationToken: cts.Token); 463var pendingStart = app.StartAsync(cts.Token); 465await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 467await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 471await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 473await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.PostgreSQL.Tests (31)
PostgresFunctionalTests.cs (31)
128await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token); 140}, cts.Token); 233await app.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 266}, cts.Token); 296await app.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 326}, cts.Token); 409await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 417}, cts.Token); 431}, cts.Token); 495await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 503}, cts.Token); 517}, cts.Token); 562await app.StartAsync(cts.Token); 566var postgresId = await GetContainerIdAsync(rns, "resource", cts.Token); 568var pgWebId = await GetContainerIdAsync(rns, "pgweb", cts.Token); 570var pgadminId = await GetContainerIdAsync(rns, "pgadmin", cts.Token); 572await app.StopAsync(cts.Token).WaitAsync(TimeSpan.FromMinutes(1), cts.Token); 609await app.StartAsync(cts.Token); 622await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 628await conn.OpenAsync(cts.Token); 651await app.StartAsync(cts.Token); 664await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 670await conn.OpenAsync(cts.Token); 721await app.StartAsync(cts.Token); 734await app.ResourceNotifications.WaitForResourceHealthyAsync(postgres.Resource.Name, cts.Token); 747}, cts.Token); 749await app.StopAsync(cts.Token); 779await app.StartAsync(cts.Token); 796await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 802await conn.OpenAsync(cts.Token);
Aspire.Hosting.Qdrant.Tests (8)
QdrantFunctionalTests.cs (8)
63}, cts.Token); 145}, cts.Token); 193}, cts.Token); 274var pendingStart = app.StartAsync(cts.Token); 276await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 278await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 282await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, (re => re.Snapshot.HealthStatus == HealthStatus.Healthy), cts.Token); 284await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Redis.Tests (16)
RedisFunctionalTests.cs (16)
49var pendingStart = app.StartAsync(cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 53await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 57await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 59await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 152await rns.WaitForResourceAsync(redisInsightBuilder.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 157await AcceptRedisInsightEula(client, cts.Token); 159var response = await client.GetAsync("/api/databases", cts.Token); 162var databases = await response.Content.ReadFromJsonAsync<List<RedisInsightDatabaseModel>>(cts.Token); 190var testConnectionResponse = await client.GetAsync($"/api/databases/{db.Id}/connect", cts2.Token); 489await rns.WaitForResourceAsync(redisInsightBuilder1.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 494await AcceptRedisInsightEula(httpClient, cts.Token); 524await rns.WaitForResourceAsync(redisInsightBuilder2.Resource.Name, KnownResourceStates.Running).WaitAsync(cts.Token); 529await EnsureRedisInsightEulaAccepted(httpClient, cts.Token); 627await app.ResourceNotifications.WaitForResourceHealthyAsync(redis.Resource.Name, cts.Token); 628await app.ResourceNotifications.WaitForResourceHealthyAsync(redisCommander.Name, cts.Token);
Aspire.Hosting.RemoteHost.Tests (2)
CallbackProxyTests.cs (1)
171await proxy("test", cts.Token);
CancellationTokenRegistryTests.cs (1)
40var (_, token) = registry.CreateLinked(cts.Token);
Aspire.Hosting.SqlServer.Tests (32)
SqlServerFunctionalTests.cs (32)
41var pendingStart = app.StartAsync(cts.Token); 43await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 45await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 49await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 51await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token); 76await 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); 181await app1.ResourceNotifications.WaitForResourceHealthyAsync(db1.Resource.Name, cts.Token); 220}, cts.Token); 240}, cts.Token); 267await app2.ResourceNotifications.WaitForResourceHealthyAsync(db2.Resource.Name, cts.Token); 294}, cts.Token); 300using var results = await command.ExecuteReaderAsync(cts.Token); 302Assert.True(await results.ReadAsync(cts.Token)); 304Assert.False(await results.ReadAsync(cts.Token)); 368await app.StartAsync(cts.Token); 381await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 399}, cts.Token); 422await app.StartAsync(cts.Token); 433await host.StartAsync(cts.Token); 435await app.ResourceNotifications.WaitForResourceHealthyAsync(newDb.Resource.Name, cts.Token); 449}, cts.Token); 495await app.StartAsync(cts.Token); 508await app.ResourceNotifications.WaitForResourceHealthyAsync(sqlserver.Resource.Name, cts.Token); 522}, cts.Token); 524await app.StopAsync(cts.Token); 554await app.StartAsync(cts.Token); 571await app.ResourceNotifications.WaitForResourceHealthyAsync(db.Resource.Name, cts.Token); 577await 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)
162ApplicationStarted = _startedCts.Token; 163ApplicationStopping = _stoppingCts.Token; 164ApplicationStopped = _stoppedCts.Token;
TestingBuilderTests.cs (21)
462genericEntryPoint ? DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>([$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token) 463: DistributedApplicationTestingBuilder.CreateAsync(typeof(Projects.TestingAppHost1_AppHost), [$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token)); 470? await DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>([$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token) 471: await DistributedApplicationTestingBuilder.CreateAsync(typeof(Projects.TestingAppHost1_AppHost), [$"--crash-{crashArg}"], cts.Token).WaitAsync(cts.Token); 476using var app = await builder.BuildAsync().WaitAsync(cts.Token); 481var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => app.StartAsync().WaitAsync(cts.Token)); 486await app.StartAsync().WaitAsync(cts.Token); 490await app.DisposeAsync().AsTask().WaitAsync(cts.Token); 505using var builder = await DistributedApplicationTestingBuilder.CreateAsync<Projects.TestingAppHost1_AppHost>(["--add-unknown-container"], cts.Token).WaitAsync(cts.Token); 507await using var app = await builder.BuildAsync(cts.Token).WaitAsync(cts.Token); 528cts.Token).WaitAsync(cts.Token); 545app = await builder.BuildAsync(cts.Token).WaitAsync(cts.Token); 554await 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 (173)
ApplicationModel\McpServerEndpointAnnotationTests.cs (1)
175() => annotation.EndpointUrlResolver(resource, cts.Token));
Backchannel\AuxiliaryBackchannelRpcTargetTests.cs (1)
388await foreach (var logLine in target.GetResourceLogsAsync("myresource", follow: true, cts.Token))
Backchannel\AuxiliaryBackchannelTests.cs (1)
421await Task.Delay(Timeout.Infinite, lifetime.ApplicationStopping).WaitAsync(cts.Token);
Backchannel\Exec\ExecTestsBase.cs (2)
29var outputStream = appHostRpcTarget.ExecAsync(cts.Token); 32var startTask = app.StartAsync(cts.Token);
Codespaces\CodespacesUrlRewriterTests.cs (6)
33await app.StartAsync(abortToken.Token); 39while (!abortToken.Token.IsCancellationRequested) 51await app.StopAsync(abortToken.Token); 69await app.StartAsync(abortToken.Token); 86abortToken.Token); 98await app.StopAsync(abortToken.Token);
Dashboard\DashboardServiceTests.cs (6)
182var context = TestServerCallContext.Create(cancellationToken: cts.Token); 237var context = TestServerCallContext.Create(cancellationToken: cts.Token); 307var context = TestServerCallContext.Create(cancellationToken: cts.Token); 354var context = TestServerCallContext.Create(cancellationToken: cts.Token); 413var context = TestServerCallContext.Create(cancellationToken: cts.Token); 450var 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)
633var watchLogsEnumerator = watchLogs.GetAsyncEnumerator(watchCts.Token); 1346await appExecutor.RunApplicationAsync(tokenSource.Token);
Dcp\DcpHostNotificationTests.cs (8)
91var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 144await interactionService.Interactions.Reader.ReadAsync(cts.Token); 199await interactionService.Interactions.Reader.ReadAsync(cts.Token); 250var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 301var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 323using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(interaction.CancellationToken, testTimeoutCts.Token)) 325await Assert.ThrowsAsync<TaskCanceledException>(() => Task.Delay(-1, linkedCts.Token)); 368var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token);
DistributedApplicationTests.cs (18)
71await testProgram.RunAsync(cts.Token); 116await testProgram.RunAsync(cts.Token); 141var token = cts.Token; 186var token = cts.Token; 276var token = cts.Token; 320var token = cts.Token; 395var token = cts.Token; 474var token = cts.Token; 1078var token = cts.Token; 1116var token = cts.Token; 1561var token = cts.Token; 1843var token = cts.Token; 1859using var logStream = await kubernetes.GetLogStreamAsync(worker, Logs.StreamTypeStdOut, logCts.Token, follow: true, timestamps: true); 1861await EnsureLogLines(logStream, logCts.Token, minimumLines); 1872using var logStream = await kubernetes.GetLogStreamAsync(worker, Logs.StreamTypeStdOut, logCts.Token, 1877await EnsureLogLines(logStream, logCts.Token, limit, (long n) => expectedLineNumber++ == n); 1885using var logStream = await kubernetes.GetLogStreamAsync(worker, Logs.StreamTypeStdOut, logCts.Token, 1891await EnsureLogLines(logStream, logCts.Token, tail, (long n) => n >= minimumLineNumber++);
EndpointReferenceTests.cs (1)
174var getValueTask = endpointExpr.GetValueAsync(cts.Token);
Health\ResourceHealthCheckServiceTests.cs (11)
227await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 233await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, abortTokenSource.Token).DefaultTimeout(); 242await app.StopAsync(abortTokenSource.Token).TimeoutAfter(TestConstants.LongTimeoutTimeSpan); 268await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 285await app.StopAsync(abortTokenSource.Token).DefaultTimeout(); 311await app.StartAsync(abortTokenSource.Token).DefaultTimeout(); 317await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, abortTokenSource.Token).DefaultTimeout(); 319var firstCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 322var secondCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 325var thirdCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 327await app.StopAsync(abortTokenSource.Token).DefaultTimeout();
InteractionServiceTests.cs (1)
51var resultTask = interactionService.PromptConfirmationAsync("Are you sure?", "Confirmation", cancellationToken: cts.Token);
Publishing\ResourceContainerImageManagerTests.cs (27)
39await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 71await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 102await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 139await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 173await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 203await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 239await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 278await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 313await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 345await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 376await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 426await imageBuilder.BuildImageAsync(servicea.Resource, cts.Token); 455await imageBuilder.PushImageAsync(testResource.Resource, cts.Token); 480imageBuilder.PushImageAsync(testResource.Resource, cts.Token)); 515await imageBuilder.BuildImagesAsync([servicea.Resource], cts.Token); 544await imageBuilder.BuildImagesAsync([dockerfileResource.Resource], cts.Token); 576await imageBuilder.BuildImagesAsync([dockerfileResource.Resource], cts.Token); 613imageBuilder.BuildImagesAsync([container.Resource], cts.Token)); 658await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 731await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 826await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 878await imageBuilder.BuildImageAsync(container.Resource, cts.Token); 1225await imageManager.BuildImagesAsync([servicea.Resource], cts.Token); 1269() => imageManager.BuildImagesAsync([servicea.Resource], cts.Token)); 1302() => imageManager.BuildImageAsync(container.Resource, cts.Token)); 1345() => imageManager.BuildImagesAsync([servicea.Resource, serviceb.Resource], cts.Token)); 1378() => imageManager.BuildImagesAsync([servicea.Resource], cts.Token));
ResourceNotificationTests.cs (10)
73await foreach (var item in notificationService.WatchAsync(cts.Token)) 113var enumerableTask = GetValuesAsync(cts.Token); 166var enumerableTask = GetValuesAsync(cts.Token); 223var waitTask = notificationService.WaitForResourceAsync("MYreSouRCe1", "sOmeSTAtE", cts.Token); 315var waitTask = notificationService.WaitForResourceAsync("myResource1", "SomeState", cts.Token); 347var waitTask = notificationService.WaitForResourceAsync("myResource1", "SomeState", cts.Token); 508var enumerableTask = GetValuesAsync(cts.Token); 560var enumerableTask = GetFirstValueAsync(cts.Token); 596var enumerableTask = GetFirstValueAsync(cts.Token); 738ApplicationStopping = _stoppingCts.Token;
SlimTestProgramTests.cs (3)
30await EnsureServicesAreRunning(testProgram, cts.Token); 55await EnsureServicesAreRunning(testProgram, cts.Token); 74await EnsureServicesAreRunning(testProgram, cts.Token);
TestProgramFixture.cs (2)
34await _app.StartAsync(cts.Token); 36await 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))
ValueSnapshotTests.cs (2)
182var getTask = snapshot.GetValueAsync(cts.Token); 194var cancelledTask = snapshot.GetValueAsync(cts.Token);
WaitForTests.cs (51)
31await app.StartAsync(abortCts.Token); 33await app.ResourceNotifications.WaitForResourceAsync(throwingResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 34await app.ResourceNotifications.WaitForResourceAsync(dependingContainerResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 35await app.ResourceNotifications.WaitForResourceAsync(dependingExecutableResource.Resource.Name, KnownResourceStates.FailedToStart, abortCts.Token); 37await app.StopAsync(abortCts.Token); 105var startTask = app.StartAsync(startupCts.Token); 108await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 136var startTask = app.StartAsync(startupCts.Token); 139await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 169var startTask = app.StartAsync(startupCts.Token); 176await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 213var startTask = app.StartAsync(startupCts.Token); 217await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 224await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token); 324var startTask = app.StartAsync(startupCts.Token); 328await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 335await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, waitingStateCts.Token); 358var startTask = app.StartAsync(startupCts.Token); 362await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 369await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 377await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 405var startTask = app.StartAsync(startupCts.Token); 409await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 416await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 424await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 447var startTask = app.StartAsync(startupCts.Token); 454await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 469await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token); 494var startTask = app.StartAsync(startupCts.Token); 501await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token); 516await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 549var startTask = app.StartAsync(startupCts.Token); 556await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "Waiting", waitingStateCts.Token); 572await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 603var startTask = app.StartAsync(startupCts.Token); 610await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 624await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.FailedToStart, runningStateCts.Token); 654var startTask = app.StartAsync(startupCts.Token); 661await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 669await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 677await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 707var startTask = app.StartAsync(startupCts.Token); 714await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 722await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 730await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 756var startTask = app.StartAsync(startupCts.Token); 763await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 771await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, waitingStateCts.Token); 871var startTask = app.StartAsync(startupCts.Token); 875await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Waiting, waitingStateCts.Token); 885await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.Running, runningStateCts.Token);
WithUrlsTests.cs (8)
389cts.Token); 416cts.Token); 449cts.Token); 480await foreach (var notification in rns.WatchAsync(cts.Token)) 498await rns.WaitForResourceAsync(servicea.Resource.Name, KnownResourceStates.Running, cts.Token); 598await foreach (var notification in rns.WatchAsync(cts.Token)) 616await rns.WaitForResourceAsync(custom.Resource.Name, KnownResourceStates.Running, cts.Token); 679cts.Token);
Aspire.Hosting.Valkey.Tests (5)
ValkeyFunctionalTests.cs (5)
223var pendingStart = app.StartAsync(cts.Token); 225await app.ResourceNotifications.WaitForResourceAsync(resource.Resource.Name, KnownResourceStates.Running, cts.Token); 227await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Waiting, cts.Token); 231await app.ResourceNotifications.WaitForResourceHealthyAsync(resource.Resource.Name, cts.Token); 233await app.ResourceNotifications.WaitForResourceAsync(dependentResource.Resource.Name, KnownResourceStates.Running, cts.Token);
Aspire.Hosting.Yarp.Tests (2)
YarpFunctionalTests.cs (2)
49await app.ResourceNotifications.WaitForResourceHealthyAsync(backend.Resource.Name, cts.Token); 50await app.ResourceNotifications.WaitForResourceHealthyAsync(yarp.Resource.Name, cts.Token);
Aspire.MongoDB.Driver.Tests (1)
ConformanceTests.cs (1)
113service.ListDatabases(source.Token);
Aspire.MongoDB.Driver.v2.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)
369await WaitForDashboardToBeAvailableAsync(dashboardUrlToUse, _testOutput, cts.Token).ConfigureAwait(false); 394}, cts.Token).ConfigureAwait(false);
tests\Shared\TemplatesTesting\ToolCommand.cs (1)
91return await ExecuteAsyncInternal(resolvedCommand, fullArgs, cts.Token);
aspire-server (6)
CancellationTokenRegistry.cs (5)
38return (id, cts.Token); 60return (id, cts.Token); 112token = cts.Token; 133return existing.Token; 147return added.Token;
JsonRpcCallbackInvoker.cs (1)
46cts.Token).ConfigureAwait(false);
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)
305var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 306var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
CustomResources.AppHost (1)
TestResource.cs (1)
60while (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)
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.Tests (2)
ClientDisconnectTests.cs (2)
156await ctx.Response.Body.WriteAsync(data, cancellationTokenSource.Token); 195var 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);
Infrastructure.Tests (3)
ExtractTestPartitions\ExtractTestPartitionsFixture.cs (1)
39await process.WaitForExitAsync(cts.Token);
ExtractTestPartitions\ExtractTestPartitionsTests.cs (1)
339await process.WaitForExitAsync(cts.Token);
PowerShellScripts\PowerShellCommand.cs (1)
65return await ExecuteAsyncInternal(cts.Token, args);
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)
1032ConnectionClosedRequested = ConnectionClosingCts.Token; 1033ConnectionClosed = ConnectionClosedCts.Token;
TestTransport\InMemoryTransportConnection.cs (1)
38ConnectionClosed = _connectionClosedTokenSource.Token;
InProcessWebSite (2)
Startup.cs (1)
1015await server.StopAsync(cts.Token);
Startup.WebSockets.cs (1)
129await Echo(ws, cts.Token);
IntegrationTestsWebsite (1)
Infrastructure\DynamicEndpointDataSource.cs (1)
28_cct = new CancellationChangeToken(_cts.Token);
Interop.FunctionalTests (7)
Http3\Http3RequestTests.cs (3)
495var responseTask = client.SendAsync(request, cts.Token); 734var responseTask = client.SendAsync(request, cts.Token); 930var responseTask1 = client.SendAsync(request1, cts1.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\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
Metrics.Legacy (7)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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),
Microsoft.Agents.AI.ProjectTemplates.Tests (2)
test\ProjectTemplates\Infrastructure\TestCommand.cs (2)
102await exitedTcs.Task.WaitAsync(timeoutCts.Token).ConfigureAwait(false); 103await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Microsoft.AspNetCore.Components (2)
NavigationManager.cs (1)
430var cancellationToken = cts.Token;
Routing\Router.cs (1)
355var navigateContext = new NavigationContext(path, _onNavigateCts.Token);
Microsoft.AspNetCore.Components.Endpoints (3)
Builder\RazorComponentEndpointDataSource.cs (2)
60_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token); 174_changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
DependencyInjection\HotReloadService.cs (1)
25public IChangeToken GetChangeToken() => new CancellationChangeToken(_tokenSource.Token);
Microsoft.AspNetCore.Components.Endpoints.Tests (1)
HotReloadServiceTests.cs (1)
170Assert.Throws<ObjectDisposedException>(() => changeTokenSource.Token);
Microsoft.AspNetCore.Components.QuickGrid (1)
QuickGrid.razor.cs (1)
345startIndex, 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)
207validationTcs.TrySetCanceled(new CancellationTokenSource().Token);
Microsoft.AspNetCore.Components.Tests (2)
ComponentBaseTest.cs (1)
363cts.Token.ThrowIfCancellationRequested();
RendererTest.cs (1)
4130cancellationTokenSource.Token.ThrowIfCancellationRequested();
Microsoft.AspNetCore.Components.Web (4)
Forms\InputFile\BrowserFileStream.cs (2)
35OpenReadStreamTask = OpenReadStreamAsync(_openReadStreamCts.Token); 105return await stream.ReadAsync(destination, _copyFileDataCts.Token);
Media\MediaComponentBase.cs (1)
286return _loadCts.Token;
Virtualization\Virtualize.cs (1)
415cancellationToken = _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 (9)
Hosting\WebAssemblyHostTest.cs (9)
30var task = host.RunAsyncCore(cts.Token, cultureProvider); 48var task = host.RunAsyncCore(cts.Token, cultureProvider); 51var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => host.RunAsyncCore(cts.Token)); 77var task = host.RunAsyncCore(cts.Token, cultureProvider); 103var task = host.RunAsyncCore(cts.Token, cultureProvider); 112Assert.Equal(cts.Token, testHostedService.StartToken); 133var runTask = host.RunAsyncCore(cts.Token, cultureProvider); 166var runTask = host.RunAsyncCore(cts.Token, cultureProvider); 197var task = host.RunAsyncCore(cts.Token, cultureProvider);
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)
292cancellationToken = cts.Token;
WebHostExtensions.cs (3)
29await host.StopAsync(cts.Token); 56await host.WaitForTokenShutdownAsync(cts.Token); 98await host.RunAsync(cts.Token, "Application started. Press Ctrl+C to shut down.");
Microsoft.AspNetCore.Hosting.Tests (11)
HostingApplicationDiagnosticsTests.cs (4)
41timeoutTokenSource.Token.Register(() => Logger.LogError("Timeout while waiting for counter value.")); 43var totalRequestValues = eventListener.GetCounterValues("total-requests", timeoutTokenSource.Token); 44var currentRequestValues = eventListener.GetCounterValues("current-requests", timeoutTokenSource.Token); 45var failedRequestValues = eventListener.GetCounterValues("failed-requests", timeoutTokenSource.Token);
Internal\HostingEventSourceTests.cs (4)
200timeoutTokenSource.Token.Register(() => Logger.LogError("Timeout while waiting for counter value.")); 202var totalRequestValues = eventListener.GetCounterValues("total-requests", timeoutTokenSource.Token); 203var currentRequestValues = eventListener.GetCounterValues("current-requests", timeoutTokenSource.Token); 204var failedRequestValues = eventListener.GetCounterValues("failed-requests", timeoutTokenSource.Token);
WebHostTests.cs (3)
173var runInBackground = host.RunAsync(cts.Token); 228var task = host.StopAsync(cts.Token); 302var 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.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)
61_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); 502var stopTask1 = server.StopAsync(cts.Token); 503var stopTask2 = server.StopAsync(new CancellationTokenSource().Token); 504var stopTask3 = server.StopAsync(new CancellationTokenSource().Token); 538var stopTask1 = server.StopAsync(new CancellationTokenSource().Token); 539var stopTask2 = server.StopAsync(cts.Token); 540var stopTask3 = server.StopAsync(new CancellationTokenSource().Token); 575stopTask1 = server.StopAsync(new CancellationTokenSource().Token); 576stopTask2 = 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)
124hostShutdownToken: _hostShutdownToken.Token,
IISExpressDeployer.cs (1)
265return (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)
1032ConnectionClosedRequested = ConnectionClosingCts.Token; 1033ConnectionClosed = 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 (19)
HubConnection.cs (17)
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)) 922createAndConsumeStream = () => ReadAsyncEnumeratorStream(AsyncEnumerableAdapters.MakeReflectionAsyncEnumeratorFromChannel(reader, tokenSource.Token)); 929createAndConsumeStream = () => ReadAsyncEnumeratorStream(AsyncEnumerableAdapters.MakeReflectionAsyncEnumerator(reader, tokenSource.Token)); 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)
479Task<int> readTask = responseStream.ReadAsync(new byte[100], 0, 100, cts.Token);
HttpContextBuilderTests.cs (2)
324var contextTask = server.SendAsync(c => { }, cts.Token); 360var readTask = responseStream.ReadAsync(new byte[100], 0, 100, cts.Token);
TestClientTests.cs (2)
897await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await client.ConnectAsync(new Uri("http://localhost"), tokenSource.Token)); 1079var 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.Tasks.CodeAnalysis (4)
src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (2)
573cancellationToken: _sharedCompileCts.Token); 575responseTask.Wait(_sharedCompileCts.Token);
src\Compilers\Shared\BuildServerConnection.cs (2)
305var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 306var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Microsoft.Build.Tasks.CodeAnalysis.Sdk (4)
src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (2)
573cancellationToken: _sharedCompileCts.Token); 575responseTask.Wait(_sharedCompileCts.Token);
src\Compilers\Shared\BuildServerConnection.cs (2)
305var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 306var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Microsoft.CodeAnalysis (2)
CommandLine\CommonCompiler.cs (2)
1122analyzerDriver.ApplyProgrammaticSuppressions(diagnostics, compilation, analyzerCts.Token); 1533analyzerCts.Token);
Microsoft.CodeAnalysis.Analyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.AnalyzerUtilities (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.BannedApiAnalyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.CodeStyle (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.CSharp (1)
CommandLine\CSharpCommandLineParser.cs (1)
299while (!Debugger.IsAttached && !timeoutSource.Token.IsCancellationRequested)
Microsoft.CodeAnalysis.CSharp.EditorFeatures (1)
EventHookup\EventHookupSessionManager_EventHookupSession.cs (1)
94var cancellationToken = _cancellationTokenSource.Token;
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (2)
Diagnostics\DiagnosticAnalyzerTests.cs (1)
4250var diagnostics = await getDiagnosticsAsync(cancellationSource.Token).ConfigureAwait(false);
Diagnostics\DiagnosticSuppressorTests.cs (1)
679var cancellationToken = suppressor.CancellationTokenSource.Token;
Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (3)
InteractiveSessionTests.cs (3)
2049var state3 = await s3.RunAsync(globals, catchException: e => true, cancellationToken: cancellationSource.Token); 2083var state3 = await s3.RunAsync(globals, catchException: e => true, cancellationToken: cancellationSource.Token); 2118s3.RunAsync(globals, catchException: e => e is not OperationCanceledException, cancellationToken: cancellationSource.Token));
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (4)
SourceGeneration\GeneratorDriverTests.cs (2)
768driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var outputCompilation, out var outputDiagnostics, cts.Token) 2609Assert.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)
109return cancellationTokenSource.Token;
BackgroundWorkIndicator\BackgroundWorkIndicatorContext.cs (1)
75public CancellationToken UserCancellationToken => _cancellationTokenSource.Token;
Classification\Syntactic\SyntacticClassificationTaggerProvider.TagComputer.cs (1)
101_disposalCancellationSource.Token);
EditAndContinue\ActiveStatementTrackingService.cs (2)
163var cancellationToken = _cancellationSource.Token; 191var cancellationToken = _cancellationSource.Token;
GoOrFind\AbstractGoOrFindNavigationService.cs (2)
165var cancellationToken = cancellationTokenSource.Token; 223var cancellationToken = cancellationTokenSource.Token;
InlineRename\InlineRenameSession.cs (4)
300var cancellationToken = _cancellationTokenSource.Token; 463using (Logger.LogBlock(FunctionId.Rename_ApplyReplacementText, replacementText, _cancellationTokenSource.Token)) 526var cancellationToken = _conflictResolutionTaskCancellationSource.Token; 557var cancellationToken = _conflictResolutionTaskCancellationSource.Token;
InlineRename\UI\SmartRename\SmartRenameViewModel.cs (1)
187GetSuggestionsTaskAsync(isAutomaticOnInitialization, _cancellationTokenSource.Token).CompletesAsyncOperation(listenerToken);
IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (2)
155() => GetHighlightedListAndUpdatedFilters(session, itemsToBeIncluded, threadLocalPatternMatchHelper, cancellationTokenSource.Token), 156cancellationTokenSource.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)
161ResultsRequested += (_, _) => 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)
74return invoker.RunAsync().JoinUsingDispatcher(CancellationTokenSource.Token); 82}, CancellationTokenSource.Token, TaskCreationOptions.None, new SynchronizationContextTaskScheduler(sta.DispatcherSynchronizationContext));
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)
92cancellationSource.Token).ConfigureAwait(false); 121cancellationSource.Token).ConfigureAwait(false);
Microsoft.CodeAnalysis.ExternalAccess.Razor.Features (1)
Cohost\RazorStartupServiceFactory.cs (1)
72this.InitializeRazorAsync(clientCapabilities, context, _disposalTokenSource.Token).ReportNonFatalErrorAsync();
Microsoft.CodeAnalysis.Features (12)
AddImport\AbstractAddImportFeatureService.cs (5)
251linkedTokenSource.Token).ConfigureAwait(false); 253catch (OperationCanceledException ex) when (ex.CancellationToken == linkedTokenSource.Token) 308linkedTokenSource.Token).ConfigureAwait(false); 310catch (OperationCanceledException ex) when (ex.CancellationToken == linkedTokenSource.Token) 358linkedTokenSource.Token.ThrowIfCancellationRequested();
CodeFixes\Service\CodeFixService.cs (1)
123var linkedToken = linkedTokenSource.Token;
CodeLens\CodeLensFindReferenceProgress.cs (2)
43public CancellationToken CancellationToken => _aggregateCancellationTokenSource.Token; 97? GetPartialLocations(symbol, _aggregateCancellationTokenSource.Token)
CodeRefactorings\CodeRefactoringService.cs (2)
140if (cancellationToken.IsCancellationRequested || linkedTokenSource.Token.IsCancellationRequested) 148document, state, provider, linkedTokenSource.Token).ConfigureAwait(false);
ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.cs (1)
55_shutdownToken = _shutdownNotificationSource.Token;
ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingAsyncWorkItemQueue.cs (1)
237return source.Token;
Microsoft.CodeAnalysis.InteractiveHost (7)
Interactive\Core\InteractiveHost.LazyRemoteService.cs (1)
55=> _lazyInitializedService.GetValueAsync(_cancellationSource.Token);
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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)
82while (!Debugger.IsAttached && !timeoutSource.Token.IsCancellationRequested)
Microsoft.CodeAnalysis.LanguageServer.Protocol (11)
Handler\AbstractRefreshQueue.cs (1)
71_disposalTokenSource.Token);
Handler\SourceGenerators\SourceGeneratorRefreshQueue.cs (4)
50_disposalTokenSource.Token); 70.ReportNonFatalErrorUnlessCancelledAsync(_disposalTokenSource.Token); 114if (await oldProject.GetDependentVersionAsync(_disposalTokenSource.Token).ConfigureAwait(false) != 115await newProject.GetDependentVersionAsync(_disposalTokenSource.Token).ConfigureAwait(false))
Handler\WorkDoneProgress\WorkDoneProgressManager.cs (1)
102public CancellationToken CancellationToken => _cancellationTokenSource.Token;
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.LanguageServer.UnitTests (1)
Utilities\AbstractLanguageServerClientTests.TestLspClient.cs (1)
56await pipeServer.WaitForConnectionAsync(cts.Token);
Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.PublicApiAnalyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.Remote.ServiceHub (3)
Host\RemoteWorkspace.InFlightSolution.cs (1)
81return _cancellationTokenSource_doNotAccessDirectly.Token;
Services\ProcessTelemetry\RemoteProcessTelemetryService.cs (1)
66_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\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
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.Test.Utilities (2)
Diagnostics\CommonDiagnosticAnalyzers.cs (2)
2680public CancellationToken CancellationToken => _cancellationTokenSource.Token; 2922public 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.VisualBasic (1)
CommandLine\VisualBasicCommandLineParser.vb (1)
463While Not Debugger.IsAttached AndAlso Not timeoutSource.Token.IsCancellationRequested
Microsoft.CodeAnalysis.Workspaces (15)
FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (1)
52_tokenSource.Token);
Remote\IRemoteKeepAliveService.cs (4)
115session.KeepAliveTokenSource.Token).ConfigureAwait(false); 148session.KeepAliveTokenSource.Token, 155linkedTokenSource.Token).ConfigureAwait(false); 197var cancellationToken = this.KeepAliveTokenSource.Token;
Shared\TestHooks\AsynchronousOperationListener.cs (2)
48var expeditedDelayCancellationToken = _expeditedDelayCancellationTokenSource.Token; 57var 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)
191_asynchronousFileChangeProcessingCancellationTokenSource.Token);
Workspace\Workspace.cs (2)
88_workQueueTokenSource.Token); 103_updateSourceGeneratorsQueueTokenSource.Token);
Microsoft.CodeAnalysis.Workspaces.MSBuild (1)
Rpc\RpcClient.cs (1)
57while ((line = await _receivingStreamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (1)
Rpc\RpcServer.cs (1)
64while ((line = await _streamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (2)
RpcTests.cs (1)
217await Assert.ThrowsAnyAsync<OperationCanceledException>(async () => await rpcPair.Client.InvokeAsync<string>(targetObject: 0, nameof(ObjectWithHelloMethod.Hello), [], tokenSource.Token));
src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (1)
64while ((line = await _streamReader.TryReadLineOrReturnNullIfCancelledAsync(_shutdownTokenSource.Token).ConfigureAwait(false)) != null)
Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)
MEF\UseExportProviderAttribute.cs (1)
142taskJoiner.JoinUsingDispatcher(waiter, timeoutTokenSource.Token);
Microsoft.CodeAnalysis.Workspaces.UnitTests (13)
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);
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)
997using HttpResponseMessage response = await client.GetAsync(uri, HttpCompletionOption.ResponseHeadersRead, timeoutTokenSource.Token); 1000using var stream = await response.Content.ReadAsStreamAsync(timeoutTokenSource.Token); 1001await stream.CopyToAsync(fs, timeoutTokenSource.Token); 1033using 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 (17)
ChatCompletion\ChatClientExtensionsTests.cs (8)
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)) 191Assert.Equal(cts.Token, cancellationToken); 197ChatResponse response = await client.GetResponseAsync([], expectedChatOptions, cts.Token); 231Assert.Equal(cts.Token, cancellationToken); 238await foreach (var update in client.GetStreamingResponseAsync([], expectedChatOptions, cts.Token))
Contents\DataContentTests.cs (3)
776await DataContent.LoadFromAsync(tempPath, cancellationToken: cts.Token)); 802await content.SaveToAsync(tempPath, cts.Token)); 825await DataContent.LoadFromAsync(ms, cancellationToken: cts.Token));
Embeddings\DelegatingEmbeddingGeneratorTests.cs (1)
26var expectedCancellationToken = cts.Token;
Image\ImageGeneratorTests.cs (2)
58Assert.Equal(cts.Token, cancellationToken); 63var result = await generator.GenerateAsync(expectedRequest, expectedOptions, 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)
112=> client.GetTextAsync(fileStream, cancellationToken: cancellationTokenSource.Token)); 127.GetStreamingTextAsync(fileStream, cancellationToken: cancellationTokenSource.Token)
Microsoft.Extensions.AI.Templates.Tests (2)
test\ProjectTemplates\Infrastructure\TestCommand.cs (2)
102await exitedTcs.Task.WaitAsync(timeoutCts.Token).ConfigureAwait(false); 103await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
Microsoft.Extensions.AI.Tests (64)
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\FunctionInvokingChatClientApprovalsTests.cs (8)
967Assert.Equal(cts.Token, actualCancellationToken); 986var updates = service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(input), options, cts.Token); 1043Assert.Equal(cts.Token, actualCancellationToken); 1067var updates = service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(input), options, cts.Token); 1245Assert.Equal(cts.Token, actualCancellationToken); 1264var result = await service.GetResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(input), options, cts.Token); 1332Assert.Equal(cts.Token, actualCancellationToken); 1346var result = await service.GetStreamingResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(input), options, cts.Token).ToChatResponseAsync();
ChatCompletion\FunctionInvokingChatClientTests.cs (4)
2206Assert.Equal(cts.Token, actualCancellationToken); 2223var result = await service.GetResponseAsync(new EnumeratedOnceEnumerable<ChatMessage>(chat), options, cts.Token); 2275Assert.Equal(cts.Token, actualCancellationToken); 2287var 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();
ChatReduction\SummarizingChatReducerTests.cs (1)
291reducer.ReduceAsync(messages, cts.Token));
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)
195foreach (CancellationToken ctArg in new[] { cts.Token, default }) 756Assert.Equal(cts.Token, cancellationToken); 761object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 779Assert.Equal(cts.Token, cancellationToken); 784object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 802Assert.Equal(cts.Token, cancellationToken); 807object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 825Assert.Equal(cts.Token, cancellationToken); 830object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 848Assert.Equal(cts.Token, cancellationToken); 853object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 871Assert.Equal(cts.Token, cancellationToken); 876object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 894Assert.Equal(cts.Token, cancellationToken); 899object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token); 917Assert.Equal(cts.Token, cancellationToken); 923object? result = await f.InvokeAsync(new() { ["i"] = 42 }, cts.Token);
Image\ConfigureOptionsImageGeneratorTests.cs (2)
43Assert.Equal(cts.Token, cancellationToken); 67var response1 = await generator.GenerateImagesAsync("test prompt", providedOptions, 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)
144BufferChunk 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.DataIngestion.Tests (2)
Readers\DocumentReaderConformanceTests.cs (2)
43await Assert.ThrowsAsync<TaskCanceledException>(async () => await reader.ReadAsync(stream, "id", "mediaType", cts.Token)); 62await Assert.ThrowsAsync<TaskCanceledException>(async () => await reader.ReadAsync(new FileInfo(filePath), 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 (4)
TcpEndpointProbesServiceTests.cs (4)
42await tcpEndpointProbesService.StartAsync(cts.Token); 43await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 52await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token); 61await tcpEndpointProbesService.UpdateHealthStatusAsync(cts.Token);
Microsoft.Extensions.Diagnostics.Testing (2)
Logging\FakeLogCollector.LogEnumeration.cs (1)
114var mainCancellationToken = _mainCts.Token;
Metrics\MetricCollector.cs (1)
258await WaitForMeasurementsAsync(minCount, cancellationTokenSource.Token).ConfigureAwait(false);
Microsoft.Extensions.Diagnostics.Testing.Tests (2)
Logging\FakeLogCollectorTests.LogEnumeration.cs (1)
34var cancellationToken = cts.Token;
Metrics\MetricCollectorTests.cs (1)
284var wait = collector.WaitForMeasurementsAsync(1, cts.Token);
Microsoft.Extensions.FileProviders.Physical (4)
PhysicalFilesWatcher.cs (2)
171var cancellationChangeToken = new CancellationChangeToken(cancellationTokenSource.Token); 206var 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)
64.Setup(x => x.StartAsync(It.Is<CancellationToken>(y => y != tokenSource.Token))) 70await sut.StartAsync(tokenSource.Token); 83.Setup(x => x.StartAsync(It.Is<CancellationToken>(y => y != cancellationTokenSource.Token))) 90_ = sut.StartAsync(cancellationTokenSource.Token); 123.Setup(x => x.StopAsync(It.Is<CancellationToken>(y => y != tokenSource.Token))) 129await sut.StopAsync(tokenSource.Token); 143.Setup(x => x.StopAsync(It.Is<CancellationToken>(y => y != cancellationTokenSource.Token))) 150_ = 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)
66return 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)
392return 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; 130_lastChangeToken = new CancellationChangeToken(cancellation.Token);
Resolver\DnsResolver.cs (3)
470return await SendQueryToServerAsync(serverEndPoint, name, dnsSafeName, queryType, attempt, cts.Token).ConfigureAwait(false); 477Debug.Assert(cts.Token.IsCancellationRequested); 880CancellationTokenSource 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)
92collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 95if (cts[0].Token.IsCancellationRequested) 144collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 147if (cts[0].Token.IsCancellationRequested) 180collection.AddChangeToken(new CancellationChangeToken(cts[0].Token)); 183if (cts[0].Token.IsCancellationRequested) 232collection.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 (11)
JSObjectReferenceExtensions.cs (5)
98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 166var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 184var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 203var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
JSRuntime.cs (1)
117return await InvokeAsync<TValue>(targetInstanceId, identifier, callType, cts.Token, args);
JSRuntimeExtensions.cs (5)
98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 166var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 184var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 203var 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.McpServer.ProjectTemplates.Tests (2)
test\ProjectTemplates\Infrastructure\TestCommand.cs (2)
102await exitedTcs.Task.WaitAsync(timeoutCts.Token).ConfigureAwait(false); 103await process.WaitForExitAsync(timeoutCts.Token).ConfigureAwait(false);
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.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.Extensibility.Testing.Xunit (5)
src\VisualStudio\IntegrationTest\Harness\XUnitShared\Harness\IdeTestAssemblyRunner.cs (4)
207cancellationTokenSource.Token, 239var executionMessageSinkFilter = new IpcMessageSink(ExecutionMessageSink, testCases.ToDictionary<IXunitTestCase, string, ITestCase>(testCase => testCase.UniqueID, testCase => testCase), finalAttempt: true, completedTestCaseIds, cancellationTokenSource.Token); 264executionMessageSinkFilter = new IpcMessageSink(ExecutionMessageSink, knownTestCasesByUniqueId, finalAttempt, completedTestCaseIds, cancellationTokenSource.Token); 278using (var runner = visualStudioContext.Instance.TestInvoker.CreateTestAssemblyRunner(new IpcTestAssembly(TestAssembly), testCases.ToArray(), new IpcMessageSink(DiagnosticMessageSink, knownTestCasesByUniqueId, finalAttempt, new HashSet<string>(), cancellationTokenSource.Token), executionMessageSinkFilter, new IpcTestFrameworkExecutionOptions(ExecutionOptions)))
src\VisualStudio\IntegrationTest\Harness\XUnitShared\Harness\VisualStudioInstanceFactory.cs (1)
463_ = Task.Run(() => TakeScreenShotEveryTimeIntervalAsync(dir, commandBeingExecuted, cancellatokenSource.Token));
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)
314_cancellationTokenSource.Token); 476if (await oldProject.GetDependentVersionAsync(_cancellationTokenSource.Token).ConfigureAwait(false) != 477await newProject.GetDependentVersionAsync(_cancellationTokenSource.Token).ConfigureAwait(false)) 486var 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)
42await executor.ExecuteAsync(query, queryDocument: null, workspace.CurrentSolution, queryCancellationSource.Token).ConfigureAwait(false);
SemanticSearch\SemanticSearchToolWindowImpl.cs (1)
425_ = ExecuteAsync(cancellationSource.Token).ReportNonFatalErrorAsync().CompletesAsyncOperation(completionToken);
Microsoft.VisualStudio.LanguageServices.Implementation (2)
SolutionExplorer\AnalyzerItem\AnalyzerItemSource.cs (1)
54_cancellationTokenSource.Token);
SolutionExplorer\DiagnosticItem\BaseDiagnosticAndGeneratorItemSource.cs (1)
57_cancellationTokenSource.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)
305var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 306var monitorTask = MonitorDisconnectAsync(pipeStream, request.RequestId, logger, serverCts.Token);
Roslyn.Diagnostics.Analyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
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)
169cancellationTokenSource.Token);
Services\VisualStudioDiagnosticAnalyzerExecutorTests.cs (2)
115var task = Task.Run(() => AnalyzeAsync(workspace, workspace.CurrentSolution.ProjectIds.First(), analyzerType, isHostAnalyzer: false, source.Token)); 130Assert.True(ex is OperationCanceledException, $"cancellationToken : {source.Token.IsCancellationRequested}/r/n{ex}");
RunTests (3)
Program.cs (3)
67result = await RunCoreAsync(options, cts.Token); 71result = await RunAsync(options, cts.Token); 94var 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)
78while (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); 1387handles.Add(linkedTokenSource.Token.WaitHandle); // add the combined token to the handles list 1620using 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.Pipelines (7)
System\IO\Pipelines\StreamPipeReader.cs (6)
259await reader.InnerStream.ReadAsync(Memory<byte>.Empty, tokenSource.Token).ConfigureAwait(false); 268int length = await reader.InnerStream.ReadAsync(buffer, tokenSource.Token).ConfigureAwait(false); 336FlushResult flushResult = await destination.WriteAsync(segment.Memory.Slice(segmentIndex), tokenSource.Token).ConfigureAwait(false); 367await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false); 407await destination.WriteAsync(segment.Memory.Slice(segmentIndex), tokenSource.Token).ConfigureAwait(false); 428await 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)
426Task<int> t = ReadAsync(array, offset, count, cts?.Token ?? CancellationToken.None); 563Task 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); 480response = base.Send(request, cts.Token); 492response.Content.LoadIntoBuffer(_maxResponseContentBufferSize, cts.Token); 535response = await base.SendAsync(request, cts.Token).ConfigureAwait(false); 547await response.Content.LoadIntoBufferAsync(_maxResponseContentBufferSize, cts.Token).ConfigureAwait(false); 626e = toThrow = CancellationHelper.CreateOperationCanceledException(e, cancellationToken.IsCancellationRequested ? cancellationToken : cts.Token); 810CancellationTokenSource 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)
269QuicConnection quicConnection = await ConnectHelper.ConnectQuicAsync(queueItem.Request, new DnsEndPoint(authority.IdnHost, authority.Port), _poolManager.Settings._pooledConnectionIdleTimeout, _sslOptionsHttp3!, connection.StreamCapacityCallback, cts.Token).ConfigureAwait(false); 285connectionException = e is OperationCanceledException oce && oce.CancellationToken == cts.Token && !waiter.CancelledByOriginatingRequestCompletion ? 865altSvcBlocklistTimerCt = _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)
184await FlushSendBufferAsync(endStream: _request.Content == null, _requestBodyCancellationSource.Token).ConfigureAwait(false); 188? SendContentAsync(_request.Content, _requestBodyCancellationSource.Token) 193Task readResponseTask = ReadResponseAsync(_requestBodyCancellationSource.Token); 245await writesClosed.WaitAsync(_requestBodyCancellationSource.Token).ConfigureAwait(false); 264await DrainContentLength0Frames(_requestBodyCancellationSource.Token).ConfigureAwait(false); 345catch (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)
86await connection.FinishConnectAsync(options, linkedCts.Token).ConfigureAwait(false); 148internal CancellationToken ConnectionShutdownToken => _shutdownTokenSource.Token;
System\Net\Quic\QuicListener.cs (2)
232using CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(_disposeCts.Token, connection.ConnectionShutdownToken); 233cancellationToken = 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)
696cancellationToken = _multipleConnectCancellation.Token;
System.Net.WebSockets (1)
System\Net\WebSockets\WebSocketStream.cs (1)
269ct = 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)
1688while ((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.ServiceModel.Http (1)
System\ServiceModel\Channels\HttpChannelFactory.cs (1)
1056_httpResponseMessage = await _httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseHeadersRead, _httpSendCts.Token);
System.ServiceModel.Primitives (3)
Internals\System\Runtime\TaskHelpers.cs (1)
234var completedTask = await Task.WhenAny(task, Task.Delay(timeout, cts.Token));
Internals\System\Runtime\TimeoutHelper.cs (2)
321var token = tokenSource.Token; 337tokenTask = Task.FromResult(new CancellationTokenSource(millisecondsTimeout).Token);
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 (8)
System\Windows\Forms\ControlTests_InvokeAsync.cs (7)
239() => throw new ArgumentOutOfRangeException("Should not run"), cts.Token) 254cts.Token).ConfigureAwait(false); 276cts.Token).ConfigureAwait(true); 290cts.Token).ConfigureAwait(false); 311cts.Token); 340}, cts.Token); 367}, cts.Token);
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),
Testing.Tests (29)
WaitFailures.cs (29)
32await app.StartAsync(cts.Token); 34await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, cancellationToken: cts.Token); 47await app.StartAsync(cts.Token); 49await app.ResourceNotifications.WaitForResourceAsync(pwsh.Resource.Name, cancellationToken: cts.Token); 64await app.StartAsync(cts.Token); 68await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, cancellationToken: cts.Token); 72await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, KnownResourceStates.TerminalStates, cancellationToken: cts.Token); 84await app.StartAsync(cts.Token); 87await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, "StateThatIsNeverUsed", cts.Token); 99await app.StartAsync(cts.Token); 102await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, ["States", "That", "Are", "Never", "Used"], cts.Token); 114await app.StartAsync(cts.Token); 117await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, x => false, cts.Token); 133await app.StartAsync(cts.Token); 136await app.ResourceNotifications.WaitForResourceHealthyAsync(nginx.Resource.Name, cts.Token); 152await app.StartAsync(cts.Token); 156await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, x => x.Snapshot.HealthReports.All(x => x.Status.HasValue), cts.Token); 159await app.ResourceNotifications.WaitForResourceHealthyAsync(nginx.Resource.Name, cts.Token); 172await app.StartAsync(cts.Token); 176await app.ResourceNotifications.WaitForResourceAsync(nginx.Resource.Name, x => x.Snapshot.HealthStatus == HealthStatus.Healthy, cts.Token); 180await app.ResourceNotifications.WaitForResourceHealthyAsync(nginx.Resource.Name, cts.Token); 203_ = app.StartAsync(cts.Token); 206await app.ResourceNotifications.WaitForDependenciesAsync(consumer.Resource, cts.Token); 224_ = app.StartAsync(cts.Token); 228await app.ResourceNotifications.WaitForResourceAsync(dependency.Resource.Name, cancellationToken: cts.Token); 232await app.ResourceNotifications.WaitForDependenciesAsync(consumer.Resource, cts.Token); 248_ = app.StartAsync(cts.Token); 252await app.ResourceNotifications.WaitForResourceAsync(dependency.Resource.Name, cancellationToken: cts.Token); 256await app.ResourceNotifications.WaitForDependenciesAsync(consumer.Resource, cancellationToken: cts.Token);
Text.Analyzers (6)
src\Dependencies\Threading\CancellationSeries.cs (1)
75var nextToken = nextSource.Token;
src\Dependencies\Threading\ParallelExtensions.NetFramework.cs (3)
163await state.LoopBody(element, state.Cancellation.Token); 328await state.LoopBody(element, state.Cancellation.Token); 618Enumerator = source.GetAsyncEnumerator(Cancellation.Token) ?? throw new InvalidOperationException();
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AsyncLazy`1.cs (2)
397var cancellationToken = computationToStart.CancellationTokenSource.Token; 431(t, s) => CompleteWithTask(t, ((CancellationTokenSource)s!).Token),
vbc (2)
src\Compilers\Shared\BuildServerConnection.cs (2)
305var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 306var 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)
305var responseTask = BuildResponse.ReadAsync(pipeStream, serverCts.Token); 306var 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; 95using var registration = runCancellationToken.Token.Register(async () =>