public async Task StreamingPull()
{
// Snippet: StreamingPull(CallSettings,BidirectionalStreamingSettings)
// Create client
SubscriberClient subscriberClient = SubscriberClient.Create();
// Initialize streaming call, retrieving the stream object
SubscriberClient.StreamingPullStream duplexStream = subscriberClient.StreamingPull();
// Sending requests and retrieving responses can be arbitrarily interleaved.
// Exact sequence will depend on client/server behavior.
// Create task to do something with responses from server
Task.Run(async() =>
{
IAsyncEnumerator <StreamingPullResponse> responseStream = duplexStream.ResponseStream;
while (await responseStream.MoveNext())
{
StreamingPullResponse response = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
});
// Send requests to the server
bool done = false;
while (!done)
{
// Initialize a request
StreamingPullRequest request = new StreamingPullRequest
{
SubscriptionAsSubscriptionName = new SubscriptionName("[PROJECT]", "[SUBSCRIPTION]"),
StreamAckDeadlineSeconds = 0,
};
// Stream a request to the server
await duplexStream.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await duplexStream.WriteCompleteAsync();
// End snippet
}
public async Task StreamingPull()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Snippet: StreamingPull(*, *)
PublisherClient publisher = PublisherClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
SubscriberClient subscriber = SubscriberClient.Create();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriber.CreateSubscription(subscriptionName, topicName, null, 60);
// If we don't see all the messages we expect in 10 seconds, we'll cancel the call.
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
CallSettings callSettings = CallSettings.FromCancellationToken(cancellationTokenSource.Token);
SubscriberClient.StreamingPullStream stream = subscriber.StreamingPull(callSettings);
// The first request must include the subscription name and the stream ack deadline
await stream.WriteAsync(new StreamingPullRequest { SubscriptionAsSubscriptionName = subscriptionName, StreamAckDeadlineSeconds = 20 });
Task pullingTask = Task.Run(async() =>
{
int messagesSeen = 0;
IAsyncEnumerator <StreamingPullResponse> responseStream = stream.ResponseStream;
// Handle responses as we see them.
while (await responseStream.MoveNext())
{
StreamingPullResponse response = responseStream.Current;
Console.WriteLine("Received streaming response");
foreach (ReceivedMessage message in response.ReceivedMessages)
{
// Messages can contain any data. We'll assume that we know this
// topic publishes UTF-8-encoded text.
Console.WriteLine($"Message text: {message.Message.Data.ToStringUtf8()}");
}
// Acknowledge the messages we've just seen
await stream.WriteAsync(new StreamingPullRequest {
AckIds = { response.ReceivedMessages.Select(rm => rm.AckId) }
});
// If we've seen all the messages we expect, we can complete the streaming call,
// and our next MoveNext call will return false.
messagesSeen += response.ReceivedMessages.Count;
if (messagesSeen == 3)
{
await stream.WriteCompleteAsync();
}
}
});
publisher.Publish(topicName, new[] { new PubsubMessage {
Data = ByteString.CopyFromUtf8("Message 1")
} });
publisher.Publish(topicName, new[] { new PubsubMessage {
Data = ByteString.CopyFromUtf8("Message 2")
} });
publisher.Publish(topicName, new[] { new PubsubMessage {
Data = ByteString.CopyFromUtf8("Message 3")
} });
await pullingTask;
// End snippet
}
