ConfigureAwait

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

121await this.ReduceAsync(document, root, nodesAndTokensToReduce, reducers, options, reducedNodesMap, reducedTokensMap, cancellationToken).ConfigureAwait(false); 178ReduceOneNodeOrTokenAsync).ConfigureAwait(false);

GenerateRulesMissingDocumentation (4)

Program.cs (4)

19await Console.Error.WriteLineAsync($"Excepted {expectedArguments} arguments, found {args.Length}: {string.Join(';', args)}").ConfigureAwait(false); 25await Console.Error.WriteLineAsync($"Excepted the first argument to start with `{validateOnlyPrefix}`. found `{args[0]}`.").ConfigureAwait(false); 86await Console.Error.WriteLineAsync($"Missing entry in '{fileWithPath}'. Please add the below entry to this file to fix the build:").ConfigureAwait(false); 87await Console.Error.WriteLineAsync(line).ConfigureAwait(false);

http2cat (2)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

HttpStress (1)

Program.cs (1)

676await tcs.Task.ConfigureAwait(false);

IdeCoreBenchmarks (2)

CSharpIdeAnalyzerBenchmarks.cs (1)

79await _diagnosticAnalyzerRunner.RunAsync(CancellationToken.None).ConfigureAwait(false);

IncrementalAnalyzerBenchmarks.cs (1)

78await _incrementalAnalyzerRunner.RunAsync(CancellationToken.None).ConfigureAwait(false);

IdentitySample.PasskeyConformance (1)

Program.cs (1)

127await passkeyStore.AddOrUpdatePasskeyAsync(user, attestationResult.Passkey, cancellationToken).ConfigureAwait(false);

IIS.Common.TestLib (2)

TestConnections.cs (2)

70await _stream.WriteAsync(bytes, index, 1).ConfigureAwait(false); 71await _stream.FlushAsync().ConfigureAwait(false);

IIS.FunctionalTests (2)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

IIS.LongTests (2)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

IIS.NewHandler.FunctionalTests (2)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

IIS.NewShim.FunctionalTests (2)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

IIS.ShadowCopy.Tests (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

IISExpress.FunctionalTests (2)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

InMemory.FunctionalTests (29)

Http2\Http2ConnectionTests.cs (4)

3635await SendPreambleAsync().ConfigureAwait(false); 3692await SendPreambleAsync().ConfigureAwait(false); 5528await SendPreambleAsync().ConfigureAwait(false); 5610await SendPreambleAsync().ConfigureAwait(false);

RequestTests.cs (3)

2354await writer.WriteAsync(text).ConfigureAwait(false); 2355await writer.FlushAsync().ConfigureAwait(false); 2356await client.Stream.FlushAsync().ConfigureAwait(false);

ResponseTests.cs (4)

635=> await AttemptingToWriteNonzeroContentLengthFails(statusCode, method).ConfigureAwait(true); 640=> await AttemptingToWriteZeroContentLength_ContentLengthRemoved(statusCode, method).ConfigureAwait(true); 654=> await AttemptingToWriteNonzeroContentLengthFails(statusCode, HttpMethod.Connect).ConfigureAwait(true); 668=> await AttemptingToWriteZeroContentLength_ContentLengthRemoved(statusCode, HttpMethod.Connect).ConfigureAwait(true);

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (7)

72await writer.WriteAsync(text).ConfigureAwait(false); 73await writer.FlushAsync().ConfigureAwait(false); 74await _stream.FlushAsync().ConfigureAwait(false); 85await writer.FlushAsync().ConfigureAwait(false); 89await writer.FlushAsync().ConfigureAwait(false); 90await _stream.FlushAsync().ConfigureAwait(false); 131await Receive(lines).ConfigureAwait(false);

TestTransport\InMemoryHttpClientSlim.cs (10)

TestTransport\TestServer.cs (1)

142await _host.StopAsync().ConfigureAwait(false);

InteractiveHost.UnitTests (2)

StressTests.cs (2)

25await TestKillAfterAsync(sleep).ConfigureAwait(false); 38await Task.Delay(milliseconds).ConfigureAwait(false);

InteractiveHost32 (1)

src\Interactive\HostProcess\InteractiveHostEntryPoint.cs (1)

57await InteractiveHost.Service.RunServerAsync(pipeName, clientProcessId, invokeOnMainThread).ConfigureAwait(false);

InteractiveHost64 (1)

src\Interactive\HostProcess\InteractiveHostEntryPoint.cs (1)

57await InteractiveHost.Service.RunServerAsync(pipeName, clientProcessId, invokeOnMainThread).ConfigureAwait(false);

InteropClient (4)

AsyncStreamExtensions.cs (4)

36await asyncAction(streamReader.Current).ConfigureAwait(false); 63await streamWriter.WriteAsync(element).ConfigureAwait(false); 67await streamWriter.CompleteAsync().ConfigureAwait(false); 79await streamWriter.WriteAsync(element).ConfigureAwait(false);

InteropWebsite (1)

AsyncStreamExtensions.cs (1)

34await asyncAction(streamReader.Current).ConfigureAwait(false);

LargeResponseApp (1)

Startup.cs (1)

36await context.Response.Body.WriteAsync(_chunk, 0, _chunkSize).ConfigureAwait(false);

Metrics (17)

Program.cs (3)

246await metricFile.WriteStringAsync(Environment.NewLine + Environment.NewLine).ConfigureAwait(false); 277await computeSolutionMetricDataAsync(workspace, projectOrSolution, cancellationToken).ConfigureAwait(false); 283await computeProjectMetricDataAsync(workspace, projectOrSolution, cancellationToken).ConfigureAwait(false);

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

Metrics.Legacy (17)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\RoslynAnalyzers\Tools\Metrics\Program.cs (3)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

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.Analyzers.Extra.Tests (1)

Resources\RoslynTestUtils.cs (1)

351await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Analyzers.Local.Tests (1)

Resources\RoslynTestUtils.cs (1)

352await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.AspNetCore.Authorization (4)

AuthorizationHandler.cs (2)

24await HandleRequirementAsync(context, req).ConfigureAwait(false); 55await HandleRequirementAsync(context, req, resource).ConfigureAwait(false);

DefaultAuthorizationService.cs (1)

70await handler.HandleAsync(authContext).ConfigureAwait(false);

PassThroughAuthorizationHandler.cs (1)

39await handler.HandleAsync(context).ConfigureAwait(false);

Microsoft.AspNetCore.Components (1)

Rendering\RendererSynchronizationContext.cs (1)

127await state.asyncAction().ConfigureAwait(false);

Microsoft.AspNetCore.Components.WebView.Maui (1)

src\Core\src\TaskExtensions.cs (1)

36 await task.ConfigureAwait(false);

Microsoft.AspNetCore.Diagnostics.Middleware (4)

Latency\CapturePipelineEntryMiddleware.cs (1)

28await _next(context).ConfigureAwait(false);

Latency\CapturePipelineExitMiddleware.cs (1)

34await _next(context).ConfigureAwait(false);

Latency\RequestLatencyTelemetryMiddleware.cs (2)

78await ExportAsync(latencyContext.LatencyData).ConfigureAwait(false); 96await Task.WhenAll(exports).ConfigureAwait(false);

Microsoft.AspNetCore.Diagnostics.Middleware.Tests (7)

Latency\AcceptanceTests.cs (1)

59await next.Invoke().ConfigureAwait(false);

Latency\ChecpointAcceptanceTests.cs (2)

47await next.Invoke().ConfigureAwait(false); 83await next.Invoke().ConfigureAwait(false);

Logging\AcceptanceTests.cs (4)

131await context.Request.Body.DrainAsync(default).ConfigureAwait(false); 135await context.Response.WriteAsync("Server: hello!").ConfigureAwait(false); 138await context.Response.WriteAsync("Server: world!").ConfigureAwait(false); 175await func(logCollector, client, host.Services).ConfigureAwait(false);

Microsoft.AspNetCore.Hosting (5)

Internal\WebHost.cs (5)

139await _hostedServiceExecutor.StartAsync(cancellationToken).ConfigureAwait(false); 147await Server.StartAsync(hostingApp, cancellationToken).ConfigureAwait(false); 299await Server.StopAsync(cancellationToken).ConfigureAwait(false); 305await _hostedServiceExecutor.StopAsync(cancellationToken).ConfigureAwait(false); 325await StopAsync().ConfigureAwait(false);

Microsoft.AspNetCore.Http.Connections.Client (29)

HttpConnection.cs (9)

HttpConnectionFactory.cs (1)

66await connection.StartAsync(cancellationToken).ConfigureAwait(false);

Internal\LongPollingTransport.cs (5)

93await sending.ConfigureAwait(false); 106await receiving.ConfigureAwait(false); 109await SendDeleteRequest(url).ConfigureAwait(false); 127await Running.ConfigureAwait(false); 192await response.Content.CopyToAsync(applicationStream, cancellationToken).ConfigureAwait(false);

Internal\ServerSentEventsTransport.cs (3)

110await sending.ConfigureAwait(false); 122await receiving.ConfigureAwait(false); 191await Running.ConfigureAwait(false);

Internal\WebSocketsTransport.cs (11)

Microsoft.AspNetCore.HttpLogging (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.Identity (2)

PasskeyHandler.cs (2)

265.ConfigureAwait(false); 484.ConfigureAwait(false);

Microsoft.AspNetCore.Identity.EntityFrameworkCore (4)

UserOnlyStore.cs (2)

637await SaveChanges(cancellationToken).ConfigureAwait(false); 719await SaveChanges(cancellationToken).ConfigureAwait(false);

UserStore.cs (2)

782await SaveChanges(cancellationToken).ConfigureAwait(false); 864await SaveChanges(cancellationToken).ConfigureAwait(false);

Microsoft.AspNetCore.InternalTesting (23)

HttpClientSlim.cs (10)

src\Shared\TaskExtensions.cs (2)

117await task.ConfigureAwait(false); 123await task.WaitAsync(timeout).ConfigureAwait(false);

xunit\AspNetTestAssemblyRunner.cs (5)

35await base.AfterTestAssemblyStartingAsync().ConfigureAwait(false); 79await asyncInit.InitializeAsync().ConfigureAwait(false); 82}).ConfigureAwait(false); 95await Aggregator.RunAsync(disposable.DisposeAsync).ConfigureAwait(false); 98await base.BeforeTestAssemblyFinishedAsync().ConfigureAwait(false);

xunit\AspNetTestCollectionRunner.cs (1)

35await base.AfterTestCollectionStartingAsync().ConfigureAwait(false);

xunit\AspNetTestInvoker.cs (4)

44await lifecycleHook.OnTestStartAsync(context, CancellationTokenSource.Token).ConfigureAwait(false); 46}).ConfigureAwait(false); 55await lifecycleHook.OnTestEndAsync(context, exception, CancellationTokenSource.Token).ConfigureAwait(false); 57}).ConfigureAwait(false);

xunit\AspNetTestRunner.cs (1)

97await Task.Delay(5000).ConfigureAwait(false);

Microsoft.AspNetCore.Mvc.Testing (3)

DeferredHostBuilder.cs (1)

154await _hostStartedTcs.Task.ConfigureAwait(false);

WebApplicationFactory.cs (2)

791.ConfigureAwait(false) 827await _host.StopAsync().ConfigureAwait(false);

Microsoft.AspNetCore.OutputCaching (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (2)

RedisOutputCacheStore.cs (2)

100await Task.Delay(TimeSpan.FromSeconds(secondsWithJitter)).ConfigureAwait(false); 326await _connectionLock.WaitAsync(token).ConfigureAwait(false);

Microsoft.AspNetCore.ResponseCaching (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.ResponseCompression (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.Server.HttpSys (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (1)

src\Shared\Http2cat\Http2Utilities.cs (1)

162await SendPreambleAsync().ConfigureAwait(false);

Microsoft.AspNetCore.Server.IIS (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.Server.Kestrel.Core (22)

AnyIPListenOptions.cs (2)

26await base.BindAsync(context, cancellationToken).ConfigureAwait(false); 43await base.BindAsync(context, cancellationToken).ConfigureAwait(false);

Internal\AddressBinder.cs (4)

90await context.CreateBinding(endpoint, cancellationToken).ConfigureAwait(false); 179await httpDefault.BindAsync(context, cancellationToken).ConfigureAwait(false); 241await endpoint.BindAsync(context, cancellationToken).ConfigureAwait(false); 269await options.BindAsync(context, cancellationToken).ConfigureAwait(false);

Internal\Infrastructure\TransportManager.cs (4)

133await Task.WhenAll(tasks).ConfigureAwait(false); 153await Task.WhenAll(tasks).ConfigureAwait(false); 160await Task.WhenAll(tasks).ConfigureAwait(false); 187await AcceptLoopTask.ConfigureAwait(false);

Internal\KestrelServerImpl.cs (8)

ListenOptions.cs (1)

224await AddressBinder.BindEndpointAsync(this, context, cancellationToken).ConfigureAwait(false);

LocalhostListenOptions.cs (2)

45await AddressBinder.BindEndpointAsync(v4Options, context, cancellationToken).ConfigureAwait(false); 59await AddressBinder.BindEndpointAsync(v6Options, context, cancellationToken).ConfigureAwait(false);

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (7)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (7)

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.Shared.Tests (1)

src\Shared\TaskToApm.cs (1)

95_task.ConfigureAwait(continueOnCapturedContext: false)

Microsoft.AspNetCore.SignalR.Client.Core (55)

HubConnection.cs (51)

src\SignalR\common\Shared\MessageBuffer.cs (4)

106await _writeLock.WaitAsync().ConfigureAwait(false); 159await _writeLock.WaitAsync(cancellationToken: default).ConfigureAwait(false); 190await _writeLock.WaitAsync(cancellationToken: default).ConfigureAwait(false); 255await _writeLock.WaitAsync().ConfigureAwait(false);

Microsoft.AspNetCore.SignalR.Client.FunctionalTests (1)

HubConnectionTests.cs (1)

82await connection.StartAsync().ConfigureAwait(false);

Microsoft.AspNetCore.SignalR.Core (4)

src\SignalR\common\Shared\MessageBuffer.cs (4)

Microsoft.AspNetCore.SignalR.Specification.Tests (2)

src\Shared\TaskExtensions.cs (2)

117await task.ConfigureAwait(false); 123await task.WaitAsync(timeout).ConfigureAwait(false);

Microsoft.Build.Tasks.CodeAnalysis (11)

src\Compilers\Shared\BuildProtocol.cs (7)

src\Compilers\Shared\BuildServerConnection.cs (4)

Microsoft.Build.Tasks.CodeAnalysis.Sdk (10)

src\Compilers\Shared\BuildProtocol.cs (7)

src\Compilers\Shared\BuildServerConnection.cs (3)

284await request.WriteAsync(pipeStream, cancellationToken).ConfigureAwait(false); 349await Task.Delay(millisecondsDelay: 100, cancellationToken).ConfigureAwait(false); 398await Task.Run(() => pipeStream.ConnectAsync(timeoutMs, cancellationToken), cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis (24)

DiagnosticAnalyzer\AnalyzerDriver.cs (12)

DiagnosticAnalyzer\CompilationWithAnalyzers.cs (11)

InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.Analyzers (20)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

Microsoft.CodeAnalysis.AnalyzerUtilities (14)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

Microsoft.CodeAnalysis.BannedApiAnalyzers (20)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

Microsoft.CodeAnalysis.CodeStyle (16)

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

193pragmasToIsUsedMap, idToSuppressMessageAttributesMap, suppressMessageAttributesToIsUsedMap, cancellationToken).ConfigureAwait(false); 533idToSuppressMessageAttributesMap, suppressMessageAttributesToIsUsedMap, cancellationToken).ConfigureAwait(false);

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

Microsoft.CodeAnalysis.CodeStyle.Fixes (23)

src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

95editor, annotation, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

237cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

116await InitializeNonDelegatedConstructorAsync(cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (4)

56await AddPropertyCodeActionsAsync(actions, semanticDocument, state, cancellationToken).ConfigureAwait(false); 62await AddPropertyCodeActionsAsync(actions, semanticDocument, state, cancellationToken).ConfigureAwait(false); 66await AddLocalCodeActionsAsync(actions, document, state, cancellationToken).ConfigureAwait(false); 67await AddParameterCodeActionsAsync(actions, document, state, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

51await MakeFieldReadonlyAsync(document, editor, declarators, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

125diagnostics.Length == 1, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (5)

330removeAssignments, nameGenerator, editor, cancellationToken).ConfigureAwait(false); 374preference, removeAssignments, nameGenerator, editor, cancellationToken).ConfigureAwait(false); 851await OnDocumentUpdatedAsync().ConfigureAwait(false); 862await OnDocumentUpdatedAsync().ConfigureAwait(false); 875await OnDocumentUpdatedAsync().ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)

54cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (1)

62document, diagnostic, nestedEditor, formattingOptions, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)

89document, editor, ifStatement, properties, cancellationToken).ConfigureAwait(false); 94document, editor, (TConditionalExpressionSyntax)conditionalExpressionOrIfStatement, properties, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (1)

121await this.ReduceAsync(document, root, nodesAndTokensToReduce, reducers, options, reducedNodesMap, reducedTokensMap, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (18)

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (1)

95.ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

75cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

34await MakeLocalFunctionStaticAsync(document, localFunction, captures, syntaxEditor, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\PassInCapturedVariablesAsArgumentsCodeFixProvider.cs (1)

88await fixer(document, localFunction, captures).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

88document, model, editor, node, alreadyHandled, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastCodeFixProvider.cs (1)

53cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs (1)

60cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseImplicitlyTypedLambdaExpression\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)

57cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)

66cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (4)

57await HandleDeclarationAsync(document, editor, node, cancellationToken).ConfigureAwait(false); 74await HandleVariableDeclarationAsync(document, editor, varDecl, cancellationToken).ConfigureAwait(false); 78await HandleForEachStatementAsync(document, editor, forEach, cancellationToken).ConfigureAwait(false); 82await HandleDeclarationExpressionAsync(document, editor, declarationExpression, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

59cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

103solutionEditor, document, constructorDeclaration, properties, removeMembers, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (1)

68solutionEditor, document, semanticModel, variableDeclarator, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (1)

153cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

48solutionEditor, parameter, fieldOrProperty, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests (6)

src\Analyzers\CSharp\Tests\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProviderTests.cs (1)

40string.Format(template, expectedMethodBody)).ConfigureAwait(false);

src\Analyzers\CSharp\Tests\ConvertToRecord\ConvertToRecordCodeFixTests.cs (5)

45""").ConfigureAwait(false); 68""").ConfigureAwait(false); 103""").ConfigureAwait(false); 133""").ConfigureAwait(false); 149await test.RunAsync().ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.EditorFeatures (3)

EventHookup\EventHookupSessionManager.cs (1)

111_suggestionBlocker?.DisposeAsync().ConfigureAwait(true);

EventHookup\EventHookupSessionManager_EventHookupSession.cs (1)

119await commandHandler.EventHookupSessionManager.EventHookupFoundInSessionAsync(this, eventName, cancellationToken).ConfigureAwait(false);

NavigationBar\CSharpEditorNavigationBarItemService.cs (1)

25await NavigateToSymbolItemAsync(document, item, (RoslynNavigationBarItem.SymbolItem)item.UnderlyingItem, textVersion, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (125)

CodeActions\InlineMethod\CSharpInlineMethodTests.cs (6)

59await test.RunAsync().ConfigureAwait(false); 84await test.RunAsync().ConfigureAwait(false); 112keepInlinedMethod: true).ConfigureAwait(false); 120keepInlinedMethod: false).ConfigureAwait(false); 147keepInlinedMethod: true).ConfigureAwait(false); 155keepInlinedMethod: false).ConfigureAwait(false);

CodeActions\MoveStaticMembers\CSharpMoveStaticMembersTests.cs (88)

Formatting\Indentation\SmartIndenterEnterOnTokenTests.cs (4)

1302await AssertIndentUsingSmartTokenFormatterAsync(code, ch, indentationLine, expectedIndentation, useTabs: false).ConfigureAwait(false); 1303await AssertIndentUsingSmartTokenFormatterAsync(code.Replace(" ", "\t"), ch, indentationLine, expectedIndentation, useTabs: true).ConfigureAwait(false); 1342await AssertIndentNotUsingSmartTokenFormatterButUsingIndenterAsync(code, indentationLine, expectedIndentation, useTabs: false, indentStyle).ConfigureAwait(false); 1343await AssertIndentNotUsingSmartTokenFormatterButUsingIndenterAsync(code.Replace(" ", "\t"), indentationLine, expectedIndentation, useTabs: true, indentStyle).ConfigureAwait(false);

Formatting\Indentation\SmartTokenFormatterFormatRangeTests.cs (2)

3099await AutoFormatOnMarkerAsync(initialMarkup, expected, useTabs: false, tokenKind, startTokenKind).ConfigureAwait(false); 3100await AutoFormatOnMarkerAsync(initialMarkup.Replace(" ", "\t"), expected.Replace(" ", "\t"), useTabs: true, tokenKind, startTokenKind).ConfigureAwait(false);

Formatting\Indentation\SmartTokenFormatterFormatTokenTests.cs (12)

Intents\AddConstructorParameterIntentTests.cs (6)

48""").ConfigureAwait(false); 82""").ConfigureAwait(false); 120""").ConfigureAwait(false); 157""").ConfigureAwait(false); 195}).ConfigureAwait(false); 229""").ConfigureAwait(false);

Intents\GenerateConstructorIntentTests.cs (7)

44""").ConfigureAwait(false); 74""").ConfigureAwait(false); 108""", intentData: intentData).ConfigureAwait(false); 142""", intentData: intentData).ConfigureAwait(false); 178""", additionalDocuments, [expectedText]).ConfigureAwait(false); 208""").ConfigureAwait(false); 239}).ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.Features (31)

CodeRefactorings\UseExplicitOrImplicitType\AbstractUseTypeCodeRefactoringProvider.cs (1)

123await HandleDeclarationAsync(document, editor, type, cancellationToken).ConfigureAwait(false);

Completion\CompletionProviders\CrefCompletionProvider.cs (1)

84await _keywordCompletionProvider.ProvideCompletionsAsync(context).ConfigureAwait(false);

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

95await HandleSingleTypeAsync(context, semanticModel, token, type, isParams, cancellationToken).ConfigureAwait(false);

Completion\CompletionProviders\ExplicitInterfaceTypeCompletionProvider.cs (1)

47await base.ProvideCompletionsAsync(context).ConfigureAwait(false);

Completion\CompletionProviders\FileBasedPrograms\AbstractAppDirectiveCompletionProvider.cs (1)

81await AddDirectiveContentCompletionsAsync(context, textAfterDirectiveKind.Slice(start: contentStartIndex)).ConfigureAwait(false);

Completion\Providers\ContextVariableArgumentProvider.cs (1)

33await base.ProvideArgumentAsync(context).ConfigureAwait(false);

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (2)

123await RemoveDirectFieldAndPropertyAssignmentsAsync().ConfigureAwait(false); 126await RewritePrimaryConstructorParameterReferencesAsync().ConfigureAwait(false);

ImplementInterface\AbstractChangeImplementationCodeRefactoringProvider.cs (1)

226cancellationToken).ConfigureAwait(false);

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider_Update.cs (1)

93solutionEditor, parameter, fieldOrProperty, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (1)

95.ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\InlineDeclaration\CSharpInlineDeclarationCodeFixProvider.cs (1)

75cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

34await MakeLocalFunctionStaticAsync(document, localFunction, captures, syntaxEditor, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\PassInCapturedVariablesAsArgumentsCodeFixProvider.cs (1)

88await fixer(document, localFunction, captures).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\Nullable\CSharpDeclareAsNullableCodeFixProvider.cs (1)

88document, model, editor, node, alreadyHandled, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\RemoveUnnecessaryCast\CSharpRemoveUnnecessaryCastCodeFixProvider.cs (1)

53cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseDefaultLiteral\CSharpUseDefaultLiteralCodeFixProvider.cs (1)

60cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseImplicitlyTypedLambdaExpression\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)

57cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseImplicitObjectCreation\CSharpUseImplicitObjectCreationCodeFixProvider.cs (1)

66cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseImplicitOrExplicitType\UseExplicitTypeCodeFixProvider.cs (4)

src\Analyzers\CSharp\CodeFixes\UseIndexOrRangeOperator\CSharpUseRangeOperatorCodeFixProvider.cs (1)

59cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorCodeFixProvider.cs (1)

103solutionEditor, document, constructorDeclaration, properties, removeMembers, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UsePrimaryConstructor\CSharpUsePrimaryConstructorFixAllProvider.cs (1)

56solutionEditor, document, constructorDeclaration, diagnostic.Properties, removeMembers, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockCodeFixProvider.cs (1)

68solutionEditor, document, semanticModel, variableDeclarator, cancellationToken).ConfigureAwait(false);

src\Analyzers\CSharp\CodeFixes\UseSystemThreadingLock\CSharpUseSystemThreadingLockFixAllProvider.cs (1)

48solutionEditor, document, semanticModel, declarator, cancellationToken).ConfigureAwait(false);

UseExpressionBody\UseExpressionBodyCodeRefactoringProvider.cs (1)

200await FixDeclarationsAsync(document, editor, root, [.. declarationsToFix], helper, useExpressionBody, cancellationToken).ConfigureAwait(false);

UseExpressionBodyForLambda\UseExpressionBodyForLambdaCodeRefactoringProvider.cs (2)

48await ComputeRefactoringsAsync(context, optionValue.Value, analyzerActive: false).ConfigureAwait(false); 70await ComputeRefactoringsAsync(context, optionValue.Value, analyzerActive: true).ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.Features.UnitTests (8)

Copilot\CSharpImplementNotImplementedExceptionFixProviderTests.cs (2)

472.ConfigureAwait(false); 486.ConfigureAwait(false);

src\Analyzers\CSharp\Tests\ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProviderTests.cs (1)

40string.Format(template, expectedMethodBody)).ConfigureAwait(false);

src\Analyzers\CSharp\Tests\ConvertToRecord\ConvertToRecordCodeFixTests.cs (5)

45""").ConfigureAwait(false); 68""").ConfigureAwait(false); 103""").ConfigureAwait(false); 133""").ConfigureAwait(false); 149await test.RunAsync().ConfigureAwait(false);

Microsoft.CodeAnalysis.CSharp.Workspaces (2)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (1)

153cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

48solutionEditor, parameter, fieldOrProperty, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.EditorFeatures (79)

BraceMatching\BraceHighlightingViewTaggerProvider.cs (1)

58context, document, documentSnapshotSpan.SnapshotSpan.Snapshot, caretPosition.Value, options, cancellationToken).ConfigureAwait(false);

BracePairs\BracePairsTaggerProvider.cs (1)

58document, spanToTag.SnapshotSpan.Span.ToTextSpan(), bracePairs, cancellationToken).ConfigureAwait(false);

Classification\CopyPasteAndPrintingClassificationBufferTaggerProvider.Tagger.cs (2)

167arg: default).ConfigureAwait(false); 197await addAsync(span.Span.ToTextSpan(), tempBuffer).ConfigureAwait(false);

Classification\Semantic\AbstractSemanticOrEmbeddedClassificationViewTaggerProvider.cs (5)

110context, spanToTag, classificationService, classificationOptions, cancellationToken).ConfigureAwait(false); 135context, document, spanToTag.SnapshotSpan, classificationService, options, currentSemanticVersion, cancellationToken).ConfigureAwait(false); 209context, document, subSpanToTag, classificationService, options, currentSemanticVersion, cancellationToken).ConfigureAwait(false); 241document, span.ToTextSpan(), options, classifiedSpans, cancellationToken).ConfigureAwait(false); 246document, span.ToTextSpan(), options, classifiedSpans, cancellationToken).ConfigureAwait(false);

Classification\TotalClassificationTaggerProvider.cs (4)

113await addSyntacticSpansAsync(spans, syntacticSpans, arg).ConfigureAwait(false); 114await addSemanticSpansAsync(spans, semanticSpans, arg).ConfigureAwait(false); 188await AddEmbeddedClassificationsAsync().ConfigureAwait(false); 232await addEmbeddedSpansAsync(stringLiteralSpans, embeddedClassifications, arg).ConfigureAwait(false);

CodeActions\CodeActionEditHandlerService.cs (1)

182workspace, operations, oldSolution, updatedSolution, cancellationToken).ConfigureAwait(false);

CodeDefinitionWindow\DefinitionContextTracker.cs (1)

134await _codeDefinitionWindowService.SetContextAsync(locations, cancellationToken).ConfigureAwait(false);

Copilot\CopilotTaggerProvider.cs (1)

84await analysisService.AnalyzeDocumentAsync(document, spanToTag.SnapshotSpan.Span.ToTextSpan(), prompts[0], cancellationToken).ConfigureAwait(false);

Copilot\CopilotWpfTextCreationListener.cs (1)

129document, accepted, featureId, proposalId, normalizedEdits, cancellationToken).ConfigureAwait(false);

DocumentationComments\CopilotGenerateDocumentationCommentManager.cs (3)

66await existingProvider.StartSuggestionSessionAsync(cancellationToken).ConfigureAwait(false); 87await generateDocumentationCommentProvider.GenerateDocumentationProposalAsync(snippet, snapshot, caret, cancellationToken).ConfigureAwait(false); 103await provider.InitializeAsync(textView, _suggestionServiceBase!, cancellationToken).ConfigureAwait(false);

DocumentationComments\CopilotGenerateDocumentationCommentProvider.cs (2)

87await _currentSuggestion.DismissSuggestionSessionAsync(cancellationToken).ConfigureAwait(false); 115await suggestion.ContinueSuggestionSessionWithProposalAsync(generateProposal, cancellationToken).ConfigureAwait(false);

DocumentationComments\DocumentationCommentSuggestion.cs (11)

EncapsulateField\AbstractEncapsulateFieldCommandHandler.cs (1)

95await ApplyChangeAsync(subjectBuffer, document, result, cancellationToken).ConfigureAwait(false);

Extensibility\NavigationBar\AbstractEditorNavigationBarItemService.cs (1)

52await NavigateToPositionAsync(workspace, documentId, position, virtualSpace, cancellationToken).ConfigureAwait(false);

ExtractMethod\ExtractMethodCommandHandler.cs (2)

125await ExecuteWorkerAsync(view, textBuffer, span.Span.ToTextSpan(), indicatorContext).ConfigureAwait(false); 180await ApplyChangeAsync(textBuffer, changes, waitContext).ConfigureAwait(true);

GoOrFind\AbstractGoOrFindNavigationService.cs (5)

132document, service, position, allowInvalidPosition, cancellationTokenSource).ConfigureAwait(false); 197await PresentResultsInStreamingPresenterAsync(document, findContext, findTask, cancellationTokenSource).ConfigureAwait(false); 234await findContext.AttachToStreamingPresenterAsync(presenterContext, cancellationToken).ConfigureAwait(false); 242await findTask.ConfigureAwait(false); 288await FindActionAsync(findContext, document, service, position, cancellationToken).ConfigureAwait(false);

InlineRename\CommandHandlers\AbstractRenameCommandHandler_RenameHandler.cs (4)

62await ShowErrorDialogAsync(workspace, FeaturesResources.You_must_rename_an_identifier).ConfigureAwait(false); 104await ShowErrorDialogAsync(workspace, FeaturesResources.You_must_rename_an_identifier).ConfigureAwait(false); 114await ShowErrorDialogAsync(workspace, FeaturesResources.You_must_rename_an_identifier).ConfigureAwait(false); 121await ShowErrorDialogAsync(workspace, sessionInfo.LocalizedErrorMessage).ConfigureAwait(false);

InlineRename\InlineRenameSession.cs (3)

571computedMergeResult.replacementInfo, computedMergeResult.mergeResult, cancellationToken).ConfigureAwait(true); 598replacementInfo, mergeResult, documents, cancellationToken).ConfigureAwait(true); 779await CommitCoreAsync(context, previewChanges).ConfigureAwait(true);

InlineRename\UI\Adornment\RenameFlyout.xaml.cs (1)

102await infoSession.DismissAsync().ConfigureAwait(false);

InlineRename\UI\SmartRename\SmartRenameViewModel.cs (1)

208.ConfigureAwait(false);

IntelliSense\AsyncCompletion\ItemManager.CompletionListUpdater.cs (1)

145await AddCompletionItemsAsync(itemsToBeIncluded, threadLocalPatternMatchHelper, cancellationToken).ConfigureAwait(false);

Interactive\ResetInteractive.cs (4)

65context).ConfigureAwait(true); 110await evaluator.SetPathsAsync(referenceSearchPaths, sourceSearchPaths, projectDirectory).ConfigureAwait(true); 114await interactiveWindow.SubmitAsync(importReferencesCommand).ConfigureAwait(true); 123await interactiveWindow.SubmitAsync([importNamespacesCommand]).ConfigureAwait(true);

LanguageServer\AbstractInProcLanguageClient.cs (2)

160await _languageServer.WaitForExitAsync().WithCancellation(cancellationToken).ConfigureAwait(false); 189await StartAsync.InvokeAsync(this, EventArgs.Empty).ConfigureAwait(false);

LanguageServer\AlwaysActiveLanguageClientEventListener.cs (1)

86]), _languageClient).ConfigureAwait(false);

NavigationBar\NavigationBarController.cs (1)

284await ProcessItemSelectionAsync(item, waitContext.UserCancellationToken).ConfigureAwait(false);

ReferenceHighlighting\ReferenceHighlightingViewTaggerProvider.cs (1)

133await ProduceTagsAsync(context, caretPosition, document, options, cancellationToken).ConfigureAwait(false);

Remote\SolutionChecksumUpdater.cs (2)

145await RemoteHostClient.WaitForClientCreationAsync(_workspace, cancellationToken).ConfigureAwait(false); 166await RemoteHostClient.WaitForClientCreationAsync(_workspace, cancellationToken).ConfigureAwait(false);

RenameTracking\RenameTrackingTaggerProvider.TrackingSession.cs (2)

97await isRenamableIdentifierTask.ConfigureAwait(true); 116await task.ConfigureAwait(true);

Shared\Extensions\ITextSnapshotExtensions.cs (1)

79await service.WaitUntilFullyLoadedAsync(operationContext.UserCancellationToken).ConfigureAwait(false);

SpellCheck\RoslynSpellCheckFixerProvider.cs (1)

58await ApplySimpleChangeAsync(span, replacement, cancellationToken).ConfigureAwait(false);

Suggestions\FixAll\FixMultipleOccurrencesService.cs (1)

80}).ConfigureAwait(false);

Suggestions\RefineUsingCopilot\RefineUsingCopilotCodeAction.cs (1)

97await copilotCodeAnalysisService.StartRefinementSessionAsync(oldDocument, newDocument, convertedPrimaryDiagnostic, CancellationToken.None).ConfigureAwait(false);

Suggestions\SuggestedActions\EditorSuggestedAction.cs (2)

110await this.InnerInvokeAsync(scope.GetCodeAnalysisProgress(), context.UserCancellationToken).ConfigureAwait(false); 128Provider, () => InvokeWorkerAsync(progressTracker, cancellationToken)).ConfigureAwait(true);

Suggestions\SuggestedActions\EditorSuggestedActionForRefactorOrFixAll.cs (1)

64await base.InnerInvokeAsync(progress, cancellationToken).ConfigureAwait(false);

Suggestions\SuggestedActionsSource_Async.cs (2)

51requestedActionCategories, range, collectors, completedCollectors, cancellationToken).ConfigureAwait(false); 82.WaitUntilFullyLoadedAsync(cancellationToken).ConfigureAwait(false);

Tagging\AbstractAsynchronousTaggerProvider.cs (1)

253cancellationToken).ConfigureAwait(false);

Tagging\AbstractAsynchronousTaggerProvider.TagSource_ProduceTags.cs (1)

594await _dataSource.ProduceTagsAsync(context, cancellationToken).ConfigureAwait(false);

Tagging\AsynchronousViewportTaggerProvider.SingleViewportTaggerProvider.cs (1)

170context, spanToTag, cancellationToken).ConfigureAwait(false);

Workspaces\ITextBufferVisibilityTracker.cs (2)

66await delayTask.ConfigureAwait(false); 73await taskOfTask.Unwrap().ConfigureAwait(false);

Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (1)

Completion\AbstractCompletionProviderTests.cs (1)

335options, skipSpeculation: skipSpeculation).ConfigureAwait(false);

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (5)

InheritanceMargin\InheritanceMarginTests.cs (4)

64await VerifyTestMemberInDocumentAsync(testWorkspace, testHostDocument, memberItems, cancellationToken).ConfigureAwait(false); 95await VerifyTestMemberInDocumentAsync(testWorkspace, testHostDocument, memberItems, cancellationToken).ConfigureAwait(false); 222await VerifyTestMemberInDocumentAsync(testWorkspace, testHostDocument1, memberItemsInMarkup1, cancellationToken).ConfigureAwait(false); 223await VerifyTestMemberInDocumentAsync(testWorkspace, testHostDocument2, memberItemsInMarkup2, cancellationToken).ConfigureAwait(false);

UnusedReferences\UnusedReferencesRemoverTests.cs (1)

174CancellationToken.None).ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.Copilot (1)

Internal\Analyzer\AbstractCopilotCodeAnalysisService.cs (1)

180await StartRefinementSessionCoreAsync(oldDocument, newDocument, primaryDiagnostic, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.Debugger (1)

DebuggerFindReferencesService.cs (1)

44await AbstractFindUsagesService.FindSymbolReferencesAsync(context, symbol, project, classificationOptions, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.Extensions (1)

Internal\ExtensionMessageHandlerWrapper.cs (1)

49await responseTask.ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.FSharp (5)

Internal\Classification\FSharpClassificationService.cs (2)

47await _service.AddSemanticClassificationsAsync(document, textSpan, list, cancellationToken).ConfigureAwait(false); 57await _service.AddSyntacticClassificationsAsync(document, textSpan, list, cancellationToken).ConfigureAwait(false);

Internal\NavigateTo\FSharpNavigateToSearchService.cs (3)

44await onResultsFound(results.SelectAsArray(result => (INavigateToSearchResult)new InternalFSharpNavigateToSearchResult(result))).ConfigureAwait(false); 65await onResultsFound(results.SelectAsArray(result => (INavigateToSearchResult)new InternalFSharpNavigateToSearchResult(result))).ConfigureAwait(false); 67await onProjectCompleted().ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.HotReload (2)

Api\HotReloadMSBuildWorkspace.cs (2)

221await Task.Delay(20, cancellationToken).ConfigureAwait(false); 231await Task.Delay(20 * (attemptIndex + 1), cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.OmniSharp (1)

NavigateTo\OmniSharpNavigateToSearchService.cs (1)

56await callback(project, omniSharpResult, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.Razor.Features (2)

Cohost\Handlers\FindAllReferences.cs (1)

28await FindAllReferencesHandler.FindReferencesAsync(progress, workspace, document, linePosition, supportsVSExtensions, includeDeclaration: true, globalOptions, metadataAsSourceFileService, AsynchronousOperationListenerProvider.NullListener, cancellationToken).ConfigureAwait(false);

Cohost\RazorStartupServiceFactory.cs (1)

93await cohostStartupService.Value.StartupAsync(serializedClientCapabilities, requestContext, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.ExternalAccess.Xaml (2)

Internal\OnInitializedServiceFactory.cs (2)

61await _initializationService.OnInitializedAsync(new ClientRequestManager(_clientLanguageServerManager), new ClientCapabilityProvider(clientCapabilities), cancellationToken).ConfigureAwait(false); 66await _onInitializedService.OnInitializedAsync(new ClientRequestManager(_clientLanguageServerManager), clientCapabilities, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.Features (258)

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.AddConstructorParametersCodeAction.cs (1)

112solutionEditor, member, parameter, cancellationToken).ConfigureAwait(false);

AddImport\AbstractAddImportFeatureService.cs (6)

185await FindResultsInAllSymbolsInStartingProjectAsync(allReferences, finder, exact, cancellationToken).ConfigureAwait(false); 194await FindResultsInUnreferencedProjectSourceSymbolsAsync(projectToAssembly, project, allReferences, maxResults, finder, exact, cancellationToken).ConfigureAwait(false); 198await FindResultsInUnreferencedMetadataSymbolsAsync(referenceToCompilation, project, allReferences, maxResults, finder, exact, cancellationToken).ConfigureAwait(false); 202await finder.FindNugetOrReferenceAssemblyReferencesAsync(allReferences, exact, cancellationToken).ConfigureAwait(false); 251linkedTokenSource.Token).ConfigureAwait(false); 308linkedTokenSource.Token).ConfigureAwait(false);

AddImport\SymbolReferenceFinder_PackageAssemblySearch.cs (5)

47await FindWorkerAsync(new(typeQuery.Name + AttributeSuffix, typeQuery.Arity), namespaceQuery, isAttributeSearch: true).ConfigureAwait(false); 49await FindWorkerAsync(typeQuery, namespaceQuery, isAttributeSearch: false).ConfigureAwait(false); 60allReferences, nameNode, typeQuery, namespaceQuery, isAttributeSearch, cancellationToken).ConfigureAwait(false); 67sourceName, sourceUrl, allReferences, nameNode, typeQuery, namespaceQuery, isAttributeSearch, cancellationToken).ConfigureAwait(false); 147cancellationToken: cancellationToken).ConfigureAwait(false);

ChangeSignature\AbstractChangeSignatureService.cs (1)

241await engine.FindReferencesAsync(symbol, cancellationToken).ConfigureAwait(false);

CodeFixes\Service\CodeFixService.cs (1)

691await task.ConfigureAwait(false);

CodeFixes\Suppression\AbstractSuppressionBatchFixAllProvider.cs (7)

104document, diagnosticsToFix, callback, fixAllState, cancellationToken).ConfigureAwait(false); 130await task.ConfigureAwait(false); 131}).ConfigureAwait(false); 156await Task.WhenAll(tasks).ConfigureAwait(false); 266await Task.WhenAll(getChangedDocumentsTasks).ConfigureAwait(false); 291await Task.WhenAll(getFinalDocumentTasks).ConfigureAwait(false); 332await merger.TryMergeChangesAsync(currentDocument, cancellationToken).ConfigureAwait(false);

CodeRefactorings\CodeRefactoringService.cs (1)

272await task.ConfigureAwait(false);

CodeRefactorings\SyncNamespace\AbstractChangeNamespaceService.cs (1)

546FindReferencesSearchOptions.Default, cancellationToken).ConfigureAwait(false);

Completion\CompletionService_GetCompletions.cs (1)

335() => provider.ProvideCompletionsAsync(context)).ConfigureAwait(false);

Completion\Providers\AbstractAggregateEmbeddedLanguageCompletionProvider.cs (1)

96await completionProvider.ProvideCompletionsAsync(context).ConfigureAwait(false);

Completion\Providers\AbstractInternalsVisibleToCompletionProvider.cs (1)

73await AddAssemblyCompletionItemsAsync(context, cancellationToken).ConfigureAwait(false);

Completion\Providers\ImportCompletionProvider\AbstractImportCompletionProvider.cs (1)

61await AddCompletionItemsAsync(completionContext, syntaxContext, namespacesInScope, cancellationToken).ConfigureAwait(false);

Completion\Providers\Scripting\AbstractDirectivePathCompletionProvider.cs (1)

58await ProvideCompletionsAsync(context, pathThroughLastSlash).ConfigureAwait(false);

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (2)

118propertyMap, cancellationToken).ConfigureAwait(false); 125anonymousType, cancellationToken).ConfigureAwait(false);

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (4)

312containingNamespace, parameterNamingRule, isRecord, cancellationToken).ConfigureAwait(false); 316documentToEditorMap, cancellationToken).ConfigureAwait(false); 471project, result, tupleFieldNames, cancellationToken).ConfigureAwait(false); 484project, result, tupleFieldNames, cancellationToken).ConfigureAwait(false);

Copilot\ICopilotChangeAnalysisService.cs (1)

324cancellationToken).ConfigureAwait(false);

Debugging\DebugInformationReaderProvider.cs (1)

80await _stream.CopyToAsync(stream, bufferSize: 4 * 1024, cancellationToken).ConfigureAwait(false);

DesignerAttribute\DesignerAttributeDiscoveryService.cs (3)

145frozenProject, frozenDocument, callback, lazyProjectVersion, cancellationToken).ConfigureAwait(false); 172await ProcessProjectAsync(frozenSolution.GetRequiredProject(projectId), callback, cancellationToken).ConfigureAwait(false); 193project, specificDocument: null, callback, lazyProjectVersion, cancellationToken).ConfigureAwait(false);

Diagnostics\Service\DiagnosticAnalyzerService.IncrementalMemberEditAnalyzer.cs (6)

120await ExecuteCompilerAnalyzerAsync(compilerAnalyzerData, oldMemberSpans, builder).ConfigureAwait(false); 121await ExecuteSpanBasedAnalyzersAsync(spanBasedAnalyzers, oldMemberSpans, builder).ConfigureAwait(false); 122await ExecuteDocumentBasedAnalyzersAsync(documentBasedAnalyzers, oldMemberSpans, builder).ConfigureAwait(false); 144await ExecuteAnalyzersAsync(executor, analyzers, oldMemberSpans, builder).ConfigureAwait(false); 156await ExecuteAnalyzersAsync(executor, analyzers, oldMemberSpans, builder).ConfigureAwait(false); 168await ExecuteAnalyzersAsync(executor, analyzers, oldMemberSpans, builder).ConfigureAwait(false);

Diagnostics\Service\DiagnosticAnalyzerService_CoreAnalyze.cs (4)

155document, documentAnalysisScope.Span, diagnosticsBuilder.Add, cancellationToken).ConfigureAwait(false); 169document, span: null, callback, cancellationToken).ConfigureAwait(false); 181document, span: null, diagnosticsBuilder.Add, cancellationToken).ConfigureAwait(false); 200semanticModel, span, hostCompilationWithAnalyzers, analyzerInfoCache.GetDiagnosticDescriptors, reportDiagnostic, cancellationToken).ConfigureAwait(false);

Diagnostics\Service\DiagnosticAnalyzerService_GetDiagnosticsForSpan.cs (3)

297await ComputeDocumentDiagnosticsAsync(syntaxAnalyzers, AnalysisKind.Syntax, range, incrementalAnalysis: false).ConfigureAwait(false); 298await ComputeDocumentDiagnosticsAsync(semanticSpanAnalyzers, AnalysisKind.Semantic, range, incrementalAnalysis).ConfigureAwait(false); 299await ComputeDocumentDiagnosticsAsync(semanticDocumentAnalyzers, AnalysisKind.Semantic, span: null, incrementalAnalysis: false).ConfigureAwait(false);

Diagnostics\Service\DocumentAnalysisExecutor_Helpers.cs (3)

104await VerifyDiagnosticLocationsAsync(diagnostics, document.Project, cancellationToken).ConfigureAwait(false); 128await VerifyDiagnosticLocationAsync(diagnostic.Id, diagnostic.Location).ConfigureAwait(false); 134await VerifyDiagnosticLocationAsync(diagnostic.Id, location).ConfigureAwait(false);

DocumentHighlighting\AbstractDocumentHighlightsService.cs (5)

127documentsToSearch, options, cancellationToken).ConfigureAwait(false); 228await AddLocationSpanAsync(symbol.Locations.First(), solution, spanSet, tagMap, HighlightSpanKind.Definition, cancellationToken).ConfigureAwait(false); 254await AddLocationSpanAsync(location, solution, spanSet, tagMap, HighlightSpanKind.Definition, cancellationToken).ConfigureAwait(false); 263await AddLocationSpanAsync(referenceLocation.Location, solution, spanSet, tagMap, referenceKind, cancellationToken).ConfigureAwait(false); 270await AddLocationSpanAsync(location, solution, spanSet, tagMap, HighlightSpanKind.Reference, cancellationToken).ConfigureAwait(false);

EditAndContinue\EditSession.cs (1)

1106await GetProjectDifferencesAsync(Log, oldProject, newProject, projectDifferences, projectDiagnostics, cancellationToken).ConfigureAwait(false);

Emit\CompilationOutputs.cs (1)

162await peImage.CopyToAsync(stream, bufferSize: 4 * 1024, cancellationToken).ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingIdleProcessor.cs (2)

130await WaitAsync(CancellationToken).ConfigureAwait(false); 139await ExecuteAsync().ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.AbstractUnitTestingPriorityProcessor.cs (1)

77await HigherQueueOperationTask.ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.cs (19)

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingIncrementalAnalyzerProcessor.cs (5)

136cancellationToken), cancellationToken).ConfigureAwait(false); 141await RunBodyAnalyzersAsync(analyzers, workItem, document, cancellationToken).ConfigureAwait(false); 175await runnerAsync(local, v, c).ConfigureAwait(false); 195cancellationToken), cancellationToken).ConfigureAwait(false); 204cancellationToken), cancellationToken).ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingLowPriorityProcessor.cs (3)

51await WaitForHigherPriorityOperationsAsync().ConfigureAwait(false); 57await ProcessProjectAsync(Analyzers, workItem, projectCancellation).ConfigureAwait(false); 139(a, p, c) => a.AnalyzeProjectAsync(p, reasons, c), cancellationToken).ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingNormalPriorityProcessor.cs (7)

116await WaitForHigherPriorityOperationsAsync().ConfigureAwait(false); 140await ProcessDocumentAsync(Analyzers, workItem, documentCancellation).ConfigureAwait(false); 210await ProcessReanalyzeDocumentAsync(workItem, textDocument, cancellationToken).ConfigureAwait(false); 212await Processor.ProcessDocumentAnalyzersAsync(textDocument, analyzers, workItem, cancellationToken).ConfigureAwait(false); 218await RemoveDocumentAsync(documentId, cancellationToken).ConfigureAwait(false); 278c), cancellationToken).ConfigureAwait(false); 296await analyzer.RemoveDocumentAsync(documentId, cancellationToken).ConfigureAwait(false);

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (6)

130await EnqueueWorkItemAsync(document, symbol).ConfigureAwait(false); 157await EnqueueWorkItemAsync(document, symbol).ConfigureAwait(false); 187await _processor.EnqueueWorkItemAsync(solution.GetRequiredProject(documentId.ProjectId), documentId, document: null).ConfigureAwait(false); 413await EnqueueWorkItemAsync(project).ConfigureAwait(false); 422await EnqueueWorkItemAsync(project).ConfigureAwait(false); 436await EnqueueWorkItemAsync(project, documentId, document: null).ConfigureAwait(false);

ExternalAccess\VSTypeScript\VSTypeScriptClassificationService.cs (1)

56await classificationService.AddSemanticClassificationsAsync(document, textSpans, list, cancellationToken).ConfigureAwait(false);

ExternalAccess\VSTypeScript\VSTypeScriptNavigateToSearchService.cs (5)

45await onResultsFound(results.SelectAsArray(Convert)).ConfigureAwait(false); 66await ProcessProjectAsync(group.Key).ConfigureAwait(false); 69await ProcessProjectAsync(project).ConfigureAwait(false); 83await onResultsFound(results.SelectAsArray(Convert)).ConfigureAwait(false); 86await onProjectCompleted().ConfigureAwait(false);

FindUsages\AbstractFindUsagesService.ProgressAdapter.cs (1)

137cancellationToken).ConfigureAwait(false);

FindUsages\AbstractFindUsagesService_FindImplementations.cs (2)

38context, symbol, project, classificationOptions, cancellationToken).ConfigureAwait(false); 64symbol, project, context, classificationOptions, cancellationToken).ConfigureAwait(false);

FindUsages\AbstractFindUsagesService_FindReferences.cs (6)

26definitionTrackingContext, document, position, classificationOptions, cancellationToken).ConfigureAwait(false); 62context, document, position, classificationOptions, cancellationToken).ConfigureAwait(false); 100context, symbol, project, classificationOptions, cancellationToken).ConfigureAwait(false); 121await FindReferencesAsync(context, symbol, project, searchOptions, classificationOptions, cancellationToken).ConfigureAwait(false); 152context, symbol, project, searchOptions, classificationOptions, cancellationToken).ConfigureAwait(false); 239tokenValue, Type.GetTypeCode(tokenValue.GetType()), solution, progressAdapter, cancellationToken).ConfigureAwait(false);

FullyQualify\AbstractFullyQualifyService.cs (1)

104await AddFixesAsync(document, semanticModel, simpleName, name, proposedContainers, fixes, cancellationToken).ConfigureAwait(false);

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.cs (1)

89cancellationToken).ConfigureAwait(false);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeAction.cs (1)

70await AddOperatorsAsync(methods, cancellationToken).ConfigureAwait(false);

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (1)

66await HandleNonSelectionAsync(context).ConfigureAwait(false);

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (2)

107await AddMembersAsync(members, options).ConfigureAwait(false); 170await AddFieldDelegatingConstructorAsync(argumentList, members, options).ConfigureAwait(false);

InlineHints\AbstractInlineHintsService.cs (2)

28await inlineParameterService.AddInlineHintsAsync(document, textSpan, options.ParameterOptions, options.DisplayOptions, displayAllOverride, result, cancellationToken).ConfigureAwait(false); 33await inlineTypeService.AddInlineHintsAsync(document, textSpan, options.TypeOptions, options.DisplayOptions, displayAllOverride, result, cancellationToken).ConfigureAwait(false);

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (2)

273}).ConfigureAwait(false); 291documents: null, FindReferencesSearchOptions.Default, cancellationToken).ConfigureAwait(false);

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (2)

273await UpdateExpressionInOriginalFunctionAsync(editor, cancellationToken).ConfigureAwait(false); 534await UpdateExpressionInOriginalFunctionAsync(editor, cancellationToken).ConfigureAwait(false);

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs (7)

163await AddDescriptionPartAsync(firstSymbol).ConfigureAwait(false); 371await AddPartsAsync(symbolGroup).ConfigureAwait(false); 380await AddPartsAsync(symbolGroup).ConfigureAwait(false); 402await AddDescriptionForFieldAsync(field).ConfigureAwait(false); 406await AddDescriptionForLocalAsync(local).ConfigureAwait(false); 434await AddDescriptionForParameterAsync(parameter).ConfigureAwait(false); 450await AddDescriptionPartAsync(alias.Target).ConfigureAwait(false);

MetadataAsSource\DecompilationMetadataAsSourceFileProvider.cs (1)

181await Task.Delay(DelayTimeSpan.Short, cancellationToken).ConfigureAwait(false);

NavigateTo\AbstractNavigateToSearchService.CachedDocumentSearch.cs (4)

96storageService, documentKeys, priorityDocumentKeys, searchPattern, kinds, onItemsFound, onProjectCompleted, cancellationToken).ConfigureAwait(false); 126ProcessSingleProjectGroupAsync, onItemsFound, args: default, cancellationToken).ConfigureAwait(false); 153}).ConfigureAwait(false); 156await onProjectCompleted().ConfigureAwait(false);

NavigateTo\AbstractNavigateToSearchService.cs (1)

51await onResultsFound(results.ToImmutableAndClear()).ConfigureAwait(false);

NavigateTo\AbstractNavigateToSearchService.GeneratedDocumentSearch.cs (4)

57projects, searchPattern, kinds, onItemsFound, onProjectCompleted, cancellationToken).ConfigureAwait(false); 72projects, ProcessSingleProjectAsync, onItemsFound, args: default, cancellationToken).ConfigureAwait(false); 85document, patternName, patternContainerOpt, declaredSymbolInfoKindsSet, onItemFound, cancellationToken)).ConfigureAwait(false); 87await onProjectCompleted().ConfigureAwait(false);

NavigateTo\AbstractNavigateToSearchService.NormalSearch.cs (7)

50await SearchDocumentAndRelatedDocumentsInCurrentProcessAsync(document, searchPattern, kinds, onItemsFound, cancellationToken).ConfigureAwait(false); 69SearchRelatedDocumentsInCurrentProcessAsync()).ConfigureAwait(false); 97await SearchDocumentsInCurrentProcessAsync(relatedDocuments).ConfigureAwait(false); 183projects, priorityDocuments, searchPattern, kinds, onItemsFound, onProjectCompleted, cancellationToken).ConfigureAwait(false); 208SearchSingleProjectAsync, onItemsFound, args: default, cancellationToken).ConfigureAwait(false); 223document, patternName, patternContainerOpt, declaredSymbolInfoKindsSet, onItemFound, cancellationToken)).ConfigureAwait(false); 225await onProjectCompleted().ConfigureAwait(false);

NavigateTo\IRemoteNavigateToSearchService.cs (2)

59await onItemsFound(items, default, cancellationToken).ConfigureAwait(false); 73await onProjectCompleted().ConfigureAwait(false);

NavigateTo\NavigateToSearcher.cs (20)

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (2)

225desiredGetMethodName, desiredSetMethodName, cancellationToken).ConfigureAwait(false); 280cancellationToken).ConfigureAwait(false);

SpellCheck\AbstractSpellCheckCodeFixProvider.cs (5)

50await CheckNodeAsync(context, document, node, cancellationToken).ConfigureAwait(false); 58await CheckTokenAsync(context, document, token, cancellationToken).ConfigureAwait(false); 83await CreateSpellCheckCodeIssueAsync(context, token, IsGeneric(name), cancellationToken).ConfigureAwait(false); 100await CreateSpellCheckCodeIssueAsync(context, token, IsGeneric(token), cancellationToken).ConfigureAwait(false); 142completionList, similarityChecker).ConfigureAwait(false);

src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

src\Analyzers\Core\CodeFixes\AddAnonymousTypeMemberName\AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs (1)

95editor, annotation, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\AddExplicitCast\AbstractAddExplicitCastCodeFixProvider.cs (1)

237cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (1)

116await InitializeNonDelegatedConstructorAsync(cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (4)

src\Analyzers\Core\CodeFixes\MakeFieldReadonly\AbstractMakeFieldReadonlyCodeFixProvider.cs (1)

51await MakeFieldReadonlyAsync(document, editor, declarators, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\PopulateSwitch\AbstractPopulateSwitchCodeFixProvider.cs (1)

125diagnostics.Length == 1, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\RemoveUnusedParametersAndValues\AbstractRemoveUnusedValuesCodeFixProvider.cs (5)

src\Analyzers\Core\CodeFixes\SimplifyBooleanExpression\SimplifyConditionalCodeFixProvider.cs (1)

54cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\UseConditionalExpression\AbstractUseConditionalExpressionCodeFixProvider.cs (1)

62document, diagnostic, nestedEditor, formattingOptions, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\UseNullPropagation\AbstractUseNullPropagationCodeFixProvider.cs (2)

SymbolSearch\Windows\SymbolSearchUpdateEngine.Update.cs (12)

SyncNamespaces\AbstractSyncNamespacesService.cs (1)

119await codeFixProvider.RegisterCodeFixesAsync(context).ConfigureAwait(false);

UnusedReferences\UnusedReferencesRemover.cs (1)

271await ApplyReferenceUpdatesAsync(referenceCleanupService, projectFilePath, referenceUpdates, cancellationToken).ConfigureAwait(true);

UseNamedArguments\AbstractUseNamedArgumentsCodeRefactoringProvider.cs (2)

207await _argumentAnalyzer.ComputeRefactoringsAsync(context, root).ConfigureAwait(false); 211await _attributeArgumentAnalyzer.ComputeRefactoringsAsync(context, root).ConfigureAwait(false);

ValueTracking\ValueTracker.cs (13)

ValueTracking\ValueTracker.FindReferencesProgress.cs (8)

54await TrackConstructorAsync(location, cancellationToken).ConfigureAwait(false); 60await TrackMethodInvocationArgumentsAsync(location, cancellationToken).ConfigureAwait(false); 79await AddItemsFromAssignmentAsync(location.Document, node, _operationCollector, cancellationToken).ConfigureAwait(false); 90await _operationCollector.VisitAsync(operation, cancellationToken).ConfigureAwait(false); 118await _operationCollector.VisitAsync(argumentOperation, cancellationToken).ConfigureAwait(false); 136await _operationCollector.VisitAsync(expressionOperation, cancellationToken).ConfigureAwait(false); 164await _operationCollector.VisitAsync(operation, cancellationToken).ConfigureAwait(false); 199await _operationCollector.VisitAsync(operation, cancellationToken).ConfigureAwait(false);

ValueTracking\ValueTracker.OperationCollector.cs (7)

52await VisitAsync(returnOperation, cancellationToken).ConfigureAwait(false); 86await AddOperationAsync(operation, symbolInfo.Symbol, cancellationToken).ConfigureAwait(false); 93await VisitAsync(child, cancellationToken).ConfigureAwait(false); 107await AddOperationAsync(invocationOperation, invocationOperation.TargetMethod, cancellationToken).ConfigureAwait(false); 108await TrackArgumentsAsync(invocationOperation.Arguments, cancellationToken).ConfigureAwait(false); 192async (pair, cancellationToken) => await pair.collector.VisitAsync(pair.argument.Value, cancellationToken).ConfigureAwait(false)).ConfigureAwait(false);

ValueTracking\ValueTrackingService.cs (2)

53await ValueTracker.TrackValueSourceAsync(selection, document, progressTracker, cancellationToken).ConfigureAwait(false); 83await ValueTracker.TrackValueSourceAsync(solution, previousTrackedItem, progressTracker, cancellationToken).ConfigureAwait(false);

Wrapping\ChainedExpression\ChainedExpressionCodeActionComputer.cs (3)

97await AddWrapCodeActionAsync(actions, cancellationToken).ConfigureAwait(false); 98await AddUnwrapCodeActionAsync(actions, cancellationToken).ConfigureAwait(false); 99await AddWrapLongCodeActionAsync(actions, cancellationToken).ConfigureAwait(false);

Wrapping\SeparatedSyntaxList\SeparatedSyntaxListCodeActionComputer.cs (4)

140await AddWrappingGroupsAsync(result, cancellationToken).ConfigureAwait(false); 210wrappingStyle, result, cancellationToken).ConfigureAwait(false); 302wrappingStyle, result, cancellationToken).ConfigureAwait(false); 436await AddTextChangeBetweenOpenAndFirstItemAsync(wrappingStyle, result, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.InteractiveHost (9)

Interactive\Core\InteractiveHost.LazyRemoteService.cs (1)

205await clientStream.ConnectAsync(cancellationToken).ConfigureAwait(false);

Interactive\Core\InteractiveHost.RemoteService.cs (1)

99await host.OnProcessExitedAsync(Process).ConfigureAwait(false);

Interactive\Core\InteractiveHost.Service.cs (2)

227await serverStream.WaitForConnectionAsync().ConfigureAwait(false); 231await jsonRpc.Completion.ConfigureAwait(false);

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

Microsoft.CodeAnalysis.LanguageServer.Protocol (54)

Features\Suggestions\UnifiedSuggestedActionsSource.cs (4)

73await GroupFixesAsync(project, fixCollections, map, order, cancellationToken).ConfigureAwait(false); 91await ProcessFixCollectionAsync(project, map, order, fixCollection, cancellationToken).ConfigureAwait(false); 107await AddCodeActionsAsync(project, map, order, fixCollection, GetFlavorsAsync, nonSupressionCodeFixes).ConfigureAwait(false); 111await AddCodeActionsAsync(project, map, order, fixCollection, GetFlavorsAsync, supressionCodeFixes).ConfigureAwait(false);

Handler\CodeActions\CodeActionResolveHelper.cs (10)

Handler\CodeLens\CodeLensHandler.cs (1)

72await AddReferencesCodeLensAsync(codeLenses, members, document, text, textDocumentIdentifier, cancellationToken).ConfigureAwait(false);

Handler\Completion\CompletionResultFactory.cs (2)

371cancellationToken).ConfigureAwait(false); 414cancellationToken).ConfigureAwait(false);

Handler\Configuration\DidChangeConfigurationNotificationHandler.cs (2)

68await RefreshOptionsAsync(cancellationToken).ConfigureAwait(false); 73await onConfigurationChanged.OnConfigurationChangedAsync(requestContext, cancellationToken).ConfigureAwait(false);

Handler\Configuration\DidChangeConfigurationNotificationHandler_OnInitialized.cs (1)

31await RefreshOptionsAsync(cancellationToken).ConfigureAwait(false);

Handler\Diagnostics\AbstractPullDiagnosticHandler.cs (2)

133await ProcessPreviousResultsAsync(context.Solution, previousResults, documentIdToPreviousDiagnosticParams, removedDocuments, cancellationToken).ConfigureAwait(false); 210await WaitForChangesAsync(category, context, cancellationToken).ConfigureAwait(false);

Handler\Diagnostics\AbstractWorkspacePullDiagnosticsHandler.cs (1)

113await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).ConfigureAwait(false);

Handler\Diagnostics\DiagnosticSourceProviders\WorkspaceDocumentsAndProjectDiagnosticSourceProvider.cs (1)

60await AddDocumentsAndProjectAsync(project, cancellationToken).ConfigureAwait(false);

Handler\LanguageServerNotificationManager.cs (4)

30=> await _jsonRpc.InvokeWithParameterObjectAsync(methodName, cancellationToken: cancellationToken).ConfigureAwait(false); 33=> await _jsonRpc.InvokeWithParameterObjectAsync(methodName, @params, cancellationToken).ConfigureAwait(false); 36=> await _jsonRpc.NotifyWithParameterObjectAsync(methodName).ConfigureAwait(false); 39=> await _jsonRpc.NotifyWithParameterObjectAsync(methodName, @params).ConfigureAwait(false);

Handler\References\FindAllReferencesHandler.cs (2)

64await FindReferencesAsync(progress, workspace, document, linePosition, clientCapabilities.HasVisualStudioLspCapability(), includeDeclaration, _globalOptions, _metadataAsSourceFileService, _asyncListener, cancellationToken).ConfigureAwait(false); 89await findUsagesService.FindReferencesAsync(findUsagesContext, document, position, classificationOptions, cancellationToken).ConfigureAwait(false);

Handler\References\FindImplementationsHandler.cs (1)

55await findUsagesService.FindImplementationsAsync(findUsagesContext, document, position, classificationOptions, cancellationToken).ConfigureAwait(false);

Handler\References\FindUsagesLSPContext.cs (1)

103=> await _workQueue.WaitUntilCurrentBatchCompletesAsync().ConfigureAwait(false);

Handler\SemanticTokens\SemanticTokensHelpers.cs (3)

52await semanticTokensRefreshQueue.TryEnqueueRefreshComputationAsync(project, cancellationToken).ConfigureAwait(false); 95classifiedSpans, document, textSpans, options, cancellationToken).ConfigureAwait(false); 125classifiedSpans, document, textSpans, options, includeAdditiveSpans: true, cancellationToken).ConfigureAwait(false);

Handler\ServerLifetime\InitializedHandler.cs (1)

29await onInitialize.OnInitializedAsync(clientCapabilities, requestContext, cancellationToken).ConfigureAwait(false);

Handler\SourceGenerators\SourceGeneratorRefreshQueue.cs (1)

102await CheckDependentVersionsAsync(oldProject, newProject).ConfigureAwait(false);

Handler\SpellCheck\AbstractSpellCheckingHandler.cs (1)

77await HandleRemovedDocumentsAsync(context, previousResults, progress, cancellationToken).ConfigureAwait(false);

Handler\Symbols\WorkspaceSymbolsHandler.cs (1)

68await searcher.SearchAsync(NavigateToSearchScope.Solution, cancellationToken).ConfigureAwait(false);

Handler\Testing\WaitForAsyncOperationsHandler.cs (1)

45await _provider.WaitAllAsync(context.Solution!.Workspace, request.Operations).ConfigureAwait(false);

Handler\WorkDoneProgress\WorkDoneProgressManager.cs (1)

57await clientReporter.SendCreateRequestAsync().ConfigureAwait(false);

RoslynRequestExecutionQueue.cs (1)

32await requestTask.ConfigureAwait(false);

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\AbstractLanguageServer.cs (4)

267await lifeCycleManager.ShutdownAsync(message).ConfigureAwait(false); 305await lifeCycleManager.ExitAsync().ConfigureAwait(false); 344await ShutdownAsync(message: "Shutdown triggered by JsonRpc disconnect").ConfigureAwait(false); 345await ExitAsync().ConfigureAwait(false);

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\QueueItem.cs (2)

204await notificationHandler.HandleNotificationAsync(request, context, cancellationToken).ConfigureAwait(false); 211await parameterlessNotificationHandler.HandleNotificationAsync(context, cancellationToken).ConfigureAwait(false);

src\LanguageServer\Microsoft.CommonLanguageServerProtocol.Framework\RequestExecutionQueue.cs (6)

274await InvokeProcessCoreAsync(work, metadata, handler, methodInfo, concurrentlyExecutingTasks, currentWorkCts, cancellationToken).ConfigureAwait(false); 293await _languageServer.ShutdownAsync(message).ConfigureAwait(false); 294await _languageServer.ExitAsync().ConfigureAwait(false); 322await task.ConfigureAwait(false); 369await WrapStartRequestTaskAsync(work.StartRequestAsync<TRequest, TResponse>(deserializedRequest, context, handler, metadata.Language, cancellationToken), rethrowExceptions: true).ConfigureAwait(false); 472await _queue._queueProcessingTask.ConfigureAwait(false);

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (31)

Definitions\GoToTypeDefinitionTests.cs (1)

254await testLspServer.OpenDocumentAsync(results.Single().DocumentUri, text: string.Empty).ConfigureAwait(false);

Diagnostics\PullDiagnosticTests.cs (1)

1835await testLspServer.TestWorkspace.ChangeDocumentAsync(csproj3Document.Id, newCsProj3Document.Project.Solution).ConfigureAwait(false);

LanguageServerTargetTests.cs (3)

37await server.AssertServerShuttingDownAsync().ConfigureAwait(false); 50await server.AssertServerShuttingDownAsync().ConfigureAwait(false); 61await server.AssertServerShuttingDownAsync().ConfigureAwait(false);

Metadata\LspMetadataAsSourceWorkspaceTests.cs (3)

47await testLspServer.OpenDocumentAsync(definition.Single().DocumentUri, text: string.Empty).ConfigureAwait(false); 53await testLspServer.CloseDocumentAsync(definition.Single().DocumentUri).ConfigureAwait(false); 93""").ConfigureAwait(false);

Ordering\FailingMutatingRequestHandler.cs (1)

32await Task.Delay(Delay, cancellationToken).ConfigureAwait(false);

Ordering\FailingRequestHandler.cs (1)

32await Task.Delay(Delay, cancellationToken).ConfigureAwait(false);

Ordering\MutatingRequestHandler.cs (1)

37await Task.Delay(Delay, cancellationToken).ConfigureAwait(false);

Ordering\NonMutatingRequestHandler.cs (2)

37await Task.Delay(Delay, cancellationToken).ConfigureAwait(false); 42await Task.Delay(Delay, cancellationToken).ConfigureAwait(false);

Ordering\RequestOrderingTests.cs (1)

179await testLspServer.GetQueueAccessor()!.Value.WaitForProcessingToStopAsync().ConfigureAwait(false);

ProtocolConversionsTests.cs (1)

364""").ConfigureAwait(false);

SemanticTokens\SemanticTokensFullTests.cs (1)

64await VerifyBasicInvariantsAndNoMultiLineTokens(testLspServer, results.Data).ConfigureAwait(false);

SemanticTokens\SemanticTokensRangesTests.cs (1)

65await VerifyBasicInvariantsAndNoMultiLineTokens(testLspServer, results.Data).ConfigureAwait(false);

SemanticTokens\SemanticTokensRangeTests.cs (9)

UriTests.cs (5)

50""", languageId: "csharp").ConfigureAwait(false); 76""", languageId: "csharp").ConfigureAwait(false); 107await testLspServer.OpenDocumentAsync(expectedDocumentUri).ConfigureAwait(false); 300await testLspServer.OpenDocumentAsync(looseFileUri, "hello", languageId: "csharp").ConfigureAwait(false); 341await testLspServer.OpenDocumentAsync(invalidUri, string.Empty, languageId: "csharp").ConfigureAwait(false);

Microsoft.CodeAnalysis.LanguageServer.UnitTests (8)

FileBasedProgramsWorkspaceTests.cs (8)

89""").ConfigureAwait(false); 117""").ConfigureAwait(false); 140""").ConfigureAwait(false); 179""").ConfigureAwait(false); 216""").ConfigureAwait(false); 270""").ConfigureAwait(false); 313""").ConfigureAwait(false); 346""").ConfigureAwait(false);

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (20)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

Microsoft.CodeAnalysis.PublicApiAnalyzers (14)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

Microsoft.CodeAnalysis.Remote.ServiceHub (44)

Host\AssetProvider.cs (7)

51builder, cancellationToken).ConfigureAwait(false); 116await Task.WhenAll(tasks).ConfigureAwait(false); 123arg: allProjectStateChecksums, cancellationToken).ConfigureAwait(false); 173await Task.WhenAll(tasks).ConfigureAwait(false); 182freeArrayBuilder: false, cancellationToken).ConfigureAwait(false); 209await Task.WhenAll(tasks).ConfigureAwait(false); 240await this.GetAssetsAsync<TAsset>(assetPath, checksums, cancellationToken).ConfigureAwait(false);

Host\RemoteWorkspace.SolutionCreator.cs (7)

137await ValidateChecksumAsync(newSolutionChecksum, solution, newSolutionChecksums.ProjectConeId, cancellationToken).ConfigureAwait(false); 222cancellationToken).ConfigureAwait(false); 248assetPath: AssetPathKind.ProjectAttributes, projectItemChecksums, cancellationToken).ConfigureAwait(false); 255assetPath: AssetPathKind.ProjectCompilationOptions, projectItemChecksums, cancellationToken).ConfigureAwait(false); 461assetPath: new(AssetPathKind.DocumentAttributes, project.Id), newChecksumsToSync, cancellationToken).ConfigureAwait(false); 467assetPath: new(AssetPathKind.DocumentText, project.Id), newChecksumsToSync, cancellationToken).ConfigureAwait(false); 626await TestUtils.AssertChecksumsAsync(_assetProvider, checksumFromRequest, workspace.CurrentSolution, incrementalSolutionBuilt, projectConeId).ConfigureAwait(false);

Host\SolutionAssetCache.cs (1)

118await Task.Delay(_cleanupIntervalTimeSpan, cancellationToken).ConfigureAwait(false);

Host\TestUtils.cs (12)

Services\AssetSynchronization\RemoteAssetSynchronizationService.cs (1)

44await workspace.UpdatePrimaryBranchSolutionAsync(assetProvider, solutionChecksum, cancellationToken).ConfigureAwait(false);

Services\AsynchronousOperationListener\RemoteAsynchronousOperationListenerService.cs (1)

54await listenerProvider.WaitAllAsync(workspace, [.. featureNames]).ConfigureAwait(false);

Services\FindUsages\RemoteFindUsagesService.cs (2)

48context, symbol, project, options, classificationOptions, cancellationToken).ConfigureAwait(false); 71context, symbol, project, classificationOptions, cancellationToken).ConfigureAwait(false);

Services\KeepAlive\RemoteKeepAliveService.cs (1)

58await Task.Delay(Timeout.Infinite, cancellationToken).ConfigureAwait(false);

Services\NavigateToSearch\RemoteNavigateToSearchService.cs (4)

62document, searchPattern, kinds.ToImmutableHashSet(), onItemsFound, cancellationToken).ConfigureAwait(false); 83projects, priorityDocuments, searchPattern, kinds.ToImmutableHashSet(), onItemsFound, onProjectCompleted, cancellationToken).ConfigureAwait(false); 101projects, searchPattern, kinds.ToImmutableHashSet(), onItemsFound, onProjectCompleted, cancellationToken).ConfigureAwait(false); 121storageService, documentKeys, priorityDocumentKeys, searchPattern, kinds.ToImmutableHashSet(), onItemsFound, onProjectCompleted, cancellationToken).ConfigureAwait(false);

Services\SemanticClassification\RemoteSemanticClassificationService.Caching.cs (3)

118document, type, options, cancellationToken).ConfigureAwait(false); 156await classificationService.AddSemanticClassificationsAsync(document, fullSpan, options, classifiedSpans, cancellationToken).ConfigureAwait(false); 160await classificationService.AddEmbeddedLanguageClassificationsAsync(document, fullSpan, options, classifiedSpans, cancellationToken).ConfigureAwait(false);

Services\SemanticClassification\RemoteSemanticClassificationService.cs (1)

46document, spans, options, type, temp, cancellationToken).ConfigureAwait(false);

Services\SymbolFinder\RemoteSymbolFinderService.cs (2)

65documents, options, cancellationToken).ConfigureAwait(false); 77convertedType, solution, progressCallback, cancellationToken).ConfigureAwait(false);

Services\ValueTracking\RemoteValueTrackingService.cs (2)

40await ValueTracker.TrackValueSourceAsync(selection, document, progress, cancellationToken).ConfigureAwait(false); 63await ValueTracker.TrackValueSourceAsync(solution, previousItem, progress, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.Remote.Workspaces (14)

AbstractAssetProvider.cs (3)

52cancellationToken).ConfigureAwait(false); 95await SynchronizeProjectDocumentsAsync(projectChecksums, cancellationToken).ConfigureAwait(false); 160await Task.WhenAll(attributesTask, textTask).ConfigureAwait(false);

AbstractAssetProviderExtensions.cs (2)

42await assetProvider.GetAssetsAsync(assetPath, checksumSet, callback, arg, cancellationToken).ConfigureAwait(false); 67cancellationToken).ConfigureAwait(false);

ExportProviderBuilder.cs (1)

163await cachedComposition.SaveAsync(config, cacheStream, cancellationToken).ConfigureAwait(false);

RemoteCallback.cs (2)

118await Task.WhenAll(writeTask, readTask).ConfigureAwait(false); 119await readTask.ConfigureAwait(false);

RemoteHostAssetWriter.cs (1)

140await tempStream.CopyToAsync(_pipeWriter, cancellationToken).ConfigureAwait(false);

SolutionAssetProvider.cs (1)

54await writer.WriteDataAsync(cancellationToken).ConfigureAwait(false);

SolutionAssetStorage.Scope.cs (4)

55await FindAssetsAsync(assetPath, checksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false); 78await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false); 84await stateChecksums.FindAsync(solutionState, this.ProjectCone, assetPath, remainingChecksumsToFind, onAssetFound, arg, cancellationToken).ConfigureAwait(false); 110}, default(VoidResult), cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.ResxSourceGenerator (14)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

Microsoft.CodeAnalysis.Scripting (1)

ScriptExecutionState.cs (1)

94await precedingExecutors[executorIndex++](_submissionStates).ConfigureAwait(continueOnCapturedContext: false);

Microsoft.CodeAnalysis.Test.Utilities (1)

TempFiles\TempFile.cs (1)

86await sw.WriteAsync(content).ConfigureAwait(false);

Microsoft.CodeAnalysis.Threading.Package (12)

ProducerConsumer.cs (8)

TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

Microsoft.CodeAnalysis.Workspaces (177)

Classification\AbstractClassificationService.cs (3)

102document, textSpans, type, options, result, cancellationToken).ConfigureAwait(false); 151document, textSpans, options, getNodeClassifiers, getTokenClassifiers, result, cancellationToken).ConfigureAwait(false); 175document, textSpans, options, result, cancellationToken).ConfigureAwait(false);

Classification\ClassifierHelper.cs (4)

39.ConfigureAwait(false); 78await classificationService.AddSyntacticClassificationsAsync(document, spans, syntaxSpans, cancellationToken).ConfigureAwait(false); 82await classificationService.AddSemanticClassificationsAsync(document, spans, options, semanticSpans, cancellationToken).ConfigureAwait(false); 83await classificationService.AddEmbeddedLanguageClassificationsAsync(document, spans, options, semanticSpans, cancellationToken).ConfigureAwait(false);

CodeCleanup\AbstractCodeCleanerService.cs (1)

502await currentDocument.VerifyNoErrorsAsync("Pretty-listing introduced errors in error-free code", cancellationToken).ConfigureAwait(false);

CodeFixes\FixAllOccurrences\BatchFixAllProvider.cs (6)

58await FixSingleContextAsync(fixAllContext, progressTracker, docIdToTextMerger).ConfigureAwait(false); 83await AddDocumentChangesAsync(fixAllContext, progressTracker, docIdToTextMerger, documentToDiagnostics).ConfigureAwait(false); 128await MergeTextChangesAsync(fixAllContext, allChangedDocumentsInDiagnosticsOrder, docIdToTextMerger).ConfigureAwait(false); 159await registerTask.ConfigureAwait(false); 223async () => await textMerger.TryMergeChangesAsync(allDocChanges, cancellationToken).ConfigureAwait(false), cancellationToken)); 226await Task.WhenAll(tasks).ConfigureAwait(false);

CodeFixes\FixAllOccurrences\DocumentBasedFixAllProvider.cs (1)

95}).ConfigureAwait(false);

CodeFixes\FixAllOccurrences\TextChangeMerger.cs (1)

67await TryMergeChangesAsync(newDocument, cancellationToken).ConfigureAwait(false);

CodeFixesAndRefactorings\DocumentBasedFixAllProviderHelpers.cs (1)

90}).ConfigureAwait(false);

CodeRefactorings\FixAllOccurences\DocumentBasedRefactorAllProvider.cs (1)

102}).ConfigureAwait(false);

CodeRefactorings\SyntaxEditorBasedCodeRefactoringProvider.cs (1)

72await editAsync(editor).ConfigureAwait(false);

Editing\SymbolEditor.cs (2)

288await editAction(editor, declaration, cancellationToken).ConfigureAwait(false); 470await editAction(editor, decl, cancellationToken).ConfigureAwait(false);

ExtensionManager\IExtensionManagerExtensions.cs (1)

58await task.ConfigureAwait(false);

FindSymbols\Declarations\DeclarationFinder_AllDeclarations.cs (9)

FindSymbols\Declarations\DeclarationFinder_SourceDeclarations.cs (2)

184project, query, criteria, result, cancellationToken).ConfigureAwait(false); 197project, query, filter, result, cancellationToken).ConfigureAwait(false);

FindSymbols\FindLiterals\FindLiteralsSearchEngine.cs (5)

81await FindReferencesWorkerAsync(cancellationToken).ConfigureAwait(false); 93ProcessDocumentAsync).ConfigureAwait(false); 109await ProcessDocumentWorkerAsync(document, cancellationToken).ConfigureAwait(false); 128await SearchDocumentAsync(document, cancellationToken).ConfigureAwait(false); 133await SearchDocumentAsync(document, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\DependentProjectsFinder.cs (2)

191solution, symbolOrigination, dependentProjects, cancellationToken).ConfigureAwait(false); 196await AddSubmissionDependentProjectsAsync(solution, symbolOrigination.sourceProject, dependentProjects, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\DependentTypeFinder.cs (9)

FindSymbols\FindReferences\Finders\AbstractReferenceFinder.cs (2)

159project, documents, static (index, predefinedType) => index.ContainsPredefinedType(predefinedType), predefinedType, processResult, processResultData, cancellationToken).ConfigureAwait(false); 689await DetermineDocumentsToSearchAsync(typedSymbol, globalAliases, project, documents, processResult, processResultData, options, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\ConstructorSymbolReferenceFinder.cs (7)

67project, documents, typeName, processResult, processResultData, cancellationToken).ConfigureAwait(false); 74project, documents, globalAlias, processResult, processResultData, cancellationToken).ConfigureAwait(false); 79project, documents, containingType.SpecialType.ToPredefinedType(), processResult, processResultData, cancellationToken).ConfigureAwait(false); 82project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 87project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 102await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, typeName).ConfigureAwait(false); 105await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, simpleName).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\EventSymbolReferenceFinder.cs (2)

59await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 60await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\ExplicitConversionSymbolReferenceFinder.cs (2)

50await FindDocumentsAsync(project, documents, StandardCallbacks<Document>.AddToHashSet, result, cancellationToken, underlyingNamedType.Name).ConfigureAwait(false); 51await FindDocumentsAsync(project, documents, underlyingNamedType.SpecialType.ToPredefinedType(), StandardCallbacks<Document>.AddToHashSet, result, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\FieldSymbolReferenceFinder.cs (2)

39await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 40await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\NamedTypeSymbolReferenceFinder.cs (6)

63await AddDocumentsToSearchAsync(symbol.Name, project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 67await AddDocumentsToSearchAsync(alias, project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 71project, documents, symbol.SpecialType.ToPredefinedType(), processResult, processResultData, cancellationToken).ConfigureAwait(false); 74project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 92project, documents, processResult, processResultData, cancellationToken, throughName).ConfigureAwait(false); 95await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, simpleName).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\NamespaceSymbolReferenceFinder.cs (4)

37await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 39await FindDocumentsWithPredicateAsync(project, documents, static index => index.ContainsGlobalKeyword, processResult, processResultData, cancellationToken).ConfigureAwait(false); 46project, documents, processResult, processResultData, cancellationToken, globalAlias).ConfigureAwait(false); 50await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\OperatorSymbolReferenceFinder.cs (3)

32await FindDocumentsAsync(project, documents, op, processResult, processResultData, cancellationToken).ConfigureAwait(false); 33await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 48project, documents, static (index, op) => index.ContainsPredefinedOperator(op), op, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\OrdinaryMethodReferenceFinder.cs (7)

86await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, methodSymbol.Name).ConfigureAwait(false); 89await FindDocumentsWithForEachStatementsAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 92await FindDocumentsWithDeconstructionAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 95await FindDocumentsWithAwaitExpressionAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 98project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 101await FindDocumentsWithCollectionInitializersAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 104await FindDocumentsWithUsingStatementsAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\PreprocessingSymbolReferenceFinder.cs (1)

35cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\PropertyAccessorSymbolReferenceFinder.cs (3)

52await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 64cancellationToken).ConfigureAwait(false); 67await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\Finders\PropertySymbolReferenceFinder.cs (5)

117await FindDocumentsAsync(project, documents, processResult, processResultData, cancellationToken, symbol.Name).ConfigureAwait(false); 120await FindDocumentsWithForEachStatementsAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 123await FindDocumentWithExplicitOrImplicitElementAccessExpressionsAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 126await FindDocumentWithIndexerMemberCrefAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false); 128await FindDocumentsWithGlobalSuppressMessageAttributeAsync(project, documents, processResult, processResultData, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\FindReferencesSearchEngine.BidirectionalSymbolSet.cs (2)

58await AddDownSymbolsAsync(this.Engine, current, _allSymbols, workQueue, projects, cancellationToken).ConfigureAwait(false); 59await AddUpSymbolsAsync(this.Engine, current, _allSymbols, workQueue, projects, _includeImplementationsThroughDerivedTypes, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\FindReferencesSearchEngine.cs (7)

FindSymbols\FindReferences\FindReferencesSearchEngine.SymbolSet.cs (8)

FindSymbols\FindReferences\FindReferencesSearchEngine.UnidirectionalSymbolSet.cs (1)

53await AddDownSymbolsAsync(this.Engine, current, initialSymbols, workQueue, projects, cancellationToken).ConfigureAwait(false);

FindSymbols\FindReferences\FindReferencesSearchEngine_FindReferencesInDocuments.cs (2)

82await AddGlobalAliasesAsync(project, symbols, symbolToGlobalAliases, cancellationToken).ConfigureAwait(false); 159cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolFinder_Callers.cs (3)

55await AddReferencingSymbolsAsync(directReference, isDirect: true).ConfigureAwait(false); 60await AddReferencingSymbolsAsync(indirectReference, isDirect: false).ConfigureAwait(false); 90options, cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolFinder_FindLiteralReferences.cs (1)

40await FindLiteralReferencesInCurrentProcessAsync(value, solution, progress, cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolFinder_FindReferences_Current.cs (1)

66documents, options, cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolFinder_FindReferences_Legacy.cs (2)

47documents: null, options, cancellationToken).ConfigureAwait(false); 109options, cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolFinder_FindRenamableReferences.cs (1)

31await engine.FindReferencesAsync(symbols, cancellationToken).ConfigureAwait(false);

FindSymbols\SymbolTree\SymbolTreeInfoCacheService.cs (2)

134await AnalyzeProjectAsync(project, cancellationToken).ConfigureAwait(false); 156await Task.WhenAll(tasks).ConfigureAwait(false);

Remote\IRemoteKeepAliveService.cs (1)

95await WaitForSessionIdAsync(compilationState, projectId, client, session, callerCancellationToken).ConfigureAwait(false);

Rename\ConflictEngine\ConflictResolver.Session.cs (5)

224_cancellationToken).ConfigureAwait(false); 235await DebugVerifyNoErrorsAsync(conflictResolution, documentsIdsToBeCheckedForConflict).ConfigureAwait(false); 296await changeDoc.VerifyNoErrorsAsync("Rename introduced errors in error-free code", _cancellationToken, ignoreErrorCodes).ConfigureAwait(false); 462projectId, renamedSymbolInNewSolution, renameSymbol, referencedSymbols, conflictResolution, reverseMappedLocations, _cancellationToken).ConfigureAwait(false); 702await AddDocumentsWithPotentialConflictsAsync(documentsFromAffectedProjects, documentIds, possibleNameConflicts).ConfigureAwait(false);

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (2)

353stringLocations, cancellationToken).ConfigureAwait(false); 358await AddLocationsToRenameInCommentsAsync(document, renameText, commentLocations, cancellationToken).ConfigureAwait(false);

Shared\TestHooks\AsynchronousOperationListener.cs (1)

193await Task.Delay(TimeSpan.FromMilliseconds(10)).ConfigureAwait(false);

Shared\TestHooks\AsynchronousOperationListenerProvider.cs (1)

170await Task.Delay(smallTimeout).ConfigureAwait(continueOnCapturedContext);

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

Storage\SQLite\v2\SQLitePersistentStorage_FlushWrites.cs (1)

29await PerformWriteAsync(_flushInMemoryDataToDisk, cancellationToken).ConfigureAwait(false);

Telemetry\TelemetryLogging.cs (1)

140await Task.Delay(TimeSpan.FromMinutes(30), cancellationToken).ConfigureAwait(false);

Workspace\Host\TemporaryStorage\LegacyTemporaryStorageService.cs (1)

73await stream.CopyToAsync(newStream, cancellationToken).ConfigureAwait(false);

Workspace\ProjectSystem\FileWatchedPortableExecutableReferenceFactory.cs (1)

197await _callback(filePath, cancellationToken).ConfigureAwait(false);

Workspace\ProjectSystem\ProjectSystemProject.BatchingDocumentCollection.cs (1)

445}, onAfterUpdateAlways: null).ConfigureAwait(false);

Workspace\ProjectSystem\ProjectSystemProject.cs (3)

556await _project.OnBatchScopeDisposedMaybeAsync(useAsync: true).ConfigureAwait(false); 652}).ConfigureAwait(false); 665await _projectSystemProjectFactory.RaiseOnDocumentsAddedMaybeAsync(useAsync, documentFileNamesAdded).ConfigureAwait(false);

Workspace\ProjectSystem\ProjectSystemProjectFactory.cs (2)

296await ApplyBatchChangeToWorkspaceMaybe_NoLockAsync(useAsync, mutation, onAfterUpdateAlways).ConfigureAwait(false); 931}, onAfterUpdateAlways).ConfigureAwait(false);

Workspace\Solution\ChecksumCollection.cs (2)

71await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false); 84await stateChecksums.FindAsync(assetPath, state, searchingChecksumsLeft, onAssetFound, arg, cancellationToken).ConfigureAwait(false);

Workspace\Solution\StateChecksums.cs (8)

Workspace\Solution\TextLoader.cs (1)

123await Task.Delay(RetryDelay, cancellationToken).ConfigureAwait(false);

Workspace\Solution\VersionSource\RecoverableTextAndVersion.RecoverableText.cs (1)

148await recoverableText.SaveAsync(sourceText, cancellationToken).ConfigureAwait(false);

Workspace\Workspace.cs (2)

605await ScheduleTask(EventArgs.Empty, handlerSet).ConfigureAwait(false); 733}, cancellationToken, TaskCreationOptions.None, _taskSchedulerProvider.CurrentContextScheduler).ConfigureAwait(false);

Microsoft.CodeAnalysis.Workspaces.MSBuild (5)

MSBuild\BuildHostProcessManager.cs (4)

118await buildHostProcess.ConnectAsync(pipeName).ConfigureAwait(false); 130await buildHostProcess.BuildHost.ConfigureGlobalStateAsync(_globalMSBuildProperties, _binaryLogPathProvider?.GetNewLogPath(), cancellationToken).ConfigureAwait(false); 458await pipeClient.ConnectAsync(timeout: 60_000).ConfigureAwait(false); 504await BuildHost.ShutdownAsync(CancellationToken.None).ConfigureAwait(false);

Rpc\RpcClient.cs (1)

175await _stream.WriteAsync(requestJsonBytes, 0, requestJsonBytes.Length, cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (7)

Program.cs (2)

40await pipeServer.WaitForConnectionAsync().ConfigureAwait(false); 47await server.RunAsync().ConfigureAwait(false);

Rpc\RpcServer.cs (4)

100await Task.WhenAll(remainingTasks).ConfigureAwait(false); 142await task.ConfigureAwait(false); 176await _streamWriter.WriteLineAsync(responseJson).ConfigureAwait(false); 177await _streamWriter.FlushAsync().ConfigureAwait(false);

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (4)

src\Workspaces\MSBuild\BuildHost\Rpc\RpcServer.cs (4)

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)

AsynchronousOperationListenerExtensions.cs (1)

14await ((AsynchronousOperationListenerProvider)provider).WaitAllAsync(workspace, featureNames).ConfigureAwait(false);

Microsoft.CommonLanguageServerProtocol.Framework.Package (12)

AbstractLanguageServer.cs (4)

QueueItem.cs (2)

RequestExecutionQueue.cs (6)

Microsoft.DotNet.Arcade.Sdk (2)

src\DownloadFile.cs (2)

200await httpResponse.Content.CopyToAsync(outStream).ConfigureAwait(false); 224await Tasks.Task.Delay(RetryDelayMilliseconds).ConfigureAwait(false);

Microsoft.DotNet.Build.Tasks.Feed (3)

src\AzureStorageExtensions.cs (1)

68await download.Content.CopyToAsync(stream).ConfigureAwait(false);

src\PublishArtifactsInManifestBase.cs (1)

1549await Task.Delay(RetryDelayMilliseconds * attemptIndex).ConfigureAwait(false);

src\SemaphoreLock.cs (1)

38await waitTask.ConfigureAwait(false);

Microsoft.DotNet.Helix.Client (82)

generated-code\Aggregate.cs (22)

generated-code\Analysis.cs (3)

122await OnSetReasonFailed(_req, _res).ConfigureAwait(false); 214await OnGetDetailsFailed(_req, _res).ConfigureAwait(false); 219await OnGetDetailsFailed(_req, _res).ConfigureAwait(false);

generated-code\Information.cs (6)

87await OnQueueInfoFailed(_req, _res).ConfigureAwait(false); 92await OnQueueInfoFailed(_req, _res).ConfigureAwait(false); 161await OnQueueInfoListFailed(_req, _res).ConfigureAwait(false); 166await OnQueueInfoListFailed(_req, _res).ConfigureAwait(false); 230await OnDeployed1esImagesInfoListFailed(_req, _res).ConfigureAwait(false); 235await OnDeployed1esImagesInfoListFailed(_req, _res).ConfigureAwait(false);

generated-code\Job.cs (14)

generated-code\LogSearch.cs (2)

109await OnDoBuildSearchFailed(_req, _res).ConfigureAwait(false); 199await OnDoTestLogSearchFailed(_req, _res).ConfigureAwait(false);

generated-code\Machine.cs (3)

98await OnChangeStateFailed(_req, _res).ConfigureAwait(false); 170await OnGetMachineStatusFailed(_req, _res).ConfigureAwait(false); 175await OnGetMachineStatusFailed(_req, _res).ConfigureAwait(false);

generated-code\ScaleSets.cs (4)

82await OnGetDetailedVMScalingHistoryFailed(_req, _res).ConfigureAwait(false); 87await OnGetDetailedVMScalingHistoryFailed(_req, _res).ConfigureAwait(false); 156await OnGetAggregatedVMScalingHistoryFailed(_req, _res).ConfigureAwait(false); 161await OnGetAggregatedVMScalingHistoryFailed(_req, _res).ConfigureAwait(false);

generated-code\Storage.cs (6)

81await OnListFailed(_req, _res).ConfigureAwait(false); 86await OnListFailed(_req, _res).ConfigureAwait(false); 167await OnNewFailed(_req, _res).ConfigureAwait(false); 172await OnNewFailed(_req, _res).ConfigureAwait(false); 253await OnExtendExpirationFailed(_req, _res).ConfigureAwait(false); 258await OnExtendExpirationFailed(_req, _res).ConfigureAwait(false);

generated-code\Telemetry.cs (11)

generated-code\WorkItem.cs (10)

Job.cs (1)

20for (;; await Task.Delay(pollingIntervalMs, cancellationToken).ConfigureAwait(false)) // delay every time this loop repeats

Microsoft.DotNet.Helix.Sdk (2)

AzureDevOpsTask.cs (1)

262await Task.Delay(GetRetryDelay(attempt)).ConfigureAwait(false);

WaitForHelixJobCompletion.cs (1)

50for (; ; await Task.Delay(20000, cancellationToken).ConfigureAwait(false)) // delay every time this loop repeats

Microsoft.DotNet.Internal.SymbolHelper (3)

SymbolUploadHelper.cs (2)

296await entryStream.CopyToAsync(entryFile).ConfigureAwait(false); 489await processExit.ConfigureAwait(false);

SymbolUploadHelperFactory.cs (1)

162await zipStream.CopyToAsync(fileStream, token).ConfigureAwait(false);

Microsoft.Extensions.AI.Abstractions (9)

Functions\AIFunctionFactory.cs (9)

Microsoft.Extensions.AI.Evaluation (1)

Utilities\TimingHelper.cs (1)

56await operation().ConfigureAwait(false);

Microsoft.Extensions.AI.Evaluation.Console (4)

Program.cs (1)

43await logger.DisplayTelemetryOptOutMessageIfNeededAsync().ConfigureAwait(false);

src\Libraries\Microsoft.Extensions.AI.Evaluation\Utilities\TimingHelper.cs (1)

56await operation().ConfigureAwait(false);

Telemetry\TelemetryConstants.cs (1)

167await File.WriteAllBytesAsync(_firstUseSentinelFilePath, []).ConfigureAwait(false);

Utilities\LoggerExtensions.cs (1)

59await operation().ConfigureAwait(false);

Microsoft.Extensions.AI.Evaluation.NLP (1)

src\Libraries\Microsoft.Extensions.AI.Evaluation\Utilities\TimingHelper.cs (1)

56await operation().ConfigureAwait(false);

Microsoft.Extensions.AI.Evaluation.Quality (1)

src\Libraries\Microsoft.Extensions.AI.Evaluation\Utilities\TimingHelper.cs (1)

56await operation().ConfigureAwait(false);

Microsoft.Extensions.AI.Evaluation.Reporting (14)

Formats\Html\HtmlReportWriter.cs (5)

49await writer.WriteAsync(HtmlTemplateBefore.AsMemory(), cancellationToken).ConfigureAwait(false); 50await writer.FlushAsync(cancellationToken).ConfigureAwait(false); 60cancellationToken).ConfigureAwait(false); 63await writer.WriteAsync(HtmlTemplateAfter.AsMemory(), cancellationToken).ConfigureAwait(false); 64await writer.FlushAsync(cancellationToken).ConfigureAwait(false);

Formats\Json\JsonReportWriter.cs (1)

49cancellationToken).ConfigureAwait(false);

ResponseCachingChatClient.cs (2)

100await base.WriteCacheAsync(key, value, cancellationToken).ConfigureAwait(false); 125await base.WriteCacheStreamingAsync(key, value, cancellationToken).ConfigureAwait(false);

Storage\DiskBasedResponseCache.CacheEntry.cs (1)

77cancellationToken).ConfigureAwait(false);

Storage\DiskBasedResponseCache.cs (4)

84await RemoveAsync(key, cancellationToken).ConfigureAwait(false); 169await entry.WriteAsync(entryFilePath, cancellationToken: cancellationToken).ConfigureAwait(false); 209await entry.WriteAsync(entryFilePath, cancellationToken: cancellationToken).ConfigureAwait(false); 212await File.WriteAllBytesAsync(contentsFilePath, value, cancellationToken).ConfigureAwait(false);

Storage\DiskBasedResultStore.cs (1)

105cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.AI.Evaluation.Reporting.Azure (5)

Storage\AzureStorageResponseCache.CacheEntry.cs (1)

90cancellationToken).ConfigureAwait(false);

Storage\AzureStorageResponseCache.cs (3)

78await RemoveAsync(key, cancellationToken).ConfigureAwait(false); 127await entry.WriteAsync(entryClient, cancellationToken: cancellationToken).ConfigureAwait(false); 177await entry.WriteAsync(entryClient, cancellationToken: cancellationToken).ConfigureAwait(false);

Storage\AzureStorageResultStore.cs (1)

170cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.AI.Evaluation.Safety (2)

ContentSafetyService.cs (1)

385await Task.Delay(InitialDelayInMilliseconds * attempts, cancellationToken).ConfigureAwait(false);

src\Libraries\Microsoft.Extensions.AI.Evaluation\Utilities\TimingHelper.cs (1)

56await operation().ConfigureAwait(false);

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.Caching.Hybrid (1)

Internal\DefaultHybridCache.StampedeStateT.cs (1)

311await System.Threading.Tasks.Task.Delay(1, CancellationToken.None).ConfigureAwait(false);

Microsoft.Extensions.Caching.SqlServer (7)

DatabaseOperations.cs (3)

73await connection.OpenAsync(token).ConfigureAwait(false); 188await connection.OpenAsync(token).ConfigureAwait(false); 284await connection.OpenAsync(token).ConfigureAwait(false);

SqlServerCache.cs (4)

141await _dbOperations.RefreshCacheItemAsync(key, token).ConfigureAwait(false); 163await _dbOperations.DeleteCacheItemAsync(key, token).ConfigureAwait(false); 210await _dbOperations.SetCacheItemAsync(key, new(value), options, token).ConfigureAwait(false); 228await _dbOperations.SetCacheItemAsync(key, Linearize(value, out var lease), options, token).ConfigureAwait(false);

Microsoft.Extensions.Caching.StackExchangeRedis (5)

RedisCache.cs (5)

231await cache.HashSetAsync(prefixedKey, fields).ConfigureAwait(false); 238).ConfigureAwait(false); 329await _connectionLock.WaitAsync(token).ConfigureAwait(false); 455await RefreshAsync(cache, key, absExpr, sldExpr.GetValueOrDefault(), token).ConfigureAwait(false); 781await RefreshAsync(cache, key, absExpr, sldExpr.GetValueOrDefault(), token).ConfigureAwait(false);

Microsoft.Extensions.DataIngestion (7)

IngestionPipeline.cs (1)

190await _writer.WriteAsync(chunks, cancellationToken).ConfigureAwait(false);

Processors\ImageAlternativeTextEnricher.cs (3)

53await ProcessAsync(batch, cancellationToken).ConfigureAwait(false); 69await ProcessAsync(batch, cancellationToken).ConfigureAwait(false); 79await ProcessAsync(batch, cancellationToken).ConfigureAwait(false);

Writers\VectorStoreWriter.cs (3)

70await _vectorStoreCollection.EnsureCollectionExistsAsync(cancellationToken).ConfigureAwait(false); 96await _vectorStoreCollection.UpsertAsync(record, cancellationToken).ConfigureAwait(false); 101await _vectorStoreCollection!.DeleteAsync(preExistingKeys, cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.DataIngestion.MarkItDown (3)

MarkItDownMcpReader.cs (1)

76await source.CopyToAsync(ms, cancellationToken).ConfigureAwait(false);

MarkItDownReader.cs (2)

81await process.WaitForExitAsync(cancellationToken).ConfigureAwait(false); 117.ConfigureAwait(false);

Microsoft.Extensions.Diagnostics.HealthChecks (4)

HealthCheckPublisherHostedService.cs (4)

130await RunAsync(timerOptions).ConfigureAwait(false); 158await RunAsyncCore(timerOptions, cancellation.Token).ConfigureAwait(false); 201await Task.WhenAll(tasks).ConfigureAwait(false); 212await publisher.PublishAsync(report, cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.Diagnostics.HealthChecks.Tests (1)

DefaultHealthCheckServiceTest.cs (1)

567await Task.Delay(1).ConfigureAwait(false);

Microsoft.Extensions.Diagnostics.Probes (2)

TcpEndpointProbesService.cs (2)

74await UpdateHealthStatusAsync(stoppingToken).ConfigureAwait(false); 75await TimeProvider.Delay(_options.HealthAssessmentPeriod, stoppingToken).ConfigureAwait(false);

Microsoft.Extensions.Diagnostics.ResourceMonitoring (2)

ResourceMonitorService.cs (2)

127await _timeProvider.Delay(_samplingInterval, cancellationToken).ConfigureAwait(false); 143await PublishUtilizationAsync(cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.Diagnostics.Testing (1)

Metrics\MetricCollector.cs (1)

258await WaitForMeasurementsAsync(minCount, cancellationTokenSource.Token).ConfigureAwait(false);

Microsoft.Extensions.Hosting (12)

Internal\Host.cs (12)

Microsoft.Extensions.Hosting.Abstractions (5)

HostingAbstractionsHostBuilderExtensions.cs (1)

33await host.StartAsync(cancellationToken).ConfigureAwait(false);

HostingAbstractionsHostExtensions.cs (4)

35await host.StopAsync(cts.Token).ConfigureAwait(false); 67await host.StartAsync(token).ConfigureAwait(false); 69await host.WaitForShutdownAsync(token).ConfigureAwait(false); 115await host.StopAsync(CancellationToken.None).ConfigureAwait(false);

Microsoft.Extensions.Hosting.Testing (8)

FakeHost.cs (4)

74await _host.StartAsync(cancellationTokenSource.Token).ConfigureAwait(false); 81await _host.StartAsync(linkedTokenSource.Token).ConfigureAwait(false); 97await _host.StopAsync(cancellationTokenSource.Token).ConfigureAwait(false); 104await _host.StopAsync(linkedTokenSource.Token).ConfigureAwait(false);

FakeHostingExtensions.cs (2)

38await service.StartAsync(cancellationToken).ConfigureAwait(false); 42await service.StopAsync(cancellationToken).ConfigureAwait(false);

HostTerminatorService.cs (2)

50await TimeProvider.Delay(_options.TimeToLive, stoppingToken).ConfigureAwait(false); 59await _host.StopAsync(combinedTokenSource.Token).ConfigureAwait(false);

Microsoft.Extensions.Hosting.WindowsServices (1)

WindowsServiceLifetime.cs (1)

129await Task.Run(Stop, cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.Http.Diagnostics (2)

Logging\Internal\HttpClientLogger.cs (2)

79await _httpRequestReader.ReadRequestAsync(logRecord, request, requestHeadersBuffer, cancellationToken).ConfigureAwait(false); 179await _httpRequestReader.ReadResponseAsync(logRecord, response, responseHeadersBuffer, cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.Http.Diagnostics.Tests (1)

Logging\HttpClientLoggingExtensionsTest.cs (1)

215var act = async () => await host.StartAsync().ConfigureAwait(false);

Microsoft.Extensions.Http.Polly.Tests (1)

PolicyHttpMessageHandlerTest.cs (1)

387await Task.Delay(1).ConfigureAwait(false);

Microsoft.Extensions.Identity.Core (58)

RoleManager.cs (7)

164await UpdateNormalizedRoleNameAsync(role).ConfigureAwait(false); 179await Store.SetNormalizedRoleNameAsync(role, NormalizeKey(name), CancellationToken).ConfigureAwait(false); 279await Store.SetRoleNameAsync(role, name, CancellationToken).ConfigureAwait(false); 280await UpdateNormalizedRoleNameAsync(role).ConfigureAwait(false); 330await claimStore.AddClaimAsync(role, claim, CancellationToken).ConfigureAwait(false); 349await claimStore.RemoveClaimAsync(role, claim, CancellationToken).ConfigureAwait(false); 432await UpdateNormalizedRoleNameAsync(role).ConfigureAwait(false);

UserManager.cs (51)

Microsoft.Extensions.Identity.Stores (3)

UserStoreBase.cs (3)

838await AddUserTokenAsync(CreateUserToken(user, loginProvider, name, value)).ConfigureAwait(false); 863await RemoveUserTokenAsync(entry).ConfigureAwait(false); 979await ReplaceCodesAsync(user, updatedCodes, cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.Logging.AzureAppServices (4)

BatchingLoggerProvider.cs (2)

110await WriteMessagesAsync(_currentBatch, _cancellationTokenSource.Token).ConfigureAwait(false); 121await IntervalAsync(_interval, _cancellationTokenSource.Token).ConfigureAwait(false);

BlobLoggerProvider.cs (1)

82await blob.AppendAsync(buffer, cancellationToken).ConfigureAwait(false);

FileLoggerProvider.cs (1)

56await streamWriter.WriteAsync(item.Message).ConfigureAwait(false);

Microsoft.Extensions.ServiceDiscovery (9)

Http\HttpServiceEndpointResolver.cs (4)

150await Task.WhenAll(cleanupTasks).ConfigureAwait(false); 225await DisposeAsyncCore().ConfigureAwait(false); 242await DisposeAsyncCore().ConfigureAwait(false); 246await _onDisposed.Task.ConfigureAwait(false);

ServiceEndpointResolver.cs (4)

159await Task.WhenAll(cleanupTasks).ConfigureAwait(false); 217await DisposeAsyncCore().ConfigureAwait(false); 234await DisposeAsyncCore().ConfigureAwait(false); 238await _onDisposed.Task.ConfigureAwait(false);

ServiceEndpointWatcher.cs (1)

85await RefreshAsync(force: false).WaitAsync(cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.ServiceDiscovery.Dns (1)

DnsServiceEndpointProviderBase.cs (1)

83await resolveTask.WaitAsync(cancellationToken).ConfigureAwait(false);

Microsoft.Extensions.ServiceDiscovery.Tests (1)

ServiceEndpointResolverTests.cs (1)

219await sem.WaitAsync(ct).ConfigureAwait(false);

Microsoft.Extensions.TimeProvider.Testing.Tests (1)

FakeTimeProviderTests.cs (1)

558await provider.Delay(TimeSpan.FromSeconds(delay)).ConfigureAwait(false);

Microsoft.Gen.BuildMetadata.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Gen.ComplianceReports.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Gen.ContextualOptions.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Gen.Logging.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Gen.MetadataExtractor.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Gen.Metrics.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Gen.MetricsReports.Unit.Tests (1)

test\Generators\Shared\RoslynTestUtils.cs (1)

487await fixer.RegisterCodeFixesAsync(context).ConfigureAwait(false);

Microsoft.Interop.ComInterfaceGenerator (3)

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (3)

110await documentBasedFix(docEditor, ct).ConfigureAwait(false); 153await fix.ApplyFix(editor, ct).ConfigureAwait(false); 206await documentBasedFix(editor, ct).ConfigureAwait(false);

Microsoft.Interop.LibraryImportGenerator (3)

src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (3)

110await documentBasedFix(docEditor, ct).ConfigureAwait(false); 153await fix.ApplyFix(editor, ct).ConfigureAwait(false); 206await documentBasedFix(editor, ct).ConfigureAwait(false);

Microsoft.Maui (2)

Dispatching\DispatcherExtensions.cs (1)

88 await funcTask().ConfigureAwait(false);

TaskExtensions.cs (1)

36 await task.ConfigureAwait(false);

Microsoft.Maui.Controls (14)

Internals\ImageParser.cs (12)

Platform\ModalNavigationManager\ModalNavigationManager.cs (1)

191 await SyncModalStackWhenPlatformIsReadyAsync().ConfigureAwait(false);

Shell\Shell.cs (1)

1277 await OnFlyoutItemSelectedAsync(shellItem, false).ConfigureAwait(false);

Microsoft.Maui.Essentials (1)

MainThread\MainThread.shared.cs (1)

115 await funcTask().ConfigureAwait(false);

Microsoft.Maui.Maps (1)

src\Core\src\TaskExtensions.cs (1)

36 await task.ConfigureAwait(false);

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.Tests (1)

DatasetUtil.cs (1)

215await stream.CopyToAsync(fileStream).ConfigureAwait(false);

Microsoft.ML.Samples (1)

Dynamic\TensorFlow\ImageClassification.cs (1)

128await response.CopyToAsync(fs).ConfigureAwait(false);

Microsoft.ML.Samples.GPU (1)

docs\samples\Microsoft.ML.Samples\Dynamic\TensorFlow\ImageClassification.cs (1)

128await response.CopyToAsync(fs).ConfigureAwait(false);

Microsoft.ML.SamplesUtils (1)

SamplesDatasetUtils.cs (1)

201await response.CopyToAsync(fs).ConfigureAwait(false);

Microsoft.ML.Tokenizers.Data.Tests (2)

src\Common\tests\RetryHelper.cs (2)

94await test().ConfigureAwait(false); 106await Task.Delay((backoffFunc ?? _defaultBackoffFunc)(i)).ConfigureAwait(false);

Microsoft.ML.Tokenizers.Tests (2)

src\Common\tests\RetryHelper.cs (2)

94await test().ConfigureAwait(false); 106await Task.Delay((backoffFunc ?? _defaultBackoffFunc)(i)).ConfigureAwait(false);

Microsoft.VisualBasic.Forms.Tests (2)

System\Windows\Forms\SingleInstanceHelpersTests.vb (2)

65.ConfigureAwait(continueOnCapturedContext:=False) 79Await tokenSource.CancelAsync().ConfigureAwait(continueOnCapturedContext:=True)

Microsoft.VisualBasic.Tests (1)

Microsoft\VisualBasic\ApplicationServices\SingleInstanceTests.cs (1)

62var awaitable = SendSecondInstanceArgsAsync(pipeName, args, tokenSource.Token).ConfigureAwait(false);

Microsoft.VisualStudio.Extensibility.Testing.Xunit (11)

src\VisualStudio\IntegrationTest\Harness\XUnitShared\Harness\IdeTestAssemblyRunner.cs (2)

36await base.AfterTestAssemblyStartingAsync().ConfigureAwait(false); 45await base.BeforeTestAssemblyFinishedAsync().ConfigureAwait(true);

src\VisualStudio\IntegrationTest\Harness\XUnitShared\Harness\VisualStudioInstanceFactory.cs (2)

85await UpdateCurrentlyRunningInstanceAsync(version, rootSuffix, environmentVariables, extensionFiles, requiredPackageIds, shouldStartNewInstance).ConfigureAwait(false); 476await Task.Delay(ReportTimeInterval, cancellationToken).ConfigureAwait(false);

src\VisualStudio\IntegrationTest\Harness\XUnitShared\Threading\InProcessIdeTestInvoker.cs (7)

41await asyncLifetime.InitializeAsync().ConfigureAwait(true); 51await BeforeTestMethodInvokedAsync().ConfigureAwait(true); 57await AfterTestMethodInvokedAsync().ConfigureAwait(true); 66await asyncLifetime.DisposeAsync().ConfigureAwait(true); 72}).ConfigureAwait(true); 179await task.ConfigureAwait(true); 196})).ConfigureAwait(true);

Microsoft.VisualStudio.LanguageServices (110)

CallHierarchy\Finders\AbstractCallFinder.cs (2)

68await SearchAsync(workspace, searchScope, callback, _cancellationSource.Token).ConfigureAwait(false); 113await SearchWorkerAsync(symbol, project, callback, documents, cancellationToken).ConfigureAwait(false);

CodeCleanup\AbstractCodeCleanUpFixer.cs (1)

177await workspaceStatusService.WaitUntilFullyLoadedAsync(context.OperationContext.UserCancellationToken).ConfigureAwait(true);

CodeLens\CodeLensCallbackListener.cs (1)

201await EnsureMaxResultAsync(cancellationToken).ConfigureAwait(false);

DesignerAttribute\VisualStudioDesignerAttributeService.cs (5)

118await statusService.WaitUntilFullyLoadedAsync(cancellationToken).ConfigureAwait(false); 135solution, trackingService.GetActiveDocument(solution), client, _listener, this, cancellationToken).ConfigureAwait(false); 180await task.ConfigureAwait(false); 258await NotifyCpsProjectSystemAsync(updateService, info, cancellationToken).ConfigureAwait(false); 271await updateService.SetProjectItemDesignerTypeAsync(data.FilePath, data.Category).ConfigureAwait(false);

FindReferences\Contexts\AbstractTableDataSourceFindUsagesContext.cs (2)

358await OnCompletedAsyncWorkerAsync(cancellationToken).ConfigureAwait(false); 543await this.Presenter.ReportMessageAsync(message, severity, cancellationToken).ConfigureAwait(false);

FindReferences\Contexts\WithoutReferencesFindUsagesContext.cs (1)

105await AddDocumentSpanEntriesAsync(entries, definitionBucket, definition, cancellationToken).ConfigureAwait(false);

FindReferences\Contexts\WithReferencesFindUsagesContext.cs (7)

54await AddDeclarationEntriesAsync(definition, expandedByDefault: true, cancellationToken).ConfigureAwait(false); 78await AddDocumentSpanEntriesAsync(entries, definitionBucket, definition, cancellationToken).ConfigureAwait(false); 155await AddDeclarationEntriesAsync(definition, expandedByDefault, cancellationToken).ConfigureAwait(false); 188await CreateMissingReferenceEntriesIfNecessaryAsync(cancellationToken).ConfigureAwait(false); 189await CreateNoResultsFoundEntryIfNecessaryAsync(cancellationToken).ConfigureAwait(false); 194await CreateMissingReferenceEntriesIfNecessaryAsync(whenGroupingByDefinition: true, cancellationToken).ConfigureAwait(false); 195await CreateMissingReferenceEntriesIfNecessaryAsync(whenGroupingByDefinition: false, cancellationToken).ConfigureAwait(false);

FindReferences\FindReferencesTableControlEventProcessorProvider.cs (1)

86await supportsNavigation.NavigateToAsync(options, context.UserCancellationToken).ConfigureAwait(false);

Interactive\VsInteractiveWindowPackage.cs (1)

39await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);

Interop\CleanableWeakComHandleTable.cs (5)

79await CollectDeadKeysAsync().ConfigureAwait(true); 80await RemoveDeadKeysAsync().ConfigureAwait(true); 103await ResetTimeSliceAsync().ConfigureAwait(true); 109await RemoveDeadKeysAsync().ConfigureAwait(true); 132await ResetTimeSliceAsync().ConfigureAwait(true);

KeybindingReset\KeybindingResetDetector.cs (4)

175await UpdateStateMachineWorkerAsync(cancellationToken).ConfigureAwait(false); 279await EnsureOleCommandTargetAsync().ConfigureAwait(false); 314await Task.Delay(TimeSpan.FromSeconds(2), cancellationToken).ConfigureAwait(false); 329await ShutdownAsync().ConfigureAwait(false);

LanguageService\AbstractCreateServicesOnTextViewConnection.cs (1)

98await InitializeServiceForProjectWithOpenedDocumentAsync(project).ConfigureAwait(false);

LanguageService\AbstractPackage`2.cs (1)

94await RegisterEditorFactoryAsync(editorFactory, cancellationToken).ConfigureAwait(true);

LanguageService\PackageLoadTasks.cs (4)

41await PerformWorkAsync(isMainThreadTask: false, cancellationToken).ConfigureAwait(false); 46await PerformWorkAsync(isMainThreadTask: true, cancellationToken).ConfigureAwait(false); 47await PerformWorkAsync(isMainThreadTask: false, cancellationToken).ConfigureAwait(false); 71await work(this, cancellationToken).ConfigureAwait(true);

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (19)

Library\ObjectBrowser\AbstractObjectBrowserLibraryManager.cs (2)

524await FindReferencesAsync(symbolListItem, project, context, classificationOptions, cancellationToken).ConfigureAwait(false); 549await AbstractFindUsagesService.FindSymbolReferencesAsync(context, symbol, project, classificationOptions, cancellationToken).ConfigureAwait(false);

NavigateTo\RoslynSearchItemsSource.cs (1)

104await searcher.SearchAsync(searchScope, cancellationToken).ConfigureAwait(false);

Packaging\PackageInstallerServiceFactory.cs (7)

308await UpdateStatusBarAsync(dte, description, cancellationToken).ConfigureAwait(false); 339cancellationToken).ConfigureAwait(false); 346await UpdateStatusBarAsync(dte, ServicesVSResources.Package_install_canceled, cancellationToken).ConfigureAwait(false); 380await UpdateStatusBarAsync(dte, description, cancellationToken).ConfigureAwait(false); 400dte, string.Format(ServicesVSResources.Uninstalling_0_completed, GetStatusBarText(packageName, installedVersion)), cancellationToken).ConfigureAwait(false); 407await UpdateStatusBarAsync(dte, ServicesVSResources.Package_uninstall_canceled, cancellationToken).ConfigureAwait(false); 488await ProcessProjectChangeAsync(nugetService, solution, projectId, cancellationToken).ConfigureAwait(false);

Packaging\PackageInstallerServiceFactory_UndoRedo.cs (1)

106await DoWorkerAsync(pUndoManager).ConfigureAwait(false);

ProjectSystem\FileChangeWatcher.cs (1)

311await service.FilterDirectoryChangesAsync(cookie, [.. _filters], cancellationToken).ConfigureAwait(false);

ProjectSystem\Legacy\SolutionEventsBatchScopeCreator.cs (1)

199await _scopeCreator.StopTrackingAllProjectsAsync().WithCancellation(cancellationToken).ConfigureAwait(false);

ProjectSystem\VisualStudioProjectFactory.cs (2)

82await _initializationTask.JoinAsync(cancellationToken).ConfigureAwait(true); 98await _visualStudioWorkspaceImpl.RefreshProjectExistsUIContextForLanguageAsync(language, cancellationToken).ConfigureAwait(true);

ProjectSystem\VisualStudioWorkspaceImpl.cs (2)

1584await RefreshProjectExistsUIContextForLanguageAsync(project.Language, cancellationToken).ConfigureAwait(false); 1610await _updateUIContextJoinableTasks.JoinTillEmptyAsync(cancellationToken).ConfigureAwait(false);

RoslynPackage.cs (12)

Snippets\AbstractSnippetInfoService.cs (1)

68await PopulateSnippetCacheAsync().ConfigureAwait(false);

Snippets\SnippetExpansionClient.cs (2)

752document, method, cancellationToken).ConfigureAwait(true); 907await provider.ProvideArgumentAsync(context).ConfigureAwait(true);

StackTraceExplorer\StackFrameViewModel.cs (2)

62await NavigateToDefinitionAsync(definition, cancellationToken).ConfigureAwait(false); 91await NavigateToDefinitionAsync(definition, cancellationToken).ConfigureAwait(false);

StackTraceExplorer\StackTraceExplorerRootViewModel.cs (3)

60await newTab.Content.ViewModel.SetStackTraceResultAsync(result.Value, originalText, cancellationToken).ConfigureAwait(false); 77await SelectedTab.Content.ViewModel.SetStackTraceResultAsync(result, text, cancellationToken).ConfigureAwait(false); 81await AddNewTabAsync(result, text, cancellationToken).ConfigureAwait(false);

StackTraceExplorer\StackTraceExplorerToolWindow.cs (1)

80await Root.ViewModel.AddNewTabAsync(result, text, cancellationToken).ConfigureAwait(false);

StackTraceExplorer\StackTraceExplorerViewModel.cs (1)

71await SetStackTraceResultAsync(result, text, cancellationToken).ConfigureAwait(false);

SymbolSearch\AbstractDelayStartedService.cs (2)

109await statusService.WaitUntilFullyLoadedAsync(this.DisposalToken).ConfigureAwait(false); 111await this.EnableServiceAsync(this.DisposalToken).ConfigureAwait(false);

TableDataSource\Suppression\VisualStudioSuppressionFixService.cs (1)

394await action(waitContext.UserCancellationToken).ConfigureAwait(true);

TaskList\ExternalErrorDiagnosticUpdateSource.cs (5)

135await ClearPreviousAsync(projectId: projectId, cancellationToken).ConfigureAwait(false); 148await ClearPreviousAsync(projectId: null, cancellationToken).ConfigureAwait(false); 179await diagnosticManagerService.ClearDiagnosticsAsync(projectId.Id.ToString(), cancellationToken).ConfigureAwait(false); 183await diagnosticManagerService.ClearAllDiagnosticsAsync(cancellationToken).ConfigureAwait(false); 212await diagnosticManagerService.AppendDiagnosticsAsync(projectId.Id.ToString(), collections.ToImmutable(), cancellationToken).ConfigureAwait(false);

Telemetry\VisualStudioWorkspaceTelemetryService.cs (1)

49await RemoteHostClient.WaitForClientCreationAsync(_workspace.Value, cancellationToken).ConfigureAwait(false);

ValueTracking\ValueTrackingCommandHandler.cs (2)

108await ShowToolWindowAsync(args.TextView, document, items, cancellationToken).ConfigureAwait(false); 164await ShowToolWindowAsync(cancellationToken).ConfigureAwait(true);

Workspace\SourceGeneratedFileManager.cs (2)

444await EnsureWindowFrameInfoBarUpdatedAsync(cancellationToken).ConfigureAwait(true); 501await EnsureWindowFrameInfoBarUpdatedAsync(cancellationToken).ConfigureAwait(true);

Workspace\VisualStudioDocumentNavigationService.cs (1)

252await OpenDocumentAsync(_threadingContext, workspace, documentId, cancellationToken).ConfigureAwait(false);

Workspace\VisualStudioWorkspaceStatusServiceFactory.cs (2)

125await completionTask.WithCancellation(cancellationToken).ConfigureAwait(false); 127await _loadHubClientPackage.JoinAsync(cancellationToken).ConfigureAwait(false);

Microsoft.VisualStudio.LanguageServices.CodeLens (2)

ReferenceCodeLensProvider.cs (2)

99await Task.Delay(TimeSpan.FromSeconds(1.5), _cancellationTokenSource.Token).ConfigureAwait(false); 259await InvalidatedAsync.InvokeAsync(this, EventArgs.Empty).ConfigureAwait(false);

Microsoft.VisualStudio.LanguageServices.CSharp (24)

Interactive\ResetInteractiveWindowFromProjectCommand.cs (1)

72await resetInteractive.ExecuteAsync(vsInteractiveWindow.InteractiveWindow, CSharpVSResources.CSharp_Interactive).ConfigureAwait(true);

LanguageService\CSharpCreateServicesOnTextViewConnection.cs (1)

45await ExtensionMemberImportCompletionHelper.WarmUpCacheAsync(project, CancellationToken.None).ConfigureAwait(false);

ObjectBrowser\DescriptionBuilder.cs (18)

SemanticSearch\SemanticSearchToolWindow.cs (1)

41await base.InitializeAsync(cancellationToken).ConfigureAwait(false);

SemanticSearch\SemanticSearchToolWindowController.cs (1)

35await extensibility.Shell().ShowToolWindowAsync<SemanticSearchToolWindow>(activateWindow, cancellationToken).ConfigureAwait(false);

SemanticSearch\SemanticSearchToolWindowImpl.cs (1)

204await _semanticSearchWorkspace.Value.OpenQueryDocumentAsync(_textBuffer, targetLanguage: null, cancellationToken).ConfigureAwait(false);

Snippets\CSharpSnippetExpansionLanguageHelper.cs (1)

103this.ThreadingContext, formattedDocument, cancellationToken).ConfigureAwait(true);

Microsoft.VisualStudio.LanguageServices.Implementation (7)

CodeModel\ProjectCodeModelFactory.cs (1)

91await FireEventsForChangedDocumentsAsync(projectCodeModelAndFileNames, cancellationToken).ConfigureAwait(false);

SolutionExplorer\AnalyzerNodeSetup.cs (2)

33await _analyzerTracker.RegisterAsync(serviceProvider, cancellationToken).ConfigureAwait(false); 36cancellationToken).ConfigureAwait(false);

SolutionExplorer\AnalyzersCommandHandler.cs (1)

405await SetSeverityHandlerAsync(workspace, (MenuCommand)sender, notificationMessages).ConfigureAwait(false);

SolutionExplorer\Search\RoslynSolutionExplorerSearchProvider.cs (1)

64await searcher.SearchAsync(NavigateToSearchScope.Solution, parameters.CancellationToken).ConfigureAwait(false);

SolutionExplorer\SourceGeneratedFileItems\SourceGeneratedFileItemSource.cs (1)

158await UpdateSourceGeneratedFileItemsAsync(solution, cancellationToken).ConfigureAwait(false);

SolutionExplorer\SymbolTree\RootSymbolTreeItemSourceProvider.cs (1)

174.ConfigureAwait(false);

Microsoft.VisualStudio.LanguageServices.LiveShare (6)

Client\RemoteLanguageServiceWorkspace.cs (3)

122await UpdatePathsToRemoteFilesAsync(session).ConfigureAwait(false); 142await UpdatePathsToRemoteFilesAsync(_session!).ConfigureAwait(false); 161await RefreshAllFilesAsync().ConfigureAwait(false);

Client\RemoteLanguageServiceWorkspaceHost.cs (2)

66await LoadRoslynPackageAsync(cancellationToken).ConfigureAwait(false); 68await Workspace.SetSessionAsync(collaborationSession).ConfigureAwait(false);

ProjectsHandler.cs (1)

40await requestContext.ProtocolConverter.RegisterExternalFilesAsync(externalUris.ToArray()).ConfigureAwait(false);

Microsoft.VisualStudio.LanguageServices.Xaml (1)

Implementation\LanguageServer\Handler\Definitions\GoToDefinitionHandler.cs (1)

86await Task.WhenAll(tasks).ConfigureAwait(false);

Pipelines.AppHost (16)

AppHost.cs (16)

Pipelines.Library (9)

DistributedApplicationPipelineExtensions.cs (9)

47context.CancellationToken).ConfigureAwait(false); 89cancellationToken).ConfigureAwait(false); 93await publishProcess.WaitForExitAsync(cancellationToken).ConfigureAwait(false); 101cancellationToken).ConfigureAwait(false); 108cancellationToken).ConfigureAwait(false); 120cancellationToken).ConfigureAwait(false); 138cancellationToken).ConfigureAwait(false); 164cancellationToken).ConfigureAwait(false); 171cancellationToken).ConfigureAwait(false);

Replay (11)

src\Compilers\Shared\BuildProtocol.cs (7)

src\Compilers\Shared\BuildServerConnection.cs (4)

Roslyn.Compilers.Extension (2)

CompilerPackage.cs (2)

29await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true); 51await WriteMSBuildFilesAsync(packagePath, RoslynHive, cancellationToken).ConfigureAwait(true);

Roslyn.Diagnostics.Analyzers (20)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

Roslyn.Diagnostics.CSharp.Analyzers (2)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (1)

153cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

48solutionEditor, parameter, fieldOrProperty, cancellationToken).ConfigureAwait(false);

Roslyn.VisualStudio.DiagnosticsWindow (4)

OptionPages\ForceLowMemoryMode.cs (1)

139await Task.Delay(MonitorDelay, _cancellationTokenSource.Token).ConfigureAwait(false);

Panels\WorkspacePanel.xaml.cs (2)

71await CompareClosedDocumentsWithFileSystemAsync(workspace, output, cancellationToken).ConfigureAwait(false); 108await Task.WhenAll(tasks).ConfigureAwait(false);

VisualStudioDiagnosticsWindowPackage.cs (1)

66await base.InitializeAsync(cancellationToken, progress).ConfigureAwait(true);

Roslyn.VisualStudio.Next.UnitTests (23)

Remote\SerializationValidator.cs (20)

Services\SolutionServiceTests.cs (3)

207newRecoveredSolutionValidator: s => ValidateProperties(s, version: 1, isRecovered: true)).ConfigureAwait(false); 241newSolutionValidator: s => ValidateProperties(s, version: 1)).ConfigureAwait(false); 287newSolutionValidator: s => ValidateProperties(s, version: 1)).ConfigureAwait(false);

Sockets.BindTests (8)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (7)

src\Servers\Kestrel\shared\test\TransportTestHelpers\TestServer.cs (1)

150await _host.StopAsync().ConfigureAwait(false);

Sockets.FunctionalTests (11)

src\Servers\Kestrel\shared\test\StreamBackedTestConnection.cs (7)

src\Servers\Kestrel\shared\test\TransportTestHelpers\TestServer.cs (1)

150await _host.StopAsync().ConfigureAwait(false);

src\Servers\Kestrel\test\FunctionalTests\MaxRequestBufferSizeTests.cs (3)

144await stream.WriteAsync(data, bytesWritten, size).ConfigureAwait(false); 237await stream.WriteAsync(data, bytesWritten, size).ConfigureAwait(false); 396await writer.WriteAsync(line).ConfigureAwait(false);

Stress.AppHost (1)

Program.cs (1)

181await Task.WhenAll(commandTasks).ConfigureAwait(false);

System.Data.Common (13)

System\Data\Common\DbDataSource.cs (13)

System.Diagnostics.Process (5)

System\Diagnostics\Process.cs (5)

1530await WaitUntilOutputEOF(cancellationToken).ConfigureAwait(false); 1553await tcs.Task.ConfigureAwait(false); 1558await WaitUntilOutputEOF(cancellationToken).ConfigureAwait(false); 1569await _output.EOF.WaitAsync(cancellationToken).ConfigureAwait(false); 1574await _error.EOF.WaitAsync(cancellationToken).ConfigureAwait(false);

System.DirectoryServices.Protocols (1)

System\DirectoryServices\Protocols\ldap\LdapConnection.cs (1)

1396await Task.Delay(Math.Min(iterationDelay, 100)).ConfigureAwait(false);

System.Formats.Tar (21)

System\Formats\Tar\TarEntry.cs (1)

562await DataStream.CopyToAsync(fs, cancellationToken).ConfigureAwait(false);

System\Formats\Tar\TarFile.cs (5)

373await CreateFromDirectoryInternalAsync(sourceDirectoryName, archive, includeBaseDirectory, leaveOpen: false, cancellationToken).ConfigureAwait(false); 392await writer.WriteEntryAsync(di.FullName, GetEntryNameForBaseDirectory(di.Name), cancellationToken).ConfigureAwait(false); 405await writer.WriteEntryAsync(fullpath, entryname, cancellationToken).ConfigureAwait(false); 491await ExtractToDirectoryInternalAsync(archive, destinationDirectoryFullPath, overwriteFiles, leaveOpen: false, cancellationToken).ConfigureAwait(false); 512await entry.ExtractRelativeToDirectoryAsync(destinationDirectoryFullPath, overwriteFiles, pendingModes, directoryModificationTimes, cancellationToken).ConfigureAwait(false);

System\Formats\Tar\TarHeader.Read.cs (1)

54await header.ProcessDataBlockAsync(archiveStream, copyData, cancellationToken).ConfigureAwait(false);

System\Formats\Tar\TarHeader.Write.cs (12)

System\Formats\Tar\TarWriter.cs (2)

190await WriteEntryAsync(entry, cancellationToken).ConfigureAwait(false); 350await task.ConfigureAwait(false);

System.IO.Compression (26)

System\IO\Compression\DeflateZLib\DeflateStream.cs (2)

247await _stream.FlushAsync(cancellationToken).ConfigureAwait(false); 957await _deflateStream._stream.CopyToAsync(this, _arrayPoolBuffer.Length, _cancellationToken).ConfigureAwait(false);

System\IO\Compression\ZipArchive.Async.cs (13)

System\IO\Compression\ZipArchiveEntry.Async.cs (9)

129await decompressor.CopyToAsync(_storedUncompressedData, cancellationToken).ConfigureAwait(false); 169await CloseStreamsAsync().ConfigureAwait(false); 170await WriteLocalFileHeaderAndDataIfNeededAsync(forceWrite, cancellationToken).ConfigureAwait(false); 171await UnloadStreamsAsync().ConfigureAwait(false); 194await ZipGenericExtraField.WriteAllBlocksAsync(_cdUnknownExtraFields, _cdTrailingExtraFieldData ?? Array.Empty<byte>(), _archive.ArchiveStream, cancellationToken).ConfigureAwait(false); 256await ThrowIfNotOpenableAsync(needToUncompress: true, needToLoadIntoMemory: false, cancellationToken).ConfigureAwait(false); 270await ThrowIfNotOpenableAsync(needToUncompress: true, needToLoadIntoMemory: true, cancellationToken).ConfigureAwait(false); 345await ZipGenericExtraField.WriteAllBlocksAsync(_lhUnknownExtraFields, _lhTrailingExtraFieldData ?? Array.Empty<byte>(), _archive.ArchiveStream, cancellationToken).ConfigureAwait(false); 367await _storedUncompressedData.CopyToAsync(entryWriter, cancellationToken).ConfigureAwait(false);

System\IO\Compression\ZipArchiveEntry.cs (1)

1676await _entry.WriteCrcAndSizesInLocalHeaderAsync(_usedZip64inLH, cancellationToken: default).ConfigureAwait(false);

System\IO\Compression\ZipBlocks.Async.cs (1)

32await field.WriteBlockAsync(stream, cancellationToken).ConfigureAwait(false);

System.IO.Compression.Brotli (1)

System\IO\Compression\enc\BrotliStream.Compress.cs (1)

246await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);

System.IO.Compression.ZipFile (8)

System\IO\Compression\ZipFile.Create.Async.cs (2)

448await CreateZipArchiveFromDirectoryAsync(sourceDirectoryName, archive, compressionLevel, includeBaseDirectory, cancellationToken).ConfigureAwait(false); 462await CreateZipArchiveFromDirectoryAsync(sourceDirectoryName, archive, compressionLevel, includeBaseDirectory, cancellationToken).ConfigureAwait(false);

System\IO\Compression\ZipFile.Extract.Async.cs (2)

204await archive.ExtractToDirectoryAsync(destinationDirectoryName, overwriteFiles, cancellationToken).ConfigureAwait(false); 362await archive.ExtractToDirectoryAsync(destinationDirectoryName, overwriteFiles, cancellationToken).ConfigureAwait(false);

System\IO\Compression\ZipFileExtensions.ZipArchive.Create.Async.cs (1)

95await fs.CopyToAsync(es, cancellationToken).ConfigureAwait(false);

System\IO\Compression\ZipFileExtensions.ZipArchive.Extract.Async.cs (1)

82await entry.ExtractRelativeToDirectoryAsync(destinationDirectoryName, overwriteFiles, cancellationToken).ConfigureAwait(false);

System\IO\Compression\ZipFileExtensions.ZipArchiveEntry.Extract.Async.cs (2)

82await es.CopyToAsync(fs, cancellationToken).ConfigureAwait(false); 98await source.ExtractToFileAsync(fileDestinationPath, overwrite: overwrite, cancellationToken).ConfigureAwait(false);

System.IO.Pipelines (3)

System\IO\Pipelines\StreamPipeReader.cs (2)

359await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false); 415await InnerStream.CopyToAsync(destination, tokenSource.Token).ConfigureAwait(false);

System\IO\Pipelines\StreamPipeWriter.cs (1)

343await InnerStream.FlushAsync(localToken).ConfigureAwait(false);

System.Memory.Data (1)

System\BinaryData.cs (1)

299await stream.CopyToAsync(memoryStream, bufferSize, cancellationToken).ConfigureAwait(false);

System.Net.Http (37)

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

210await responseStream.CopyToAsync(buffer, cts.Token).ConfigureAwait(false); 286await responseStream.CopyToAsync(buffer, cts.Token).ConfigureAwait(false); 547await response.Content.LoadIntoBufferAsync(_maxResponseContentBufferSize, cts.Token).ConfigureAwait(false);

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

518await serializeToStreamTask.ConfigureAwait(false); 774await waitTask.ConfigureAwait(false);

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

218await output.CopyToAsync(stream, cancellationToken).ConfigureAwait(false); 220await content.CopyToAsync(stream, context, cancellationToken).ConfigureAwait(false);

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

68await sslStream.AuthenticateAsClientAsync(sslOptions, cancellationToken).ConfigureAwait(false);

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

121await copyTask.ConfigureAwait(false);

System\Net\Http\SocketsHttpHandler\ConnectionPool\HttpConnectionPool.Http2.cs (1)

210await HandleHttp11Downgrade(queueItem.Request, stream, transportContext, activity, remoteEndPoint, cts.Token).ConfigureAwait(false);

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

150await copyTask.ConfigureAwait(false);

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

161await decompressedStream.CopyToAsync(stream, cancellationToken).ConfigureAwait(false); 304await _decompressionStream.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(false); 415await _stream.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(false);

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

1234await FlushOutgoingBytesAsync().ConfigureAwait(false); 1267await FlushOutgoingBytesAsync().ConfigureAwait(false); 1695}, cancellationToken).ConfigureAwait(false); 1748}, cancellationToken).ConfigureAwait(false); 2042await requestBodyTask.ConfigureAwait(false); 2062await responseHeadersTask.ConfigureAwait(false);

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

1329await _connection.SendStreamDataAsync(StreamId, current, flush, _requestBodyCancellationSource.Token).ConfigureAwait(false);

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

169await _sendSettingsTask!.ConfigureAwait(false); 649await ProcessServerControlStreamAsync(stream, bufferCopy).ConfigureAwait(false); 660await stream.CopyToAsync(Stream.Null).ConfigureAwait(false); 672await stream.CopyToAsync(Stream.Null).ConfigureAwait(false);

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

206await sendRequestTask.ConfigureAwait(false); 236await readResponseTask.ConfigureAwait(false); 245await writesClosed.WaitAsync(_requestBodyCancellationSource.Token).ConfigureAwait(false); 487await content.CopyToAsync(writeStream, null, cancellationToken).ConfigureAwait(false);

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

767await sendTask.ConfigureAwait(false); 881await sendRequestContentTask.ConfigureAwait(false); 978await request.Content!.CopyToAsync(stream, _transportContext, cancellationToken).ConfigureAwait(false); 986await stream.FinishAsync(async).ConfigureAwait(false); 1906await _stream.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(false);

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

61await contentStream.CopyToAsync(stream, BufferSize, cancellationToken).ConfigureAwait(false);

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

123await copyTask.ConfigureAwait(false);

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

82await copyTask.ConfigureAwait(false);

System.Net.Http.Json (1)

System\Net\Http\Json\JsonContent.cs (1)

131await JsonSerializer.SerializeAsync(transcodingStream, Value, _typeInfo, cancellationToken).ConfigureAwait(false);

System.Net.HttpListener (3)

System\Net\Managed\HttpResponseStream.Managed.cs (2)

109await InternalWriteAsync(ms.GetBuffer(), (int)start, (int)(ms.Length - start)).ConfigureAwait(false); 110await _stream.FlushAsync().ConfigureAwait(false);

System\Net\Managed\WebSockets\HttpWebSocket.Managed.cs (1)

58await responseStream.WriteWebSocketHandshakeHeadersAsync().ConfigureAwait(false);

System.Net.Mail (19)

System\Net\Base64Stream.cs (1)

158await base.FlushAsync(cancellationToken).ConfigureAwait(false);

System\Net\Mail\MailMessage.cs (1)

438await _message.SendAsync<TIOAdapter>(writer, sendEnvelope, allowUnicode, cancellationToken).ConfigureAwait(false);

System\Net\Mail\MailPriority.cs (1)

258await Content.SendAsync<TIOAdapter>(writer, allowUnicode, cancellationToken).ConfigureAwait(false);

System\Net\Mail\SmtpClient.cs (2)

516await EnsureConnection<TIOAdapter>(cancellationToken).ConfigureAwait(false); 525await message.SendAsync<TIOAdapter>(writer, DeliveryMethod != SmtpDeliveryMethod.Network, allowUnicode, cancellationToken).ConfigureAwait(false);

System\Net\Mail\SmtpCommands.cs (3)

21await conn.FlushAsync<TIOAdapter>(cancellationToken).ConfigureAwait(false); 31await conn.FlushAsync<TIOAdapter>(cancellationToken).ConfigureAwait(false); 416await conn.FlushAsync<TIOAdapter>(cancellationToken).ConfigureAwait(false);

System\Net\Mail\SmtpConnection.cs (5)

89await _tcpClient!.ConnectAsync(host, port).ConfigureAwait(false); 106await InitializeConnectionAsync(host, port).ConfigureAwait(false); 141await HelloCommand.SendAsync<TIOAdapter>(this, _client!._clientDomain, cancellationToken).ConfigureAwait(false); 158await StartTlsCommand.SendAsync<TIOAdapter>(this, cancellationToken).ConfigureAwait(false); 174cancellationToken).ConfigureAwait(false);

System\Net\Mail\SmtpTransport.cs (3)

84await GetConnectionAsync<AsyncReadWriteAdapter>(host, port, cancellationToken).ConfigureAwait(false); 117await MailCommand.SendAsync<TIOAdapter>(_connection!, SmtpCommands.Mail, sender, allowUnicode, cancellationToken).ConfigureAwait(false); 141await DataCommand.SendAsync<TIOAdapter>(_connection!, cancellationToken).ConfigureAwait(false);

System\Net\Mime\MimeMultiPart.cs (1)

52await part.SendAsync<TIOAdapter>(mimeWriter, allowUnicode, cancellationToken).ConfigureAwait(false);

System\Net\Mime\QEncodedStream.cs (1)

197await base.FlushAsync(cancellationToken).ConfigureAwait(false);

System\Net\Mime\QuotedPrintableStream.cs (1)

311await base.FlushAsync(cancellationToken).ConfigureAwait(false);

System.Net.Ping (1)

System\Net\NetworkInformation\Ping.PingUtility.cs (1)

83await pingProcess.WaitForExitAsync(timeoutOrCancellationToken).ConfigureAwait(false);

System.Net.Quic (3)

System\Net\Quic\QuicConnection.cs (2)

551await _connectionCloseTcs.Task.ConfigureAwait(false); 849await _shutdownTcs.GetFinalTask(this).ConfigureAwait(false);

System\Net\Quic\QuicListener.cs (1)

431await _disposeCts.CancelAsync().ConfigureAwait(false);

System.Net.Requests (3)

System\Net\FtpWebRequest.cs (1)

957await client.ConnectAsync(_uri.Host, _uri.Port).ConfigureAwait(false);

System\Net\RequestStream.cs (1)

150await _internalStream.FlushAsync().ConfigureAwait(false);

System\Net\RequestStreamContent.cs (1)

23await completeTcs.Task.WaitAsync(cancellationToken).ConfigureAwait(false);

System.Net.Security (19)

src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (3)

198await sendTask.ConfigureAwait(false); 237await sendTask.ConfigureAwait(false); 257await responseStream.CopyToAsync(result).ConfigureAwait(false);

System\Net\Security\NegotiateStream.cs (8)

System\Net\Security\SslStream.IO.cs (8)

System.Net.Sockets (1)

System\Net\Sockets\TCPClient.cs (1)

200await task.ConfigureAwait(false);

System.Net.WebSockets (8)

System\Net\WebSockets\ManagedWebSocket.cs (7)

564await _stream.FlushAsync().ConfigureAwait(false); 595await lockTask.ConfigureAwait(false); 604await _stream.FlushAsync(cancellationToken).ConfigureAwait(false); 784await _receiveMutex.EnterAsync(cancellationToken).ConfigureAwait(false); 1148await task.WaitAsync(TimeSpan.FromMilliseconds(WaitForCloseTimeoutMs)).ConfigureAwait(false); 1274await CloseOutputAsync(closeStatus, string.Empty, default).ConfigureAwait(false); 1454await _receiveMutex.EnterAsync(cancellationToken).ConfigureAwait(false);

System\Net\WebSockets\WebSocket.cs (1)

76await SendAsync(new ArraySegment<byte>(array, 0, buffer.Length), messageType, endOfMessage, cancellationToken).ConfigureAwait(false);

System.Net.WebSockets.Client (1)

System\Net\WebSockets\ClientWebSocket.cs (1)

127await _innerWebSocket.ConnectAsync(uri, invoker, cancellationToken, Options).ConfigureAwait(false);

System.Private.CoreLib (82)

src\libraries\Common\src\System\Threading\Tasks\TaskToAsyncResult.cs (1)

139_task.ConfigureAwait(continueOnCapturedContext: false)

src\libraries\System.Private.CoreLib\src\System\CodeDom\Compiler\IndentedTextWriter.cs (27)

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (9)

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (2)

1362await writer.WriteLineAsync(line.AsMemory(), cancellationToken).ConfigureAwait(false); 1365await writer.FlushAsync(cancellationToken).ConfigureAwait(false);

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (8)

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (1)

746await writeTask.ConfigureAwait(false);

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (8)

260await FlushAsync().ConfigureAwait(false); 677await FlushAsyncInternal(flushStream: false, flushEncoder: false).ConfigureAwait(false); 688await FlushAsyncInternal(flushStream: false, flushEncoder: false).ConfigureAwait(false); 697await FlushAsyncInternal(flushStream: true, flushEncoder: false).ConfigureAwait(false); 785await FlushAsyncInternal(flushStream: false, flushEncoder: false, cancellationToken).ConfigureAwait(false); 802await FlushAsyncInternal(flushStream: false, flushEncoder: false, cancellationToken).ConfigureAwait(false); 811await FlushAsyncInternal(flushStream: true, flushEncoder: false, cancellationToken).ConfigureAwait(false); 1003await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);

src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.CreateBroadcasting.cs (15)

src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (3)

650await WriteAsync(chunk, ct).ConfigureAwait(false); 744await WriteAsync(chunk, ct).ConfigureAwait(false); 746await WriteAsync(CoreNewLine, ct).ConfigureAwait(false);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\ConfiguredValueTaskAwaitable.cs (6)

59t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation); 69Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation); 81t.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation); 90Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation); 174Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().OnCompleted(continuation); 195Task.CompletedTask.ConfigureAwait(_value._continueOnCapturedContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\ConfigureAwaitOptions.cs (2)

13/// identically to using <see cref="Task.ConfigureAwait(bool)"/> with a <see langword="false"/> argument. 25/// behaves identically to using <see cref="Task.ConfigureAwait(bool)"/> with a <see langword="true"/> argument.

System.Private.DataContractSerialization (29)

System\Xml\XmlBaseWriter.cs (14)

System\Xml\XmlStreamNodeWriter.cs (5)

101await FlushBufferAsync().ConfigureAwait(false); 149await FlushBufferAsync().ConfigureAwait(false); 195await FlushBufferAsync().ConfigureAwait(false); 424await FlushBufferAsync().ConfigureAwait(false); 425await OutputStream.FlushAsync().ConfigureAwait(false);

System\Xml\XmlUTF8TextWriter.cs (10)

System.Private.Xml (407)

System\Xml\AsyncHelper.cs (5)

36await task.ConfigureAwait(false); 49await task.ConfigureAwait(false); 62await task.ConfigureAwait(false); 63await func(arg).ConfigureAwait(false); 75await task.ConfigureAwait(false);

System\Xml\Base64EncoderAsync.cs (3)

44await WriteCharsAsync(_charsLine, 0, leftOverChars).ConfigureAwait(false); 69await WriteCharsAsync(_charsLine, 0, charCount).ConfigureAwait(false); 81await WriteCharsAsync(_charsLine, 0, leftOverChars).ConfigureAwait(false);

System\Xml\BinHexEncoderAsync.cs (1)

27await writer.WriteRawAsync(chars, 0, cnt * 2).ConfigureAwait(false);

System\Xml\Core\XmlCharCheckingReaderAsync.cs (1)

37await _readBinaryHelper.FinishAsync().ConfigureAwait(false);

System\Xml\Core\XmlCharCheckingWriterAsync.cs (2)

108await writer.WriteCDataAsync(text.Substring(0, i + 2)).ConfigureAwait(false); 113await writer.WriteCDataAsync(text).ConfigureAwait(false);

System\Xml\Core\XmlEncodedRawTextWriterAsync.cs (82)

System\Xml\Core\XmlRawWriterAsync.cs (3)

195await WriteStringAsync(prefix).ConfigureAwait(false); 196await WriteStringAsync(":").ConfigureAwait(false); 199await WriteStringAsync(localName).ConfigureAwait(false);

System\Xml\Core\XmlReaderAsync.cs (1)

203await WriteNodeAsync(xtw, false).ConfigureAwait(false);

System\Xml\Core\XmlSubtreeReaderAsync.cs (4)

123await reader.SkipAsync().ConfigureAwait(false); 139await reader.SkipAsync().ConfigureAwait(false); 162await SkipAsync().ConfigureAwait(false); 170await SkipAsync().ConfigureAwait(false);

System\Xml\Core\XmlTextReaderImplAsync.cs (39)

System\Xml\Core\XmlUtf8RawTextWriterAsync.cs (77)

System\Xml\Core\XmlValidatingReaderImplAsync.cs (3)

43await ParseDtdFromParserContextAsync().ConfigureAwait(false); 61await ResolveEntityInternallyAsync().ConfigureAwait(false); 65await _readBinaryHelper!.FinishAsync().ConfigureAwait(false);

System\Xml\Core\XmlWellFormedWriterAsync.cs (79)

System\Xml\Core\XmlWellFormedWriterHelpersAsync.cs (15)

System\Xml\Core\XmlWriterAsync.cs (53)

System\Xml\Core\XsdValidatingReaderAsync.cs (7)

251await ProcessReaderEventAsync().ConfigureAwait(false); 281await task.ConfigureAwait(false); 364await _coreReader.SkipAsync().ConfigureAwait(false); 552await _inlineSchemaParser.StartParsingAsync(_coreReader, null).ConfigureAwait(false); 621await ProcessEndElementEventAsync().ConfigureAwait(false); 641await _cachingReader.SetToReplayModeAsync().ConfigureAwait(false); 868await ProcessReaderEventAsync().ConfigureAwait(false);

System\Xml\Schema\DtdParserAsync.cs (32)

System.Private.Xml.Linq (29)

System\Xml\Linq\XContainer.cs (3)

868await ReadContentFromAsync(r, cancellationToken).ConfigureAwait(false); 1339await tWrite.ConfigureAwait(false); 1347await n.WriteToAsync(writer, cancellationToken).ConfigureAwait(false);

System\Xml\Linq\XDocument.cs (8)

System\Xml\Linq\XElement.cs (8)

System\Xml\Linq\XLinq.cs (10)

System.Security.Cryptography (6)

src\libraries\Common\src\System\Net\Http\X509ResourceClient.cs (3)

198await sendTask.ConfigureAwait(false); 237await sendTask.ConfigureAwait(false); 257await responseStream.CopyToAsync(result).ConfigureAwait(false);

System\Security\Cryptography\CryptoStream.cs (3)

169await _stream.FlushAsync(cancellationToken).ConfigureAwait(false); 240await AsyncActiveSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false); 479await AsyncActiveSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

System.Security.Cryptography.Cose (6)

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (3)

408await WriteSignatureAsync(writer, signer, buffer, buffer.AsMemory(0, protectedMapBytesWritten), associatedData, content, cancellationToken).ConfigureAwait(false); 487await AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature, bodyProtected, buffer.AsMemory(start, signProtectedBytesWritten), associatedData, contentStream, cancellationToken).ConfigureAwait(false); 861await AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature, _protectedHeaderAsBstr, encodedSignProtected, associatedData, content, cancellationToken).ConfigureAwait(false);

System\Security\Cryptography\Cose\CoseSign1Message.cs (2)

346await AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature1, buffer.AsMemory(0, protectedMapBytesWritten), ReadOnlyMemory<byte>.Empty, associatedData, content, cancellationToken).ConfigureAwait(false); 950await AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature1, _protectedHeaderAsBstr, ReadOnlyMemory<byte>.Empty, associatedData, content, cancellationToken).ConfigureAwait(false);

System\Security\Cryptography\Cose\CoseSignature.cs (1)

628await CoseMessage.AppendToBeSignedAsync(buffer, toBeSignedBuilder, SigStructureContext.Signature, Message.RawProtectedHeaders, _encodedSignProtectedHeaders, associatedData, content, cancellationToken).ConfigureAwait(false);

System.ServiceModel.Primitives (11)

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

374await semaphoreLockTask.ConfigureAwait(false);

System\ServiceModel\Channels\BufferedWriteStream.cs (10)

System.Text.Json (3)

System\Text\Json\Serialization\Metadata\JsonTypeInfoOfT.WriteHelpers.cs (1)

144await derivedTypeInfo.SerializeAsObjectAsync(pipeWriter, rootValue, flushThreshold, cancellationToken).ConfigureAwait(false);

System\Text\Json\Writer\Utf8JsonWriter.cs (2)

492await FlushAsync().ConfigureAwait(false); 529await _stream.FlushAsync(cancellationToken).ConfigureAwait(false);

System.Threading.RateLimiting (1)

System\Threading\RateLimiting\DefaultPartitionedRateLimiter.cs (1)

153await _timerTask.ConfigureAwait(false);

System.Threading.Tasks.Dataflow (4)

Blocks\TransformManyBlock.netstandard21.cs (4)

60await StoreOutputItemsAsync(messageWithId, outputItems).ConfigureAwait(false); 95await StoreOutputItemsReorderedAsync(messageWithId.Value, outputItems).ConfigureAwait(false); 100await StoreOutputItemsNonReorderedWithIterationAsync(outputItems).ConfigureAwait(false); 146await StoreOutputItemsNonReorderedWithIterationAsync(item).ConfigureAwait(false);

System.Windows.Forms (4)

System\Windows\Forms\Control_InvokeAsync.cs (4)

71await completion.Task.ConfigureAwait(false); 297.ConfigureAwait(false)); 299await completion.Task.ConfigureAwait(false); 402.ConfigureAwait(false));

System.Windows.Forms.Analyzers.CSharp.Tests (2)

Analyzers\WFO1001\ImplementITypedDataObjectTests.cs (2)

136await context.RunAsync().ConfigureAwait(false); 139private static async Task NoWarning(string input) => await CreateContext(input).RunAsync().ConfigureAwait(false);

System.Windows.Forms.Tests (34)

System\Windows\Forms\ControlTests_InvokeAsync.cs (31)

System\Windows\Forms\FormTests.cs (3)

2668await Task.Delay(100).ConfigureAwait(false); 2673.ConfigureAwait(false); 2693.ConfigureAwait(true);

System.Windows.Forms.UI.IntegrationTests (4)

ListControlUnboundActionListTests.cs (4)

25await Task.Delay(500).ConfigureAwait(true); 30await form.InvokeAsync(new Action(() => form.Dispose())).ConfigureAwait(true); 42await Task.Delay(retryDelay).ConfigureAwait(true); 50await disposeTask.ConfigureAwait(true);

Test.Utilities (14)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

TestDiscoveryWorker (1)

Program.cs (1)

95await JsonSerializer.SerializeAsync(fileStream, testsToWrite.OrderBy(x => x)).ConfigureAwait(false);

Text.Analyzers (20)

src\Compilers\Core\Portable\InternalUtilities\SemaphoreSlimExtensions.cs (1)

23await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

src\Dependencies\Threading\ProducerConsumer.cs (8)

src\Dependencies\Threading\TaskExtensions.cs (2)

106_task.ConfigureAwait(_captureContext).GetAwaiter().OnCompleted(continuation); 116_task.ConfigureAwait(_captureContext).GetAwaiter().UnsafeOnCompleted(continuation);

src\Dependencies\Threading\YieldAwaitableExtensions.cs (2)

16/// is the same as one would expect for <see cref="Task.ConfigureAwait(bool)"/>. 19/// <param name="continueOnCapturedContext"><inheritdoc cref="Task.ConfigureAwait(bool)"/></param>

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SpecializedTasks.cs (1)

90await Task.WhenAll((IEnumerable<Task>)tasks).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\ForkingSyntaxEditorBasedCodeFixProvider.cs (1)

91cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeFixes\SyntaxEditorBasedCodeFixProvider.cs (1)

86await editAsync(editor).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Editing\ImportAdderService.cs (1)

83model, container, namespaceSymbols, conflicts, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\MoveDeclarationNearReference\AbstractMoveDeclarationNearReferenceService.cs (1)

111document, state, editor, warningAnnotation, cancellationToken).ConfigureAwait(false);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Simplification\AbstractSimplificationService.cs (2)

vbc (11)

src\Compilers\Shared\BuildProtocol.cs (7)

src\Compilers\Shared\BuildServerConnection.cs (4)

VBCSCompiler (14)

src\Compilers\Server\VBCSCompiler\ClientConnectionHandler.cs (1)

107await clientConnection.WriteBuildResponseAsync(response, cancellationToken).ConfigureAwait(false);

src\Compilers\Server\VBCSCompiler\NamedPipeClientConnection.cs (1)

74await BuildServerConnection.MonitorDisconnectAsync(Stream, request.RequestId, Logger, DisconnectCancellationTokenSource.Token).ConfigureAwait(false);

src\Compilers\Server\VBCSCompiler\NamedPipeClientConnectionHost.cs (1)

206await connectTask.ConfigureAwait(false);

src\Compilers\Shared\BuildProtocol.cs (7)

src\Compilers\Shared\BuildServerConnection.cs (4)

VBCSCompiler.UnitTests (1)

Extensions.cs (1)

51await Task.Delay(delay, cancellationToken).ConfigureAwait(false);