None

1060 references to None

AuthSamples.FunctionalTests (1)

TestAssert.cs (1)

79.OpenAsync(ResponseFactory, CancellationToken.None);

http2cat (2)

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

IIS.FunctionalTests (2)

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

IIS.LongTests (2)

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

IIS.NewHandler.FunctionalTests (2)

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

IIS.NewShim.FunctionalTests (2)

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

IIS.ShadowCopy.Tests (1)

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

IISExpress.FunctionalTests (2)

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

InMemory.FunctionalTests (13)

Http2\TlsTests.cs (2)

67}, CancellationToken.None); 69var reader = PipeReaderFactory.CreateFromStream(PipeOptions.Default, sslStream, CancellationToken.None);

Http3\WebTransport\WebTransportHandshakeTests.cs (1)

37var session = await webTransportFeature.AcceptAsync(CancellationToken.None).DefaultTimeout(); // todo session is null here

Http3\WebTransport\WebTransportSessionTests.cs (5)

21var stream = await session.OpenUnidirectionalStreamAsync(CancellationToken.None); 45var stream = await session.AcceptStreamAsync(CancellationToken.None); 53var stream2 = await session.AcceptStreamAsync(CancellationToken.None); 93Assert.Null(await session.AcceptStreamAsync(CancellationToken.None)); 94Assert.Null(await session.OpenUnidirectionalStreamAsync(CancellationToken.None));

Http3\WebTransport\WebTransportStreamTests.cs (2)

42await stream.Transport.Output.WriteAsync(input, CancellationToken.None); 47var length = await stream.Transport.Input.AsStream().ReadAsync(memoryOut, CancellationToken.None);

Http3\WebTransport\WebTransportTestUtilities.cs (1)

35var session = await webTransportFeature.AcceptAsync(CancellationToken.None).DefaultTimeout();

HttpsTests.cs (2)

463var sslServerAuthenticationOptions = await sslOptions.OnConnection(new TlsConnectionCallbackContext(), CancellationToken.None); 507var sslServerAuthenticationOptions = await tlsOptions.OnConnection(new TlsConnectionCallbackContext(), CancellationToken.None);

InProcessWebSite (4)

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

105await webSocket.SendAsync(new ArraySegment<byte>(Encoding.ASCII.GetBytes(message)), WebSocketMessageType.Text, true, CancellationToken.None); 156await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); 163await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, closeFromServerCmd, CancellationToken.None); 169result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

Interop.FunctionalTests (42)

Http2\Http2RequestTests.cs (3)

64var response1 = await client.SendAsync(request1, CancellationToken.None); 108var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 193var responseMessage = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

Http3\Http3RequestTests.cs (32)

Http3\Http3TlsTests.cs (7)

61var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 107var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 149var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 198var sendTask = client.SendAsync(request, CancellationToken.None); 248var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 327var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout(); 492var response = await client.SendAsync(request, CancellationToken.None).DefaultTimeout();

Microsoft.Arcade.Common (2)

ArcadeHttpMessageHandler.cs (1)

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

ExponentialRetry.cs (1)

32public CancellationToken DefaultCancellationToken { get; set; } = CancellationToken.None;

Microsoft.AspNetCore.Analyzer.Testing (2)

CodeFixRunner.cs (2)

29var context = new CodeFixContext(document, analyzerDiagnostic, (a, d) => actions.Add(a), CancellationToken.None); 63var operations = await codeAction.GetOperationsAsync(CancellationToken.None);

Microsoft.AspNetCore.App.Analyzers.Test (8)

TestDiagnosticAnalyzer.cs (5)

34var result = await Classifier.GetClassifiedSpansAsync(doc, textSpan, CancellationToken.None); 73var semanticModel = await document.GetSemanticModelAsync(CancellationToken.None).ConfigureAwait(false); 79var root = await document.GetSyntaxRootAsync(CancellationToken.None).ConfigureAwait(false); 95return braceMatcher.FindBraces(model, token, caretPosition, CancellationToken.None); 103var highlights = highlighter.GetDocumentHighlights(model, token, caretPosition, CancellationToken.None);

Verifiers\CSharpAnalyzerVerifier.cs (1)

46await test.RunAsync(CancellationToken.None);

Verifiers\CSharpCodeFixVerifier.cs (2)

43await test.RunAsync(CancellationToken.None); 77await test.RunAsync(CancellationToken.None);

Microsoft.AspNetCore.Components.Analyzers.Tests (2)

Helpers\CodeFixVerifier.Helper.cs (1)

28var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;

Verifiers\CodeFixVerifier.cs (1)

86var context = new CodeFixContext(document, analyzerDiagnostics[0], (a, d) => actions.Add(a), CancellationToken.None);

Microsoft.AspNetCore.Components.SdkAnalyzers.Tests (2)

Helpers\CodeFixVerifier.Helper.cs (1)

28var operations = codeAction.GetOperationsAsync(CancellationToken.None).Result;

Verifiers\CodeFixVerifier.cs (1)

86var context = new CodeFixContext(document, analyzerDiagnostics[0], (a, d) => actions.Add(a), CancellationToken.None);

Microsoft.AspNetCore.Components.Server (2)

Circuits\CircuitHost.cs (2)

191await OnConnectionDownAsync(CancellationToken.None); 201await OnCircuitDownAsync(CancellationToken.None);

Microsoft.AspNetCore.Components.Server.Tests (10)

Circuits\CircuitHostTest.cs (3)

601await circuitHost.UpdateRootComponents(new() { Operations = [addOperation] }, null, CancellationToken.None); 617await circuitHost.UpdateRootComponents(new() { Operations = [updateOperation] }, null, CancellationToken.None); 629await circuitHost.UpdateRootComponents(new() { Operations = [removeOperation] }, null, CancellationToken.None);

Circuits\RemoteJSDataStreamTest.cs (6)

24var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(_jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None).DefaultTimeout(); 162var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None); 182var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None); 219cancellationToken: CancellationToken.None); 260cancellationToken: CancellationToken.None); 293var remoteJSDataStream = await RemoteJSDataStream.CreateRemoteJSDataStreamAsync(jsRuntime ?? _jsRuntime, jsStreamReference, totalLength: 100, signalRMaximumIncomingBytes: 10_000, jsInteropDefaultCallTimeout: TimeSpan.FromMinutes(1), cancellationToken: CancellationToken.None);

ProtectedBrowserStorageTest.cs (1)

367=> InvokeAsync<TValue>(identifier, cancellationToken: CancellationToken.None, args: args);

Microsoft.AspNetCore.Components.Web (1)

Virtualization\Virtualize.cs (1)

367cancellationToken = CancellationToken.None;

Microsoft.AspNetCore.Components.WebAssembly (1)

Hosting\WebAssemblyHost.cs (1)

112return RunAsyncCore(CancellationToken.None);

Microsoft.AspNetCore.Components.WebAssembly.Tests (3)

PullFromJSDataStreamTest.cs (3)

23var pullFromJSDataStream = PullFromJSDataStream.CreateJSDataStream(_jsRuntime, jsStreamReference, totalLength: 100, cancellationToken: CancellationToken.None); 108var pullFromJSDataStream = PullFromJSDataStream.CreateJSDataStream(runtime, jsStreamReference, totalLength: data.Length, cancellationToken: CancellationToken.None); 135return await InvokeAsync<TValue>(identifier, CancellationToken.None, args);

Microsoft.AspNetCore.Components.WebView.Photino (2)

PhotinoSynchronizationContext.cs (1)

240}, CancellationToken.None, flags, TaskScheduler.Current);

PhotinoWebViewManager.cs (1)

43}, message, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

Microsoft.AspNetCore.Connections.Abstractions (2)

IConnectionFactory.cs (1)

19/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

IMultiplexedConnectionFactory.cs (1)

21/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

Microsoft.AspNetCore.DataProtection (3)

KeyManagement\Internal\CacheableKeyRing.cs (1)

49return new CacheableKeyRing(CancellationToken.None, now + extension, KeyRing);

KeyManagement\KeyRingProvider.cs (2)

369CancellationToken.None, // GetKeyRingFromCompletedTaskUnsynchronized will need to react if this becomes cancellable 411CancellationToken.None,

Microsoft.AspNetCore.DataProtection.Tests (22)

KeyManagement\CacheableKeyRingTests.cs (1)

51var cacheableKeyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.Now, keyRing);

KeyManagement\KeyRingBasedDataProtectorTests.cs (5)

262var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key }); 293var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key }); 297var keyRing2 = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key2 }); 329var keyRing = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key }); 333var keyRing2 = new CacheableKeyRing(CancellationToken.None, DateTimeOffset.MaxValue, key, new[] { key2 });

KeyManagement\KeyRingProviderTests.cs (16)

Microsoft.AspNetCore.Grpc.JsonTranscoding (4)

Internal\CallHandlers\UnaryServerCallHandler.cs (1)

54await JsonRequestHelpers.SendMessage(serverCallContext, SerializerOptions, response, CancellationToken.None);

Internal\HttpContextStreamWriter.cs (1)

39return WriteAsyncCore(message, CancellationToken.None);

Internal\JsonRequestHelpers.cs (2)

101await WriteResponseMessage(response, encoding, e, options, CancellationToken.None); 352await fs.DrainAsync(CancellationToken.None);

Microsoft.AspNetCore.Hosting.Abstractions (1)

HostingAbstractionsWebHostBuilderExtensions.cs (1)

175host.StartAsync(CancellationToken.None).GetAwaiter().GetResult();

Microsoft.AspNetCore.Http (1)

Features\FormFeature.cs (1)

156public Task<IFormCollection> ReadFormAsync() => ReadFormAsync(CancellationToken.None);

Microsoft.AspNetCore.Http.Connections (1)

Internal\Transports\WebSocketsServerTransport.cs (1)

281await socket.CloseOutputAsync(error != null ? WebSocketCloseStatus.InternalServerError : WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

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

HttpConnection.cs (2)

177/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 193/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

HttpConnectionFactory.cs (1)

40/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

Microsoft.AspNetCore.Http.Connections.Tests (18)

ApplicationLifetime.cs (3)

35public CancellationToken ApplicationStarted => CancellationToken.None; 37public CancellationToken ApplicationStopping => CancellationToken.None; 39public CancellationToken ApplicationStopped => CancellationToken.None;

HttpConnectionDispatcherTests.cs (1)

1465await ws.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

LongPollingTests.cs (3)

30var poll = new LongPollingServerTransport(CancellationToken.None, connection.Application.Input, LoggerFactory); 71var poll = new LongPollingServerTransport(CancellationToken.None, connection.Application.Input, LoggerFactory); 94var poll = new LongPollingServerTransport(CancellationToken.None, connection.Application.Input, LoggerFactory);

MapConnectionHandlerTests.cs (3)

402await client.ConnectAsync(new Uri(address), CancellationToken.None); 404await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).DefaultTimeout(); 405var result = await client.ReceiveAsync(new ArraySegment<byte>(new byte[1024]), CancellationToken.None).DefaultTimeout();

WebSocketsTests.cs (8)

Microsoft.AspNetCore.Http.Extensions.Tests (5)

SendFileResponseExtensionsTests.cs (5)

26await response.SendFileAsync("bob", 1, 3, CancellationToken.None); 31Assert.Equal(CancellationToken.None, fakeFeature.Token); 42await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None); 82await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None); 97await response.SendFileAsync("testfile1kb.txt", 1, 3, CancellationToken.None);

Microsoft.AspNetCore.Http.Results.Tests (5)

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (4)

273.Setup(s => s.SendFileAsync(path, 0, null, CancellationToken.None)) 313Assert.Equal(CancellationToken.None, sendFile.Token); 340Assert.Equal(CancellationToken.None, sendFile.Token); 360Assert.Equal(CancellationToken.None, sendFile.Token);

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (1)

348Assert.Equal(CancellationToken.None, sendFile.Token);

Microsoft.AspNetCore.HttpOverrides (1)

CertificateForwardingFeature.cs (1)

27get => GetClientCertificateAsync(CancellationToken.None).Result;

Microsoft.AspNetCore.Identity (4)

AspNetRoleManager.cs (1)

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

AspNetUserManager.cs (1)

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

IdentityApiEndpointRouteBuilderExtensions.cs (2)

77await userStore.SetUserNameAsync(user, email, CancellationToken.None); 78await emailStore.SetEmailAsync(user, email, CancellationToken.None);

Microsoft.AspNetCore.Identity.FunctionalTests (1)

Extensions\ResponseAssert.cs (1)

27.OpenAsync(ResponseFactory, CancellationToken.None);

Microsoft.AspNetCore.Identity.Test (84)

RoleManagerTest.cs (9)

17store.Setup(s => s.CreateAsync(role, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 18store.Setup(s => s.GetRoleNameAsync(role, CancellationToken.None)).Returns(Task.FromResult(role.Name)).Verifiable(); 19store.Setup(s => s.SetNormalizedRoleNameAsync(role, normalizer.NormalizeName(role.Name), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 37store.Setup(s => s.UpdateAsync(role, CancellationToken.None)).ReturnsAsync(IdentityResult.Success).Verifiable(); 38store.Setup(s => s.GetRoleNameAsync(role, CancellationToken.None)).Returns(Task.FromResult(role.Name)).Verifiable(); 39store.Setup(s => s.SetNormalizedRoleNameAsync(role, normalizer.NormalizeName(role.Name), CancellationToken.None)).Returns(Task.FromResult(0)).Verifiable(); 65store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName("Foo"), CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable(); 82store.Setup(s => s.FindByNameAsync(role.Name, CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable(); 101store.Setup(s => s.FindByNameAsync(normalizer.NormalizeName("Foo"), CancellationToken.None)).Returns(Task.FromResult(role)).Verifiable();

UserManagerTest.cs (75)

Microsoft.AspNetCore.Identity.UI (8)

Areas\Identity\Pages\V4\Account\ExternalLogin.cshtml.cs (2)

185await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 186await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

Areas\Identity\Pages\V4\Account\Register.cshtml.cs (2)

131await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 132await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

Areas\Identity\Pages\V5\Account\ExternalLogin.cshtml.cs (2)

185await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 186await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

Areas\Identity\Pages\V5\Account\Register.cshtml.cs (2)

131await _userStore.SetUserNameAsync(user, Input.Email, CancellationToken.None); 132await _emailStore.SetEmailAsync(user, Input.Email, CancellationToken.None);

Microsoft.AspNetCore.Mvc.Core.Test (5)

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (4)

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (1)

348Assert.Equal(CancellationToken.None, sendFile.Token);

Microsoft.AspNetCore.Mvc.Formatters.Xml (4)

XmlDataContractSerializerInputFormatter.cs (2)

115await readStream.DrainAsync(CancellationToken.None); 134await readStream.DrainAsync(CancellationToken.None);

XmlSerializerInputFormatter.cs (2)

99await readStream.DrainAsync(CancellationToken.None); 118await readStream.DrainAsync(CancellationToken.None);

Microsoft.AspNetCore.Mvc.NewtonsoftJson (2)

NewtonsoftJsonInputFormatter.cs (2)

115await readStream.DrainAsync(CancellationToken.None); 134await readStream.DrainAsync(CancellationToken.None);

Microsoft.AspNetCore.OutputCaching (1)

Streams\OutputCacheStream.cs (1)

220=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

Microsoft.AspNetCore.OutputCaching.Microbenchmarks (6)

EndToEndBenchmarks.cs (6)

130await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None); 140await WriteInRandomChunksAsync(Payload, oc, CancellationToken.None); 146await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None); 157await WriteInRandomChunks(Payload, pipe, CancellationToken.None); 163await OutputCacheEntryFormatter.StoreAsync(Key, entry, _tags, _options.DefaultExpirationTimeSpan, _store, NullLogger.Instance, CancellationToken.None); 174var entry = await OutputCacheEntryFormatter.GetAsync(Key, _store, CancellationToken.None);

Microsoft.AspNetCore.OutputCaching.StackExchangeRedis (1)

RedisOutputCacheStore.cs (1)

128var cache = await ConnectAsync(CancellationToken.None).ConfigureAwait(false);

Microsoft.AspNetCore.OutputCaching.Tests (1)

OutputCacheEntryFormatterTests.cs (1)

74var payload = await store.GetAsync(key, CancellationToken.None);

Microsoft.AspNetCore.Owin (3)

OwinEnvironment.cs (2)

110_context.Items[OwinConstants.CallCancelled] = CancellationToken.None; 124feature => new Func<Task>(() => feature.GetClientCertificateAsync(CancellationToken.None))));

WebSockets\OwinWebSocketAcceptAdapter.cs (1)

129adapter.UpstreamTask.ContinueWith(adapter.EnsureCompleted, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

Microsoft.AspNetCore.Owin.Tests (1)

OwinEnvironmentTests.cs (1)

124Assert.Equal(CancellationToken.None, env["owin.CallCancelled"]);

Microsoft.AspNetCore.ResponseCaching (2)

src\Shared\SegmentWriteStream.cs (1)

182=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

Streams\ResponseCachingStream.cs (1)

185=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

Microsoft.AspNetCore.ResponseCaching.Microbenchmarks (2)

ResponseCachingBenchmark.cs (2)

55var consumer = ConsumeAsync(pipe.Reader, CancellationToken.None); 73var consumer = ConsumeAsync(pipe.Reader, CancellationToken.None);

Microsoft.AspNetCore.ResponseCompression (1)

ResponseCompressionBody.cs (1)

172=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

Microsoft.AspNetCore.ResponseCompression.Tests (4)

ResponseCompressionBodyTest.cs (1)

71await stream.SendFileAsync(path, 0, null, CancellationToken.None);

ResponseCompressionMiddlewareTest.cs (3)

1052return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); 1102return sendFile.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None); 1152await feature.SendFileAsync("testfile1kb.txt", 0, null, CancellationToken.None);

Microsoft.AspNetCore.Server.HttpSys (5)

NativeInterop\DisconnectListener.cs (1)

33return CancellationToken.None;

RequestProcessing\RequestContext.cs (2)

50_disconnectToken = CancellationToken.None; 63_disconnectToken = CancellationToken.None;

RequestProcessing\RequestStream.cs (1)

182=> TaskToApm.Begin(ReadAsync(buffer, offset, size, CancellationToken.None), callback, state);

ResponseStream.cs (1)

74=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

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

HttpsTests.cs (2)

84var cert = await tls.GetClientCertificateAsync(CancellationToken.None); 109var cert = await tls.GetClientCertificateAsync(CancellationToken.None);

MessagePumpTests.cs (6)

31server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 52server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 69server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 90server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 106server.StartAsync(new DummyApplication(), CancellationToken.None).Wait(); 117server.StartAsync(new DummyApplication(), CancellationToken.None).Wait();

RequestTests.cs (1)

583server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();

ResponseCachingTests.cs (2)

377await httpContext.Response.SendFileAsync(_absoluteFilePath, 0, null, CancellationToken.None); 397await httpContext.Response.SendFileAsync(_absoluteFilePath, 0, null, CancellationToken.None);

ResponseSendFileTests.cs (17)

ServerTests.cs (1)

348await server.StartAsync(new DummyApplication(), CancellationToken.None);

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

102}, CancellationToken.None);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

Utilities.cs (2)

130server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait(); 160server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();

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

Utilities.cs (1)

49server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();

Microsoft.AspNetCore.Server.IIS (1)

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

Microsoft.AspNetCore.Server.IntegrationTesting (1)

Common\DeploymentResult.cs (1)

43: this(loggerFactory, deploymentParameters: deploymentParameters, applicationBaseUri: applicationBaseUri, contentRoot: string.Empty, hostShutdownToken: CancellationToken.None)

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

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

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

AddressBinderTests.cs (5)

169AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None)); 190var bindTask = AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None); 218var bindTask = AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None); 281await AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None); 312await AddressBinder.BindAsync(options.GetListenOptions(), addressBindContext, _noopUseHttps, CancellationToken.None);

HttpRequestStreamTests.cs (1)

112mockMessageBody.Setup(m => m.ReadAsync(CancellationToken.None)).Returns(new ValueTask<ReadResult>(new ReadResult(default, isCanceled: false, isCompleted: true)));

HttpResponseStreamTests.cs (1)

114mockHttpResponseControl.Setup(m => m.WritePipeAsync(It.IsAny<ReadOnlyMemory<byte>>(), CancellationToken.None)).Returns(new ValueTask<FlushResult>(new FlushResult()));

KestrelServerTests.cs (15)

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (5)

QuicTestHelpers.cs (2)

62return (QuicConnectionListener)await transportFactory.BindAsync(endpoint, features, cancellationToken: CancellationToken.None); 77return (QuicConnectionListener)await transportFactory.BindAsync(endpoint, features, cancellationToken: CancellationToken.None);

QuicTransportFactoryTests.cs (3)

32var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: null, cancellationToken: CancellationToken.None).AsTask()).DefaultTimeout(); 49var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: features, cancellationToken: CancellationToken.None).AsTask()).DefaultTimeout(); 72await quicTransportFactory.BindAsync(new IPEndPoint(0, 0), features: features, cancellationToken: CancellationToken.None).AsTask().DefaultTimeout();

Microsoft.AspNetCore.Shared.Tests (2)

src\Shared\SegmentWriteStream.cs (1)

182=> TaskToApm.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

src\Shared\ServerInfrastructure\DuplexPipeStream.cs (1)

108FlushAsync(CancellationToken.None).GetAwaiter().GetResult();

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

HubConnection.cs (8)

248/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 301/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 412/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 434/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 456/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 601CancellationToken.None, 654/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 1284var sendHandshakeResult = await startingConnectionState.Connection.Transport.Output.FlushAsync(CancellationToken.None).ConfigureAwait(false);

HubConnectionExtensions.InvokeAsync.cs (12)

HubConnectionExtensions.InvokeAsyncGeneric.cs (12)

HubConnectionExtensions.SendAsync.cs (11)

HubConnectionExtensions.StreamAsChannelAsync.cs (12)

HubConnectionExtensions.StreamAsync.cs (11)

Microsoft.AspNetCore.SignalR.Core (37)

ClientProxyExtensions.cs (22)

HubConnectionContext.cs (1)

228/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

HubLifetimeManager.cs (11)

IClientProxy.cs (1)

21/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

IGroupManager.cs (2)

16/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 25/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

Microsoft.AspNetCore.SignalR.Tests (16)

EndToEndTests.cs (10)

HubConnectionHandlerTestUtils\Hubs.cs (1)

352var result = await caller.InvokeAsync<int>("GetResult", 1, CancellationToken.None);

Internal\TypedClientBuilderTests.cs (5)

27Assert.Equal(CancellationToken.None, send.CancellationToken); 51Assert.Equal(CancellationToken.None, send.CancellationToken); 80Assert.Equal(CancellationToken.None, send1.CancellationToken); 88Assert.Equal(CancellationToken.None, send2.CancellationToken); 223Assert.Equal(CancellationToken.None, send.CancellationToken);

Microsoft.AspNetCore.SpaServices.Extensions (1)

Util\EventedStreamReader.cs (1)

30Task.Factory.StartNew(Run, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

Microsoft.AspNetCore.SpaServices.Extensions.Tests (2)

SpaProxyTests.cs (1)

58var res = await SpaProxy.PerformProxyRequest(context, httpClient, baseUriTask, CancellationToken.None, true);

SpaServicesExtensionsTests.cs (1)

88public CancellationToken ApplicationStarted => CancellationToken.None;

Microsoft.AspNetCore.TestHost (1)

ResponseBodyReaderStream.cs (1)

66return ReadAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();

Microsoft.AspNetCore.TestHost.Tests (31)

ClientHandlerTests.cs (6)

221var response = await invoker.SendAsync(message, CancellationToken.None); 316var responseTask = invoker.SendAsync(message, CancellationToken.None); 344Assert.Throws<NotSupportedException>(() => invoker.Send(message, CancellationToken.None)); 363HttpResponseMessage response = await invoker.SendAsync(message, CancellationToken.None); 366response = await invoker.SendAsync(message, CancellationToken.None); 500responseTask = invoker.SendAsync(message, CancellationToken.None);

TestClientTests.cs (25)

Microsoft.AspNetCore.WebSockets.Tests (74)

SendReceiveTests.cs (11)

WebSocketCompressionMiddlewareTests.cs (2)

125var result = await webSocket.ReceiveAsync(serverBuffer, CancellationToken.None); 142await client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None);

WebSocketMiddlewareTests.cs (61)

Microsoft.AspNetCore.WebUtilities (2)

MultipartReader.cs (1)

85/// The default value is <see cref="CancellationToken.None"/>.</param>

MultipartSectionStreamExtensions.cs (1)

20=> section.ReadAsStringAsync(CancellationToken.None).AsTask();

Microsoft.Build (6)

BackEnd\BuildManager\BuildManager.cs (1)

1193MSBuildClient.ShutdownServer(CancellationToken.None);

BackEnd\Client\MSBuildClient.cs (1)

346waitHandles[0] = CancellationToken.None.WaitHandle;

BackEnd\Components\ProjectCache\ProjectCacheService.cs (1)

841await plugin.Instance.EndBuildAsync(pluginLogger, CancellationToken.None);

CommunicationsUtilities.cs (1)

593int bytesRead = await stream.ReadAsync(buffer.AsMemory(totalBytesRead, bytesToRead - totalBytesRead), CancellationToken.None);

Graph\ProjectGraph.cs (1)

342CancellationToken.None)

Logging\BinaryLogger\BinaryLogReplayEventSource.cs (1)

93Replay(sourceFilePath, CancellationToken.None);

Microsoft.Build.CommandLine.UnitTests (2)

MSBuildServer_Tests.cs (2)

259bool serverIsDown = MSBuildClient.ShutdownServer(CancellationToken.None); 271bool serverIsDown = MSBuildClient.ShutdownServer(CancellationToken.None);

Microsoft.Build.Engine.UnitTests (36)

BackEnd\TargetBuilder_Tests.cs (31)

BackEnd\TargetEntry_Tests.cs (1)

1003entry.ExecuteTarget(taskBuilder, entry.RequestEntry, GetProjectLoggingContext(entry.RequestEntry), CancellationToken.None).GetAwaiter().GetResult();

BackEnd\TaskExecutionHost_Tests.cs (3)

999CancellationToken.None); 1027CancellationToken.None); 1266CancellationToken.None);

Graph\ParallelWorkSet_Tests.cs (1)

239_workSet = new ParallelWorkSet<string, string>(tt.DegreeOfParallelism, StringComparer.Ordinal, CancellationToken.None);

Microsoft.DotNet.AsmDiff (2)

DiffEngine.cs (2)

58return new DiffCsvWriter(csvTextWriter, mappingSettings, diffColumns, CancellationToken.None); 137return BuildDiffDocument(configuration, CancellationToken.None);

Microsoft.DotNet.Build.Tasks.Feed.Tests (1)

TestDoubles\MockRetryHandler.cs (1)

29=> RunAsync(actionSuccessfulAsync, CancellationToken.None);

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

UpdatePackageIndex.cs (2)

192IEnumerable<Version> stablePackageVersions = NuGetUtility.GetAllVersionsForPackageId(package.Key, includePrerelease: false, includeUnlisted: false, Log, CancellationToken.None); 271IEnumerable<Version> allStableVersions = NuGetUtility.GetAllVersionsForPackageId(id, includePrerelease: false, includeUnlisted: false, Log, CancellationToken.None);

ValidateHarvestVersionIsLatestForRelease.cs (1)

137IEnumerable<Version> packageVersions = NuGetUtility.GetAllVersionsForPackageId(packageId, includePrerelease: false, includeUnlisted: false, Log, CancellationToken.None);

Microsoft.DotNet.Helix.Sdk (2)

AzureDevOpsTask.cs (2)

96CancellationToken.None); 112CancellationToken.None);

Microsoft.DotNet.SignCheckLibrary (1)

Verification\NupkgVerifier.cs (1)

46Task<VerifySignaturesResult> verifySignatureResult = packageSignatureVerifier.VerifySignaturesAsync(pr, verifierSettings, CancellationToken.None);

Microsoft.Extensions.Caching.Hybrid (1)

Internal\DefaultHybridCache.StampedeState.cs (1)

48SharedToken = CancellationToken.None;

Microsoft.Extensions.Caching.Hybrid.Tests (14)

StampedeTests.cs (14)

Microsoft.Extensions.Caching.Memory (3)

CacheEntry.CacheEntryTokens.cs (1)

110CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

CacheEntry.cs (1)

284}, obj, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

MemoryCache.cs (1)

357CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

Microsoft.Extensions.DependencyInjection (1)

ServiceLookup\StackGuard.cs (1)

68Task<R> task = Task.Factory.StartNew((Func<object?, R>)action, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

Microsoft.Extensions.FileProviders.Physical (1)

PhysicalFilesWatcher.cs (1)

462CancellationToken.None,

Microsoft.Extensions.Hosting.Abstractions (1)

HostingAbstractionsHostExtensions.cs (1)

115await host.StopAsync(CancellationToken.None).ConfigureAwait(false);

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

PolicyHttpMessageHandlerTest.cs (11)

Microsoft.Extensions.Identity.Core (2)

RoleManager.cs (1)

28protected virtual CancellationToken CancellationToken => CancellationToken.None;

UserManager.cs (1)

55protected virtual CancellationToken CancellationToken => CancellationToken.None;

Microsoft.JSInterop (5)

JSObjectReferenceExtensions.cs (2)

98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;

JSRuntime.cs (1)

94return await InvokeAsync<TValue>(targetInstanceId, identifier, CancellationToken.None, args);

JSRuntimeExtensions.cs (2)

98var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None; 116var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;

Microsoft.JSInterop.Tests (4)

JSObjectReferenceTest.cs (1)

51await Assert.ThrowsAsync<ObjectDisposedException>(async () => await jsObject.InvokeAsync<object>("test", CancellationToken.None, "arg1", "arg2"));

JSRuntimeExtensionsTest.cs (2)

124Assert.True(cts == CancellationToken.None); 168Assert.True(cts == CancellationToken.None);

JSRuntimeTest.cs (1)

415var exception = await Assert.ThrowsAsync<NotSupportedException>(async () => await runtime.ReadJSDataAsStreamAsync(dataReference, 10, CancellationToken.None));

System.Collections.Concurrent (16)

System\Collections\Concurrent\BlockingCollection.cs (16)

System.ComponentModel.EventBasedAsync (1)

System\ComponentModel\BackgroundWorker.cs (1)

131CancellationToken.None,

System.Data.Common (12)

System\Data\Common\DbCommand.cs (4)

119public Task<int> ExecuteNonQueryAsync() => ExecuteNonQueryAsync(CancellationToken.None); 151ExecuteReaderAsync(CommandBehavior.Default, CancellationToken.None); 157ExecuteReaderAsync(behavior, CancellationToken.None); 192ExecuteScalarAsync(CancellationToken.None);

System\Data\Common\DbConnection.cs (1)

322public Task OpenAsync() => OpenAsync(CancellationToken.None);

System\Data\Common\DbDataReader.cs (4)

248GetFieldValueAsync<T>(ordinal, CancellationToken.None); 273public Task<bool> IsDBNullAsync(int ordinal) => IsDBNullAsync(ordinal, CancellationToken.None); 298public Task<bool> ReadAsync() => ReadAsync(CancellationToken.None); 319public Task<bool> NextResultAsync() => NextResultAsync(CancellationToken.None);

System\Data\Common\DbTransaction.cs (3)

91/// An optional token to cancel the asynchronous operation. The default value is <see cref="CancellationToken.None" />. 117/// An optional token to cancel the asynchronous operation. The default value is <see cref="CancellationToken.None" />. 144/// An optional token to cancel the asynchronous operation. The default value is <see cref="CancellationToken.None" />.

System.Diagnostics.Process (2)

System\Diagnostics\ProcessWaitState.Unix.cs (2)

285_waitInProgress = WaitForExitAsync(CancellationToken.None); 465CancellationToken.None :

System.Formats.Tar (8)

System\Formats\Tar\TarEntry.cs (1)

209/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

System\Formats\Tar\TarFile.cs (4)

58/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 127/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 199/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 285/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

System\Formats\Tar\TarReader.cs (1)

165/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

System\Formats\Tar\TarWriter.cs (2)

147/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param> 233/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.</param>

System.IO.Compression (6)

System\IO\Compression\DeflateManaged\DeflateManagedStream.cs (1)

155TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState);

System\IO\Compression\DeflateZLib\DeflateStream.cs (3)

359TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState); 766TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState); 880this(deflateStream, destination, bufferSize, CancellationToken.None)

System\IO\Compression\GZipStream.cs (2)

75TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState); 103TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState);

System.IO.Compression.Brotli (8)

System\IO\Compression\BrotliStream.cs (1)

106await WriteAsyncMemoryCore(ReadOnlyMemory<byte>.Empty, CancellationToken.None, isFinalBlock: true).ConfigureAwait(false);

System\IO\Compression\dec\BrotliStream.Decompress.cs (3)

99TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState); 114/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> 127/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param>

System\IO\Compression\enc\BrotliStream.Compress.cs (4)

97TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState); 109/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> 122/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> 195/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param>

System.IO.Hashing (1)

System\IO\Hashing\NonCryptographicHashAlgorithm.cs (1)

135/// The default value is <see cref="CancellationToken.None"/>.

System.IO.Pipelines (6)

System\IO\Pipelines\PipeReader.cs (2)

176/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> 198/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param>

System\IO\Pipelines\PipeWriter.cs (3)

57/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> 111/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param> 121/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param>

System\IO\Pipelines\StreamPipeExtensions.cs (1)

15/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None" />.</param>

System.IO.Pipes (6)

System\IO\Pipes\NamedPipeClientStream.cs (3)

126ConnectInternal(timeout, CancellationToken.None, Environment.TickCount); 168return ConnectAsync(Timeout.Infinite, CancellationToken.None); 173return ConnectAsync(timeout, CancellationToken.None);

System\IO\Pipes\NamedPipeServerStream.cs (1)

159return WaitForConnectionAsync(CancellationToken.None);

System\IO\Pipes\PipeStream.Unix.cs (2)

106=> TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state); 180=> TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

System.IO.Ports (3)

System\IO\Ports\SerialStream.Unix.cs (3)

427Task<int> t = ReadAsync(array, offset, count, cts?.Token ?? CancellationToken.None); 564Task t = WriteAsync(array, offset, count, cts?.Token ?? CancellationToken.None); 685CancellationToken.None,

System.Linq.Expressions (1)

System\Linq\Expressions\StackGuard.cs (1)

68Task<R> task = Task.Factory.StartNew(action!, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

System.Linq.Parallel (2)

System\Linq\Parallel\QueryOperators\QuerySettings.cs (1)

199get { return new QuerySettings(null, null, CancellationToken.None, null, null); }

System\Linq\Parallel\Scheduling\QueryTask.cs (1)

84return Task.Factory.StartNew(s_baseWorkDelegate, this, CancellationToken.None, TaskCreationOptions.AttachedToParent | TaskCreationOptions.PreferFairness, taskScheduler);

System.Net.Http (40)

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

63WriteAsync(buffer, offset, count, CancellationToken.None).GetAwaiter().GetResult();

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

System\Net\Http\HttpContent.cs (8)

140ReadAsStringAsync(CancellationToken.None); 225ReadAsByteArrayAsync(CancellationToken.None); 242ReadAsStream(CancellationToken.None); 272ReadAsStreamAsync(CancellationToken.None); 374CopyToAsync(stream, CancellationToken.None); 380CopyToAsync(stream, context, CancellationToken.None); 477LoadIntoBufferAsync(maxBufferSize, CancellationToken.None); 1036TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState);

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

103}, tcs, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

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

241CreateContentReadStreamAsyncCore(async: true, CancellationToken.None).AsTask(); 530TaskToAsyncResult.Begin(ReadAsync(array, offset, count, CancellationToken.None), asyncCallback, asyncState);

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

966CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

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

144SerializeToStreamAsync(stream, context, CancellationToken.None);

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

2007CancellationToken requestBodyCancellationToken = duplex ? CancellationToken.None : cancellationToken;

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

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

1120if (_responseDataPayloadRemaining <= 0 && !ReadNextDataFrameAsync(response, CancellationToken.None).AsTask().GetAwaiter().GetResult()) 1175HandleReadResponseContentException(ex, CancellationToken.None);

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

185CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 202CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);

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

49SerializeToStreamAsync(stream, context, CancellationToken.None);

System.Net.Http.Json (1)

System\Net\Http\Json\JsonContent.cs (1)

105=> SerializeToStreamAsyncCore(stream, CancellationToken.None);

System.Net.HttpListener (1)

src\libraries\Common\src\System\Net\LazyAsyncResult.cs (1)

371CancellationToken.None,

System.Net.Mail (6)

src\libraries\Common\src\System\Net\LazyAsyncResult.cs (1)

371CancellationToken.None,

System\Net\Base64Stream.cs (2)

67TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state); 70TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

System\Net\BufferedReadStream.cs (1)

43TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state);

System\Net\Mime\QEncodedStream.cs (1)

56TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

System\Net\Mime\QuotedPrintableStream.cs (1)

86TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

System.Net.NameResolution (7)

System\Net\Dns.cs (7)

91GetHostEntryAsync(hostNameOrAddress, AddressFamily.Unspecified, CancellationToken.None); 139}, hostNameOrAddress, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); 162}, address, CancellationToken.None); 215(Task<IPAddress[]>)GetHostEntryOrAddressesCoreAsync(hostNameOrAddress, justReturnParsedIp: true, throwOnIIPAny: true, justAddresses: true, AddressFamily.Unspecified, CancellationToken.None); 267TaskToAsyncResult.Begin(GetHostEntryCoreAsync(hostName, justReturnParsedIp: true, throwOnIIPAny: true, AddressFamily.Unspecified, CancellationToken.None), requestCallback, stateObject); 330TaskToAsyncResult.Begin(GetHostEntryCoreAsync(hostName, justReturnParsedIp: false, throwOnIIPAny: false, AddressFamily.Unspecified, CancellationToken.None), requestCallback, stateObject); 698}, key, CancellationToken.None, TaskContinuationOptions.OnlyOnCanceled | TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

System.Net.NetworkInformation (1)

System\Net\NetworkInformation\UnixIPGlobalProperties.cs (1)

57CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

System.Net.Ping (5)

System\Net\NetworkInformation\Ping.cs (5)

530}, AsyncOperationManager.CreateOperation(userToken), CancellationToken.None, TaskContinuationOptions.DenyChildAttach, TaskScheduler.Default); 565return SendPingAsync(address, timeout, buffer, options, CancellationToken.None); 581/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> 605return SendPingAsync(hostNameOrAddress, timeout, buffer, options, CancellationToken.None); 624/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>

System.Net.Quic (2)

System\Net\Quic\Internal\ResettableValueTaskSource.cs (1)

320}, handle, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

System\Net\Quic\QuicStream.cs (1)

350/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>

System.Net.Requests (6)

src\libraries\Common\src\System\Net\LazyAsyncResult.cs (1)

371CancellationToken.None,

System\Net\FileWebRequest.cs (4)

159this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 172}, this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 220this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 233}, this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

System\Net\TaskExtensions.cs (1)

37}, CancellationToken.None, TaskContinuationOptions.None, TaskScheduler.Default);

System.Net.Security (4)

System\Net\Security\SslStream.cs (4)

252return BeginAuthenticateAsClient(options, CancellationToken.None, asyncCallback, asyncState); 291return BeginAuthenticateAsServer(options, CancellationToken.None, asyncCallback, asyncState); 839return TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState); 851return TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), asyncCallback, asyncState);

System.Net.Sockets (6)

System\Net\Sockets\Socket.cs (1)

2674public bool AcceptAsync(SocketAsyncEventArgs e) => AcceptAsync(e, CancellationToken.None);

System\Net\Sockets\Socket.Tasks.cs (3)

32public Task<Socket> AcceptAsync() => AcceptAsync((Socket?)null, CancellationToken.None).AsTask(); 46public Task<Socket> AcceptAsync(Socket? acceptSocket) => AcceptAsync(acceptSocket, CancellationToken.None).AsTask(); 152public Task ConnectAsync(IPAddress[] addresses, int port) => ConnectAsync(addresses, port, CancellationToken.None).AsTask();

System\Net\Sockets\TCPListener.cs (2)

220public Task<Socket> AcceptSocketAsync() => AcceptSocketAsync(CancellationToken.None).AsTask(); 232public Task<TcpClient> AcceptTcpClientAsync() => AcceptTcpClientAsync(CancellationToken.None).AsTask();

System.Net.WebSockets (3)

System\Net\WebSockets\ManagedWebSocket.cs (3)

232Task lockTask = mutex.EnterAsync(CancellationToken.None); 592ValueTask t = SendFrameAsync(MessageOpcode.Pong, endOfMessage: true, disableCompression: true, ReadOnlyMemory<byte>.Empty, CancellationToken.None); 601CancellationToken.None,

System.Private.CoreLib (34)

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipeEventDispatcher.cs (2)

139m_dispatchTask = Task.Factory.StartNew(() => DispatchEventsToEventListeners(sessionID, syncTimeUtc, syncTimeQPC, timeQPCFrequency, previousDispatchTask, m_dispatchTaskCancellationSource.Token), CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default); 161previousDispatchTask?.Wait(CancellationToken.None);

src\libraries\System.Private.CoreLib\src\System\IO\BufferedStream.cs (2)

728TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state); 1141TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

src\libraries\System.Private.CoreLib\src\System\IO\File.cs (3)

720/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="System.Threading.CancellationToken.None"/>.</param> 781/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> 791/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>

src\libraries\System.Private.CoreLib\src\System\IO\Strategies\BufferedFileStreamStrategy.cs (2)

459=> TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state); 742=> TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

src\libraries\System.Private.CoreLib\src\System\IO\Stream.cs (5)

81public Task CopyToAsync(Stream destination, int bufferSize) => CopyToAsync(destination, bufferSize, CancellationToken.None); 189public Task FlushAsync() => FlushAsync(CancellationToken.None); 301public Task<int> ReadAsync(byte[] buffer, int offset, int count) => ReadAsync(buffer, offset, count, CancellationToken.None); 665base(function, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach) 729public Task WriteAsync(byte[] buffer, int offset, int count) => WriteAsync(buffer, offset, count, CancellationToken.None);

src\libraries\System.Private.CoreLib\src\System\IO\StreamReader.cs (1)

1072Task<int> task = ReadAsyncInternal(new Memory<char>(buffer, index, count), CancellationToken.None).AsTask();

src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (1)

942return (_asyncWriteTask = FlushAsyncInternal(flushStream: true, flushEncoder: true, CancellationToken.None));

src\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (7)

543}, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 550}, new TupleSlim<TextWriter, string?>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 589}, new TupleSlim<TextWriter, char[], int, int>(this, buffer, index, count), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 606}, new TupleSlim<TextWriter, char>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 613}, new TupleSlim<TextWriter, string?>(this, value), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 653}, new TupleSlim<TextWriter, char[], int, int>(this, buffer, index, count), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default); 673CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

src\libraries\System.Private.CoreLib\src\System\Text\TranscodingStream.cs (2)

86=> TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state); 89=> TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

src\libraries\System.Private.CoreLib\src\System\Threading\CancellationTokenSource.cs (1)

343}, this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

src\libraries\System.Private.CoreLib\src\System\Threading\ManualResetEventSlim.cs (3)

353Wait(Timeout.Infinite, CancellationToken.None); 404return Wait((int)totalMilliseconds, CancellationToken.None); 458return Wait(millisecondsTimeout, CancellationToken.None);

src\libraries\System.Private.CoreLib\src\System\Threading\SemaphoreSlim.cs (3)

178Wait(Timeout.Infinite, CancellationToken.None); 222return Wait((int)timeout.TotalMilliseconds, CancellationToken.None); 269return Wait(millisecondsTimeout, CancellationToken.None);

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Sources\ManualResetValueTaskSourceCore.cs (1)

311Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, scheduler);

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\TaskCanceledException.cs (1)

73base(SR.TaskCanceledException_ctor_DefaultMessage, task != null ? task.CancellationToken : CancellationToken.None)

System.Security.Cryptography (64)

System\Security\Cryptography\CryptographicOperations.cs (5)

281/// The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />. 332/// The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />. 629/// The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />. 672/// The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />. 721/// The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" />.

System\Security\Cryptography\CryptoStream.cs (3)

125/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> 252TaskToAsyncResult.Begin(ReadAsync(buffer, offset, count, CancellationToken.None), callback, state); 491TaskToAsyncResult.Begin(WriteAsync(buffer, offset, count, CancellationToken.None), callback, state);

System\Security\Cryptography\HMACMD5.cs (3)

248/// The default value is <see cref="System.Threading.CancellationToken.None" />. 275/// The default value is <see cref="System.Threading.CancellationToken.None" />. 300/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\HMACSHA1.cs (3)

247/// The default value is <see cref="System.Threading.CancellationToken.None" />. 273/// The default value is <see cref="System.Threading.CancellationToken.None" />. 297/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\HMACSHA256.cs (3)

239/// The default value is <see cref="System.Threading.CancellationToken.None" />. 265/// The default value is <see cref="System.Threading.CancellationToken.None" />. 289/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\HMACSHA3_256.cs (3)

279/// The default value is <see cref="System.Threading.CancellationToken.None" />. 306/// The default value is <see cref="System.Threading.CancellationToken.None" />. 330/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\HMACSHA3_384.cs (3)

System\Security\Cryptography\HMACSHA3_512.cs (3)

System\Security\Cryptography\HMACSHA384.cs (3)

256/// The default value is <see cref="System.Threading.CancellationToken.None" />. 282/// The default value is <see cref="System.Threading.CancellationToken.None" />. 306/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\HMACSHA512.cs (3)

253/// The default value is <see cref="System.Threading.CancellationToken.None" />. 279/// The default value is <see cref="System.Threading.CancellationToken.None" />. 303/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\Kmac128.cs (3)

378/// The default value is <see cref="System.Threading.CancellationToken.None" />. 425/// The default value is <see cref="System.Threading.CancellationToken.None" />. 471/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\Kmac256.cs (3)

System\Security\Cryptography\KmacXof128.cs (3)

System\Security\Cryptography\KmacXof256.cs (3)

System\Security\Cryptography\MD5.cs (2)

183/// The default value is <see cref="System.Threading.CancellationToken.None" />. 210/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA1.cs (2)

176/// The default value is <see cref="System.Threading.CancellationToken.None" />. 202/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA256.cs (2)

176/// The default value is <see cref="System.Threading.CancellationToken.None" />. 202/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA3_256.cs (2)

217/// The default value is <see cref="System.Threading.CancellationToken.None" />. 247/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA3_384.cs (2)

218/// The default value is <see cref="System.Threading.CancellationToken.None" />. 248/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA3_512.cs (2)

217/// The default value is <see cref="System.Threading.CancellationToken.None" />. 247/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA384.cs (2)

175/// The default value is <see cref="System.Threading.CancellationToken.None" />. 201/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\SHA512.cs (2)

175/// The default value is <see cref="System.Threading.CancellationToken.None" />. 201/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\Shake128.cs (2)

401/// The default value is <see cref="System.Threading.CancellationToken.None" />. 437/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System\Security\Cryptography\Shake256.cs (2)

401/// The default value is <see cref="System.Threading.CancellationToken.None" />. 437/// The default value is <see cref="System.Threading.CancellationToken.None" />.

System.Security.Cryptography.Cose (5)

System\Security\Cryptography\Cose\CoseMultiSignMessage.cs (2)

232/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> 822/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>

System\Security\Cryptography\Cose\CoseSign1Message.cs (2)

199/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param> 649/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>

System\Security\Cryptography\Cose\CoseSignature.cs (1)

324/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>

System.Text.Json.SourceGeneration (1)

JsonSourceGenerator.Roslyn3.11.cs (1)

37context.RegisterForSyntaxNotifications(static () => new SyntaxContextReceiver(CancellationToken.None));

System.Text.RegularExpressions (11)

System\Threading\StackHelper.cs (11)

System.Text.RegularExpressions.Generator (11)

src\libraries\System.Text.RegularExpressions\src\System\Threading\StackHelper.cs (11)

System.Threading (6)

System\Threading\Barrier.cs (3)

483SignalAndWait(CancellationToken.None); 538return SignalAndWait(timeout, CancellationToken.None); 598return SignalAndWait(millisecondsTimeout, CancellationToken.None);

System\Threading\CountdownEvent.cs (3)

411Wait(Timeout.Infinite, CancellationToken.None); 463return Wait((int)totalMilliseconds, CancellationToken.None); 514return Wait(millisecondsTimeout, CancellationToken.None);

System.Threading.Channels (2)

System\Threading\Channels\AsyncOperation.cs (2)

292Task.Factory.StartNew(continuation, state, CancellationToken.None, TaskCreationOptions.DenyChildAttach, ts); 419CancellationToken.None, TaskCreationOptions.DenyChildAttach, ts);

System.Threading.Tasks.Dataflow (57)

Base\DataflowBlock.cs (17)

Base\DataflowBlockOptions.cs (4)

40/// <description><see cref="System.Threading.CancellationToken.None"/></description> 71private CancellationToken _cancellationToken = CancellationToken.None; 218/// <description><see cref="System.Threading.CancellationToken.None"/></description> 350/// <description><see cref="System.Threading.CancellationToken.None"/></description>

Blocks\ActionBlock.cs (1)

196}, this, CancellationToken.None, Common.GetContinuationOptions(TaskContinuationOptions.ExecuteSynchronously), TaskScheduler.Default);

Blocks\BatchBlock.cs (4)

75CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default); 86}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 550}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 658exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

Blocks\BatchedJoinBlock.cs (2)

104}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 356}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);

Blocks\BroadcastBlock.cs (6)

96}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 277exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 410}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 656}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 870}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 953this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

Blocks\BufferBlock.cs (3)

78}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 278exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 413}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

Blocks\JoinBlock.cs (5)

89CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default); 100}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 314CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default); 325}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 1350}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

Blocks\TransformBlock.cs (3)

148}, _source, CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default); 159}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 264}, Tuple.Create(this, messageWithId), CancellationToken.None,

Blocks\TransformManyBlock.cs (3)

144}, source, CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default); 155}, this, CancellationToken.None, Common.GetContinuationOptions() | TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default); 245CancellationToken.None,

Blocks\TransformManyBlock.IAsyncEnumerable.cs (1)

43t.ContinueWith(static t => Debug.Assert(t.IsCompletedSuccessfully), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

Blocks\WriteOnceBlock.cs (1)

145Tuple.Create(this, exceptions), CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

Internal\Common.cs (1)

574target, CancellationToken.None, Common.GetContinuationOptions(), TaskScheduler.Default);

Internal\SourceCore.cs (3)

529}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 792}, this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 926this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

Internal\SpscTargetCore.cs (1)

168this, CancellationToken.None, Common.GetCreationOptionsForTask(isReplica));

Internal\TargetCore.cs (2)

390exception, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default); 746this, CancellationToken.None, Common.GetCreationOptionsForTask(), TaskScheduler.Default);

System.Threading.Tasks.Parallel (3)

System\Threading\Tasks\Parallel.cs (1)

49_cancellationToken = CancellationToken.None;

System\Threading\Tasks\Parallel.ForEachAsync.cs (1)

626return _lock.WaitAsync(CancellationToken.None);

System\Threading\Tasks\TaskReplicator.cs (1)

79_pendingTask = new Task(s => ((Replica)s!).Execute(), this, CancellationToken.None, TaskCreationOptions.None);

Wasm.Performance.Driver (1)

Program.cs (1)

26var stressRunCancellation = CancellationToken.None;

WebSocketSample (5)

Program.cs (5)

28await ws.ConnectAsync(new Uri(url), CancellationToken.None); 38await ws.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, endOfMessage: true, cancellationToken: CancellationToken.None); 41await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); 55var result = await ws.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); 66await ws.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);

WebTransportInteractiveSampleApp (2)

Program.cs (2)

62var session = await feature.AcceptAsync(CancellationToken.None); 74stream = await session.AcceptStreamAsync(CancellationToken.None);

WebTransportSampleApp (3)

Program.cs (3)

31var session = await feature.AcceptAsync(CancellationToken.None); 34var stream = await session.AcceptStreamAsync(CancellationToken.None); 38var test = await stream.Transport.Input.AsStream().ReadAsync(memory, CancellationToken.None);