Reader

System\Threading\Channels\BoundedChannel.cs (1)

64Reader = new BoundedChannelReader(this);

System\Threading\Channels\RendezvousChannel.cs (1)

55Reader = new RendezvousChannelReader(this);

System\Threading\Channels\SingleConsumerUnboundedChannel.cs (1)

47Reader = new UnboundedChannelReader(this);

System\Threading\Channels\UnboundedChannel.cs (1)

41Reader = new UnboundedChannelReader(this);

System\Threading\Channels\UnboundedPriorityChannel.cs (1)

48Reader = new UnboundedPrioritizedChannelReader(this);

Interaction\ExtensionInteractionService.cs (2)

49while (await _extensionTaskChannel.Reader.WaitToReadAsync().ConfigureAwait(false)) 53var taskFunction = await _extensionTaskChannel.Reader.ReadAsync().ConfigureAwait(false);

Hosting\CliOrphanDetectorTests.cs (14)

ActivityNotifier.cs (1)

41await foreach (var activity in _activityChannel.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))

MetricsChannel.cs (1)

23public ChannelReader<string> Reader => _channel.Reader;

ServiceClient\DashboardClient.cs (3)

450await foreach (var update in _incomingInteractionChannel.Reader.ReadAllAsync(cts.Token).ConfigureAwait(false)) 639await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken: enumeratorCancellationToken).ConfigureAwait(false)) 685await foreach (var batch in channel.Reader.ReadAllAsync(combinedTokens.Token).ConfigureAwait(false))

src\Shared\ChannelExtensions.cs (2)

36if (await channel.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) 48while (!cancellationToken.IsCancellationRequested && channel.Reader.TryRead(out var log))

Telemetry\DashboardTelemetrySender.cs (3)

51while (await _channel.Reader.WaitToReadAsync().ConfigureAwait(false)) 53while (_channel.Reader.TryRead(out var operation)) 107while (_channel.Reader.TryRead(out _))

Interactions\InteractionsProviderTests.cs (2)

230var update = await sendInteractionUpdatesChannel.Reader.ReadAsync(); 293var update = await sendInteractionUpdatesChannel.Reader.ReadAsync();

Pages\ConsoleLogsTests.cs (3)

145var subscribedResourceName1 = await subscribedResourceNamesChannel.Reader.ReadAsync().DefaultTimeout(); 171var subscribedResourceName2 = await subscribedResourceNamesChannel.Reader.ReadAsync().DefaultTimeout(); 175Assert.False(await subscribedResourceNamesChannel.Reader.WaitToReadAsync().DefaultTimeout());

tests\Shared\TestDashboardClient.cs (5)

57return _resourceCommandsChannel.Reader.ReadAsync(cancellationToken).AsTask(); 69await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 84await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 103await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 123await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken))

ChannelExtensionsTests.cs (4)

91var read1 = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 96var read2 = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 135var read1 = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 140var read2Task = resultChannel.Reader.ReadAsync().DefaultTimeout();

Integration\DashboardClientAuthTests.cs (2)

44var call = await server.Calls.ResourceInformationCallsChannel.Reader.ReadAsync().DefaultTimeout(); 60var call = await server.Calls.ResourceInformationCallsChannel.Reader.ReadAsync().DefaultTimeout();

Model\AIAssistant\AIContextProviderTests.cs (4)

93var newContext = await changeChannel.Reader.ReadAsync().DefaultTimeout(); 97newContext = await changeChannel.Reader.ReadAsync().DefaultTimeout(); 103var newContextTask = changeChannel.Reader.ReadAsync(); 115Assert.False(await changeChannel.Reader.WaitToReadAsync().DefaultTimeout());

ResourceOutgoingPeerResolverTests.cs (6)

142Assert.False(resultChannel.Reader.TryRead(out readValue)); 151readValue = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 159readValue = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 167readValue = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 179Assert.False(await resultChannel.Reader.WaitToReadAsync().DefaultTimeout()); 184await foreach (var item in sourceChannel.Reader.ReadAllAsync(cancellationToken))

Telemetry\ComponentTelemetryContextTests.cs (9)

Telemetry\DashboardTelemetryServiceTests.cs (1)

68await foreach (var item in sender.ContextChannel.Reader.ReadAllAsync())

Telemetry\TelemetryLoggerProviderTests.cs (4)

33Assert.False(telemetrySender.ContextChannel.Reader.TryPeek(out _)); 38Assert.False(telemetrySender.ContextChannel.Reader.TryPeek(out _)); 42Assert.False(telemetrySender.ContextChannel.Reader.TryPeek(out _)); 46Assert.True(telemetrySender.ContextChannel.Reader.TryPeek(out var context));

TelemetryRepositoryTests\LogTests.cs (2)

748var read1 = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 769var read2 = await resultChannel.Reader.ReadAsync().DefaultTimeout();

tests\Shared\TestDashboardClient.cs (5)

57return _resourceCommandsChannel.Reader.ReadAsync(cancellationToken).AsTask(); 69await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 84await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 103await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 123await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken))

ApplicationModel\ResourceLoggerService.cs (2)

239await foreach (var entry in channel.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false)) 318await foreach (var item in channel.Reader.ReadAllAsync().ConfigureAwait(false))

ApplicationModel\ResourceNotificationService.cs (1)

556await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))

Backchannel\AppHostRpcTarget.cs (2)

39var logEntries = channel.Reader.ReadAllAsync(cancellationToken); 57var publishingActivity = await activityReporter.ActivityItemUpdated.Reader.ReadAsync(cancellationToken).ConfigureAwait(false);

Dcp\DcpExecutor.cs (1)

282await foreach (var entry in _logInformationChannel.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))

Devcontainers\DevcontainerSettingsWriter.cs (1)

69var reader = _portUpdates.Reader;

InteractionService.cs (1)

473await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))

src\Shared\ChannelExtensions.cs (2)

36if (await channel.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) 48while (!cancellationToken.IsCancellationRequested && channel.Reader.TryRead(out var log))

AzureDeployerTests.cs (9)

71var tenantInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 87var subscriptionInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 105var locationInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 458var parameterInputs = await testInteractionService.Interactions.Reader.ReadAsync(); 500Assert.Equal(0, testInteractionService.Interactions.Reader.Count); 529var parameterInputs = await testInteractionService.Interactions.Reader.ReadAsync(); 672Assert.Equal(0, testInteractionService.Interactions.Reader.Count); 697var parameterInputs = await testInteractionService.Interactions.Reader.ReadAsync(); 742var parameterInputs = await testInteractionService.Interactions.Reader.ReadAsync();

ProvisioningContextProviderTests.cs (6)

268var messageBarInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 275var inputsInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 362var messageBarInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 367var inputsInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 424var messageBarInteraction = await testInteractionService.Interactions.Reader.ReadAsync(); 431var inputsInteraction = await testInteractionService.Interactions.Reader.ReadAsync();

Dashboard\DashboardLifecycleHookTests.cs (1)

67var logContext = await logChannel.Reader.ReadAsync().DefaultTimeout();

Dcp\DcpExecutorTests.cs (2)

96await foreach (var item in channel.Reader.ReadAllAsync()) 742await foreach (var item in logStreamPipesChannel.Reader.ReadAllAsync())

Dcp\DcpHostNotificationTests.cs (6)

83var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 136await interactionService.Interactions.Reader.ReadAsync(cts.Token); 191await interactionService.Interactions.Reader.ReadAsync(cts.Token); 242var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 293var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token); 360var interaction = await interactionService.Interactions.Reader.ReadAsync(cts.Token);

Dcp\TestKubernetesService.cs (1)

149var (evtType, res) = await chan.Reader.ReadAsync(cancellationToken);

DistributedApplicationTests.cs (2)

778await beforeResourceStartedEvents.Reader.ReadAsync().DefaultTimeout(); 788await beforeResourceStartedEvents.Reader.ReadAsync().DefaultTimeout();

Health\ResourceHealthCheckServiceTests.cs (5)

170var e1 = await channel.Reader.ReadAsync().DefaultTimeout(); 198var e2 = await channel.Reader.ReadAsync().DefaultTimeout(); 318var firstCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 321var secondCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 324var thirdCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout();

InteractionServiceTests.cs (9)

Orchestrator\ParameterProcessorTests.cs (10)

Pipelines\DistributedApplicationPipelineTests.cs (7)

675var activityReader = reporter.ActivityItemUpdated.Reader; 716var activityReader = reporter.ActivityItemUpdated.Reader; 764var activityReader = reporter.ActivityItemUpdated.Reader; 807var activityReader = reporter.ActivityItemUpdated.Reader; 848var activityReader = reporter.ActivityItemUpdated.Reader; 892var activityReader = reporter.ActivityItemUpdated.Reader; 1049var activityReader = reporter.ActivityItemUpdated.Reader;

Publishing\PipelineActivityReporterTests.cs (38)

ResourceCommandServiceTests.cs (3)

105await foreach (var resourceName in commandResourcesChannel.Reader.ReadAllAsync().DefaultTimeout()) 142await foreach (var resourceName in commandResourcesChannel.Reader.ReadAllAsync().DefaultTimeout()) 153Assert.Equal(resourceName, await commandResourcesChannel.Reader.ReadAsync().DefaultTimeout());

Utils\Grpc\TestAsyncStreamReader.cs (2)

39if (await _channel.Reader.WaitToReadAsync(cancellationToken) && 40_channel.Reader.TryRead(out var message))

Utils\Grpc\TestServerStreamWriter.cs (3)

30return _channel.Reader.ReadAllAsync(); 35if (await _channel.Reader.WaitToReadAsync()) 37_channel.Reader.TryRead(out var message);

Utils\TestConsoleLogsService.cs (1)

28await foreach (var result in channel.Reader.ReadAllAsync(cancellationToken))

VersionChecking\VersionCheckServiceTests.cs (7)

34var interaction = await interactionService.Interactions.Reader.ReadAsync().DefaultTimeout(); 98Assert.False(interactionService.Interactions.Reader.TryRead(out var _)); 128var interaction = await interactionService.Interactions.Reader.ReadAsync().DefaultTimeout(); 171var interaction = await interactionService.Interactions.Reader.ReadAsync().DefaultTimeout(); 179Assert.False(interactionService.Interactions.Reader.TryRead(out var _)); 214Assert.False(interactionService.Interactions.Reader.TryRead(out var _)); 243Assert.False(interactionService.Interactions.Reader.TryRead(out var _));

UploadSample.cs (4)

45var invokeTask = connection.InvokeAsync<string>("UploadWord", channel.Reader); 65var result = await connection.InvokeAsync<string>("ScoreTracker", channel_one.Reader, channel_two.Reader); 95var outputs = await connection.StreamAsChannelAsync<string>("StreamEcho", channel.Reader);

Commands\Test\MTP\TestApplicationActionQueue.cs (1)

56await foreach (var nonParallelizedGroup in _channel.Reader.ReadAllAsync())

Aspire\AspireServiceFactory.cs (1)

155await foreach (var line in outputChannel.Reader.ReadAllAsync(cancellationToken))

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (4)

91internal ChannelReader<KeyValuePair<Http3SettingType, long>> ServerReceivedSettingsReader => _serverReceivedSettings.Reader; 110var reader = MultiplexedConnectionContext.ToClientAcceptQueue.Reader; 1058while (await ToServerAcceptQueue.Reader.WaitToReadAsync(cancellationToken)) 1060while (ToServerAcceptQueue.Reader.TryRead(out var connection))

TestTransport\InMemoryTransportFactory.cs (2)

26if (await _acceptQueue.Reader.WaitToReadAsync(cancellationToken)) 28while (_acceptQueue.Reader.TryRead(out var item))

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

src\Shared\EventSource.Testing\TestCounterListener.cs (1)

41var values = _counters[counterName].Reader.ReadAllAsync(cancellationToken).GetAsyncEnumerator(cancellationToken);

TestWebSocketConnectionFeature.cs (2)

43var clientSocket = new WebSocketChannel(serverToClient.Reader, clientToServer.Writer, _sync); 44var serverSocket = new WebSocketChannel(clientToServer.Reader, serverToClient.Writer, _sync);

Internal\Http2\Http2FrameWriter.cs (2)

178while (await _channel.Reader.WaitToReadAsync()) 182while (_channel.Reader.TryRead(out var producer) && !producer.CompletedResponse)

Internal\WebTransport\WebTransportSession.cs (1)

175return await _pendingStreams.Reader.ReadAsync(cancellationToken);

src\Servers\Kestrel\shared\test\Http3\Http3InMemory.cs (4)

91internal ChannelReader<KeyValuePair<Http3SettingType, long>> ServerReceivedSettingsReader => _serverReceivedSettings.Reader; 110var reader = MultiplexedConnectionContext.ToClientAcceptQueue.Reader; 1058while (await ToServerAcceptQueue.Reader.WaitToReadAsync(cancellationToken)) 1060while (ToServerAcceptQueue.Reader.TryRead(out var connection))

Internal\NamedPipeConnectionListener.cs (2)

149while (await _acceptedQueue.Reader.WaitToReadAsync(cancellationToken)) 151if (_acceptedQueue.Reader.TryRead(out var connection))

HubConnection.cs (1)

1614connectionState.InvocationMessageReceiveTask = StartProcessingInvocationMessages(invocationMessageChannel.Reader);

HubConnectionExtensions.StreamAsChannelAsync.cs (1)

282return outputChannel.Reader;

Internal\InvocationRequest.cs (1)

88public ChannelReader<object?> Result => _channel.Reader;

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

139while (await _waitForAck.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) 141if (_waitForAck.Reader.TryRead(out var count) && count < _bufferLimit) 150_waitForAck.Reader.TryRead(out _);

HubConnectionTests.cs (3)

800var channel = await connection.StreamAsChannelAsync<string>("StreamEcho", channelWriter.Reader).DefaultTimeout(); 2957while (await _taskQueue.Reader.WaitToReadAsync()) 2960while (_taskQueue.Reader.TryRead(out var tuple))

HubConnectionTests.Tracing.cs (8)

83clientActivity1 = await clientChannel.Reader.ReadAsync().DefaultTimeout(); 105clientActivity2 = await clientChannel.Reader.ReadAsync().DefaultTimeout(); 138var serverActivities = await serverChannel.Reader.ReadAtLeastAsync(minimumCount: 4).DefaultTimeout(); 310var serverActivities = await serverChannel.Reader.ReadAtLeastAsync(minimumCount: 3).DefaultTimeout(); 439var serverActivities = await serverChannel.Reader.ReadAtLeastAsync(minimumCount: 3).DefaultTimeout(); 536var serverActivities = await serverChannel.Reader.ReadAtLeastAsync(minimumCount: 3).DefaultTimeout(); 631var serverActivities = await serverChannel.Reader.ReadAtLeastAsync(minimumCount: 3).DefaultTimeout(); 730var serverActivities = await serverChannel.Reader.ReadAtLeastAsync(minimumCount: 3).DefaultTimeout();

Hubs.cs (3)

240return channel.Reader; 271return output.Reader; 295return output.Reader;

HubConnectionTests.cs (8)

439var invokeTask = hubConnection.InvokeAsync<int>("SomeMethod", channel.Reader); 479var sendTask = hubConnection.SendAsync("SomeMethod", channel.Reader); 510var invokeTask = hubConnection.InvokeAsync<SampleObject>("UploadMethod", channel.Reader); 555var invokeTask = hubConnection.InvokeAsync<object>("UploadMethod", channel.Reader, cts.Token); 587var invokeTask = hubConnection.InvokeAsync<object>("UploadMethod", channel.Reader, cts.Token); 612var invokeTask = hubConnection.InvokeAsync<object>("UploadMethod", channel.Reader); 646var invokeTask = hubConnection.InvokeAsync<long>("UploadMethod", channel.Reader); 679var invokeTask = hubConnection.InvokeAsync<int>("SumInts", channel.Reader);

HubServerProxyGeneratorTests.cs (10)

176var asyncEnumerable = channelForEnumerable.Reader.ReadAllAsync(); 186.Returns(Task.FromResult(channel.Reader)); 193.Returns(Task.FromResult(channel.Reader)); 217var channelReader = channel.Reader; 219var asyncEnumerable = channelForEnumerable.Reader.ReadAllAsync(); 259var retChannelReader = retChannel.Reader; 261var argEnumerable = argChannelForEnumerable.Reader.ReadAllAsync(); 263var retEnumerable = retChannelForEnumerable.Reader.ReadAllAsync(); 297_ = await myHub.StreamBidirectionalViaChannel(argChannel.Reader); 298_ = await myHub.StreamBidirectionalViaChannelWithToken(argChannel.Reader, token);

Internal\ChannelBasedSemaphore.cs (2)

26return _channel.Reader.TryRead(out _); 32return _channel.Reader.ReadAsync(cancellationToken);

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

139while (await _waitForAck.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) 141if (_waitForAck.Reader.TryRead(out var count) && count < _bufferLimit) 150_waitForAck.Reader.TryRead(out _);

StreamTracker.cs (2)

124return _channel.Reader.ReadAllAsync(); 128return _channel.Reader;

DefaultHubDispatcherBenchmark.cs (1)

171return channel.Reader;

HubConnectionHandlerTests.Activity.cs (20)

HubConnectionHandlerTests.cs (1)

4752provider.AddSingleton(channel.Reader);

HubConnectionHandlerTestUtils\Hubs.cs (14)

296return channel.Reader; 715return channel.Reader; 773return Channel.CreateUnbounded<string>().Reader; 780return channel.Reader; 787return channel.Reader; 794return channel.Reader; 829return output.Reader; 1030return Channel.CreateUnbounded<string>().Reader; 1045return channel.Reader; 1060return channel.Reader; 1075return channel.Reader; 1090return channel.Reader; 1105return channel.Reader; 1146return channel.Reader;

NativeAotTests.cs (4)

80var echoResponseReader = await connection.StreamAsChannelAsync<string>(nameof(AsyncMethodHub.StreamEcho), channel.Reader); 118stringResult = await connection.InvokeAsync<string>(nameof(AsyncMethodHub.ChannelShortParameter), channelShorts.Reader); 261return output.Reader; 295return output.Reader;

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

ProducerConsumer.cs (2)

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

ServiceEndpointResolverTests.cs (1)

275var next = await channel.Reader.ReadAsync(CancellationToken.None);

Transforms\RowShufflingTransformer.cs (3)

571while (await _toProduceChannel.Reader.WaitToReadAsync().ConfigureAwait(false)) 574if (!_toProduceChannel.Reader.TryRead(out requested)) 637ValueTask<int> readTask = _toConsumeChannel.Reader.ReadAsync();

AsyncSweeper.cs (1)

282return await _paramChannel.Reader.ReadAsync(_cts.Token);

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);

TestHub.cs (3)

67return channel.Reader; 80return channel.Reader; 102return channel.Reader;

Hubs\Streaming.cs (1)

45return channel.Reader;

Hubs\UploadHub.cs (1)

81return output.Reader;

ObservableExtensions.cs (2)

35channel.Reader.Completion.ContinueWith(task => 41return channel.Reader;

ProducerConsumer.cs (1)

30await foreach (var item in _channel.Reader.ReadAllAsync())

Program.cs (1)

273await foreach (var message in channel.Reader.ReadAllAsync(cancellationToken))

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

1211while (await _writeChannel.Reader.WaitToReadAsync().ConfigureAwait(false)) 1213while (_writeChannel.Reader.TryRead(out WriteQueueEntry? writeEntry))

System\Net\Quic\QuicConnection.cs (2)

575return await _acceptQueue.Reader.ReadAsync(cancellationToken).ConfigureAwait(false); 864while (_acceptQueue.Reader.TryRead(out QuicStream? stream))

System\Net\Quic\QuicListener.cs (2)

185object item = await _acceptQueue.Reader.ReadAsync(cancellationToken).ConfigureAwait(false); 433while (_acceptQueue.Reader.TryRead(out object? item))

System\Threading\Channels\Channel_2.cs (1)

22public static implicit operator ChannelReader<TRead>(Channel<TWrite, TRead> channel) => channel.Reader;

System\Threading\Channels\RendezvousChannel.cs (1)

487$"{((RendezvousChannelReader)Reader).DebuggerDisplay}, {((RendezvousChannelWriter)Writer).DebuggerDisplay}";

Program.cs (2)

124while (await _channel.Reader.WaitToReadAsync(CancellationToken.None).ConfigureAwait(false)) 126while (_channel.Reader.TryRead(out var item))

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

279return channel.Reader.ReadAllAsync(cancellationToken); 351return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

63return channel.Reader.ReadAllAsync(cancellationToken);