Reader

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

54Reader = new BoundedChannelReader(this);

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

47Reader = new UnboundedChannelReader(this);

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

36Reader = new UnboundedChannelReader(this);

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

41Reader = new UnboundedPrioritizedChannelReader(this);

ActivityNotifier.cs (1)

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

MetricsChannel.cs (1)

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

src\Shared\ChannelExtensions.cs (2)

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

Shared\TestDashboardClient.cs (2)

52await foreach (var item in channel.Reader.ReadAllAsync(cancellationToken)) 71await 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();

ResourceOutgoingPeerResolverTests.cs (4)

134Assert.False(resultChannel.Reader.TryRead(out readValue)); 142readValue = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 149readValue = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 156await foreach (var item in sourceChannel.Reader.ReadAllAsync(cancellationToken))

TelemetryRepositoryTests\LogTests.cs (2)

749var read1 = await resultChannel.Reader.ReadAsync().DefaultTimeout(); 770var read2 = await resultChannel.Reader.ReadAsync().DefaultTimeout();

ApplicationModel\ResourceLoggerService.cs (2)

191await foreach (var item in channel.Reader.ReadAllAsync().ConfigureAwait(false)) 237await foreach (var entry in channel.Reader.ReadAllAsync(cancellationToken).ConfigureAwait(false))

ApplicationModel\ResourceNotificationService.cs (1)

322await 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))

Dashboard\DashboardLifecycleHookTests.cs (1)

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

Dcp\ApplicationExecutorTests.cs (1)

614await foreach (var item in logStreamPipesChannel.Reader.ReadAllAsync())

Dcp\TestKubernetesService.cs (1)

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

Health\ResourceHealthCheckServiceTests.cs (3)

161var firstCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 164var secondCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).DefaultTimeout(); 167var thirdCheck = await channel.Reader.ReadAsync(abortTokenSource.Token).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);

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);

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

92internal ChannelReader<KeyValuePair<Http3SettingType, long>> ServerReceivedSettingsReader => _serverReceivedSettings.Reader; 111var reader = MultiplexedConnectionContext.ToClientAcceptQueue.Reader; 1055while (await ToServerAcceptQueue.Reader.WaitToReadAsync(cancellationToken)) 1057while (ToServerAcceptQueue.Reader.TryRead(out var connection))

TestTransport\InMemoryTransportFactory.cs (2)

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

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

35return _counters[counterName].Reader.ReadAllAsync(cancellationToken);

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

35return _counters[counterName].Reader.ReadAllAsync(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)

92internal ChannelReader<KeyValuePair<Http3SettingType, long>> ServerReceivedSettingsReader => _serverReceivedSettings.Reader; 111var reader = MultiplexedConnectionContext.ToClientAcceptQueue.Reader; 1055while (await ToServerAcceptQueue.Reader.WaitToReadAsync(cancellationToken)) 1057while (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)

1604connectionState.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)

138while (await _waitForAck.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) 140if (_waitForAck.Reader.TryRead(out var count) && count < _bufferLimit) 149_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)

138while (await _waitForAck.Reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false)) 140if (_waitForAck.Reader.TryRead(out var count) && count < _bufferLimit) 149_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)

4734provider.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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\IAsyncEnumerableExtensions.cs (1)

72return channel.Reader.ReadAllAsync(cancellationToken);

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

308return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

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

72return channel.Reader.ReadAllAsync(cancellationToken);

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

308return await consumeItems(channel.Reader, args, cancellationToken).ConfigureAwait(false);

ChatCompletion\AnonymousDelegatingChatClient.cs (1)

158return updates.Reader.ReadAllAsync(cancellationToken);

ServiceEndpointResolverTests.cs (1)

273var 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);

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)

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

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

1197while (await _writeChannel.Reader.WaitToReadAsync().ConfigureAwait(false)) 1199while (_writeChannel.Reader.TryRead(out WriteQueueEntry? writeEntry))

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

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

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

183object item = await _acceptQueue.Reader.ReadAsync(cancellationToken).ConfigureAwait(false); 434while (_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;

Program.cs (2)

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