/// <summary>Snippet for SampleRowKeys</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task SampleRowKeysRequestObject()
{
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
SampleRowKeysRequest request = new SampleRowKeysRequest
{
TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
AppProfileId = "",
};
// Make the request, returning a streaming response
BigtableClient.SampleRowKeysStream response = bigtableClient.SampleRowKeys(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <SampleRowKeysResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
SampleRowKeysResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for SearchStream</summary>
public async Task SearchStreamRequestObject()
{
// Snippet: SearchStream(SearchGoogleAdsStreamRequest, CallSettings)
// Create client
GoogleAdsServiceClient googleAdsServiceClient = GoogleAdsServiceClient.Create();
// Initialize request argument(s)
SearchGoogleAdsStreamRequest request = new SearchGoogleAdsStreamRequest
{
CustomerId = "",
Query = "",
SummaryRowSetting = SummaryRowSettingEnum.Types.SummaryRowSetting.Unspecified,
};
// Make the request, returning a streaming response
GoogleAdsServiceClient.SearchStreamStream response = googleAdsServiceClient.SearchStream(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <SearchGoogleAdsStreamResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
SearchGoogleAdsStreamResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for BatchGetDocuments</summary>
public async Task BatchGetDocumentsRequestObject()
{
// Snippet: BatchGetDocuments(BatchGetDocumentsRequest, CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
BatchGetDocumentsRequest request = new BatchGetDocumentsRequest
{
Database = "",
Documents = { "", },
Mask = new DocumentMask(),
Transaction = ByteString.Empty,
};
// Make the request, returning a streaming response
FirestoreClient.BatchGetDocumentsStream response = firestoreClient.BatchGetDocuments(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <BatchGetDocumentsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
BatchGetDocumentsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for StreamingReadFeatureValues</summary>
public async Task StreamingReadFeatureValuesRequestObject()
{
// Snippet: StreamingReadFeatureValues(StreamingReadFeatureValuesRequest, CallSettings)
// Create client
FeaturestoreOnlineServingServiceClient featurestoreOnlineServingServiceClient = FeaturestoreOnlineServingServiceClient.Create();
// Initialize request argument(s)
StreamingReadFeatureValuesRequest request = new StreamingReadFeatureValuesRequest
{
EntityTypeAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
EntityIds = { "", },
FeatureSelector = new FeatureSelector(),
};
// Make the request, returning a streaming response
FeaturestoreOnlineServingServiceClient.StreamingReadFeatureValuesStream response = featurestoreOnlineServingServiceClient.StreamingReadFeatureValues(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadFeatureValuesResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadFeatureValuesResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for ReadRows</summary>
public async Task ReadRowsRequestObject()
{
// Snippet: ReadRows(ReadRowsRequest, CallSettings)
// Create client
BigQueryReadClient bigQueryReadClient = BigQueryReadClient.Create();
// Initialize request argument(s)
ReadRowsRequest request = new ReadRowsRequest
{
ReadStreamAsReadStreamName = ReadStreamName.FromProjectLocationSessionStream("[PROJECT]", "[LOCATION]", "[SESSION]", "[STREAM]"),
Offset = 0L,
};
// Make the request, returning a streaming response
BigQueryReadClient.ReadRowsStream response = bigQueryReadClient.ReadRows(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for ReadRows</summary>
public async Task ReadRowsRequestObject()
{
// Snippet: ReadRows(ReadRowsRequest, CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
ReadRowsRequest request = new ReadRowsRequest
{
TableNameAsTableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]"),
Rows = new RowSet(),
Filter = new RowFilter(),
RowsLimit = 0L,
AppProfileId = "",
};
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream response = bigtableClient.ReadRows(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for MutateRows</summary>
public async Task MutateRows1()
{
// Snippet: MutateRows(string, IEnumerable<MutateRowsRequest.Types.Entry>, CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
string tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
IEnumerable <MutateRowsRequest.Types.Entry> entries = new MutateRowsRequest.Types.Entry[]
{
new MutateRowsRequest.Types.Entry(),
};
// Make the request, returning a streaming response
BigtableClient.MutateRowsStream response = bigtableClient.MutateRows(tableName, entries);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <MutateRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
MutateRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for MethodServerStreamingResources</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task MethodServerStreamingResourcesRequestObject()
{
// Create client
SnippetsClient snippetsClient = SnippetsClient.Create();
// Initialize request argument(s)
ResourceSignatureRequest request = new ResourceSignatureRequest
{
FirstNameAsSimpleResourceName = SimpleResourceName.FromItem("[ITEM_ID]"),
SecondNameAsSimpleResourceName = SimpleResourceName.FromItem("[ITEM_ID]"),
ThirdNameAsSimpleResourceName = SimpleResourceName.FromItem("[ITEM_ID]"),
};
// Make the request, returning a streaming response
SnippetsClient.MethodServerStreamingResourcesStream response = snippetsClient.MethodServerStreamingResources(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <Response> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
Response responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for MethodServerStreaming</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task MethodServerStreamingRequestObject()
{
// Create client
SnippetsClient snippetsClient = SnippetsClient.Create();
// Initialize request argument(s)
SignatureRequest request = new SignatureRequest
{
AString = "",
AnInt = 0,
ABool = false,
MapIntString = { { 0, "" }, },
};
// Make the request, returning a streaming response
SnippetsClient.MethodServerStreamingStream response = snippetsClient.MethodServerStreaming(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <Response> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
Response responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for MutateRows</summary>
public async Task MutateRows2ResourceNames()
{
// Snippet: MutateRows(TableName, IEnumerable<MutateRowsRequest.Types.Entry>, string, CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
TableName tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
IEnumerable <MutateRowsRequest.Types.Entry> entries = new MutateRowsRequest.Types.Entry[]
{
new MutateRowsRequest.Types.Entry(),
};
string appProfileId = "";
// Make the request, returning a streaming response
BigtableClient.MutateRowsStream response = bigtableClient.MutateRows(tableName, entries, appProfileId);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <MutateRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
MutateRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for RunQuery</summary>
public async Task RunQueryRequestObject()
{
// Snippet: RunQuery(RunQueryRequest, CallSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize request argument(s)
RunQueryRequest request = new RunQueryRequest
{
Parent = "",
StructuredQuery = new StructuredQuery(),
Transaction = ByteString.Empty,
};
// Make the request, returning a streaming response
FirestoreClient.RunQueryStream response = firestoreClient.RunQuery(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <RunQueryResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
RunQueryResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for ReadRows</summary>
public async Task ReadRowsRequestObject()
{
// Snippet: ReadRows(ReadRowsRequest, CallSettings)
// Create client
BigQueryStorageClient bigQueryStorageClient = BigQueryStorageClient.Create();
// Initialize request argument(s)
ReadRowsRequest request = new ReadRowsRequest
{
ReadPosition = new StreamPosition(),
};
// Make the request, returning a streaming response
BigQueryStorageClient.ReadRowsStream response = bigQueryStorageClient.ReadRows(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for GenerateMediationReport</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task GenerateMediationReportRequestObject()
{
// Create client
AdMobApiClient adMobApiClient = AdMobApiClient.Create();
// Initialize request argument(s)
GenerateMediationReportRequest request = new GenerateMediationReportRequest
{
Parent = "",
ReportSpec = new MediationReportSpec(),
};
// Make the request, returning a streaming response
AdMobApiClient.GenerateMediationReportStream response = adMobApiClient.GenerateMediationReport(request);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <GenerateMediationReportResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
GenerateMediationReportResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for Egress</summary>
public async Task Egress()
{
// Snippet: Egress(CallSettings, BidirectionalStreamingSettings)
// Create client
TetherClient tetherClient = TetherClient.Create();
// Initialize streaming call, retrieving the stream object
TetherClient.EgressStream response = tetherClient.Egress();
// 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 responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <EgressRequest> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
EgressRequest responseItem = 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
EgressResponse request = new EgressResponse
{
Id = "",
HttpResponse = new HttpResponse(),
Status = new Status(),
Project = "",
TraceId = "",
Endpoint = TetherEndpoint.Unspecified,
Name = "",
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
/// <summary>Snippet for StreamingDetectIntent</summary>
public async Task StreamingDetectIntent()
{
// Snippet: StreamingDetectIntent(CallSettings, BidirectionalStreamingSettings)
// Create client
SessionsClient sessionsClient = SessionsClient.Create();
// Initialize streaming call, retrieving the stream object
SessionsClient.StreamingDetectIntentStream response = sessionsClient.StreamingDetectIntent();
// 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 responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <StreamingDetectIntentResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
StreamingDetectIntentResponse responseItem = 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
StreamingDetectIntentRequest request = new StreamingDetectIntentRequest
{
Session = "",
QueryParams = new QueryParameters(),
QueryInput = new QueryInput(),
OutputAudioConfig = new OutputAudioConfig(),
InputAudio = ByteString.Empty,
OutputAudioConfigMask = new FieldMask(),
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
/// <summary>Snippet for Write</summary>
public async Task Write()
{
// Snippet: Write(CallSettings, BidirectionalStreamingSettings)
// Create client
FirestoreClient firestoreClient = FirestoreClient.Create();
// Initialize streaming call, retrieving the stream object
FirestoreClient.WriteStream response = firestoreClient.Write();
// 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 responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <WriteResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
WriteResponse responseItem = 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
WriteRequest request = new WriteRequest
{
Database = "",
StreamId = "",
Writes = { new Write(), },
StreamToken = ByteString.Empty,
Labels = { { "", "" }, },
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
/// <summary>Snippet for AppendRows</summary>
public async Task AppendRows()
{
// Snippet: AppendRows(CallSettings, BidirectionalStreamingSettings)
// Create client
BigQueryWriteClient bigQueryWriteClient = BigQueryWriteClient.Create();
// Initialize streaming call, retrieving the stream object
BigQueryWriteClient.AppendRowsStream response = bigQueryWriteClient.AppendRows();
// 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 responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <AppendRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
AppendRowsResponse responseItem = 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
AppendRowsRequest request = new AppendRowsRequest
{
WriteStreamAsWriteStreamName = WriteStreamName.FromProjectDatasetTableStream("[PROJECT]", "[DATASET]", "[TABLE]", "[STREAM]"),
Offset = 0L,
ProtoRows = new AppendRowsRequest.Types.ProtoData(),
TraceId = "",
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
// End snippet
}
/// <summary>Snippet for MethodBidiStreaming</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task MethodBidiStreaming()
{
// Create client
SnippetsClient snippetsClient = SnippetsClient.Create();
// Initialize streaming call, retrieving the stream object
SnippetsClient.MethodBidiStreamingStream response = snippetsClient.MethodBidiStreaming();
// 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 responseHandlerTask = Task.Run(async() =>
{
// Note that C# 8 code can use await foreach
AsyncResponseStream <Response> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
Response responseItem = 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
SignatureRequest request = new SignatureRequest
{
AString = "",
AnInt = 0,
ABool = false,
MapIntString = { { 0, "" }, },
};
// Stream a request to the server
await response.WriteAsync(request);
// Set "done" to true when sending requests is complete
}
// Complete writing requests to the stream
await response.WriteCompleteAsync();
// Await the response handler
// This will complete once all server responses have been processed
await responseHandlerTask;
}
/// <summary>Snippet for MethodServerStreaming</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task MethodServerStreaming2()
{
// Create client
SnippetsClient snippetsClient = SnippetsClient.Create();
// Make the request, returning a streaming response
SnippetsClient.MethodServerStreamingStream response = snippetsClient.MethodServerStreaming();
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <Response> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
Response responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for ReadRows</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task ReadRows1()
{
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
string tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream response = bigtableClient.ReadRows(tableName);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for ReadRows</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task ReadRows2ResourceNames()
{
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
TableName tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
string appProfileId = "";
// Make the request, returning a streaming response
BigtableClient.ReadRowsStream response = bigtableClient.ReadRows(tableName, appProfileId);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for ReadRows</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task ReadRows()
{
// Create client
BigQueryReadClient bigQueryReadClient = BigQueryReadClient.Create();
// Initialize request argument(s)
string readStream = "projects/[PROJECT]/locations/[LOCATION]/sessions/[SESSION]/streams/[STREAM]";
long offset = 0L;
// Make the request, returning a streaming response
BigQueryReadClient.ReadRowsStream response = bigQueryReadClient.ReadRows(readStream, offset);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadRowsResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadRowsResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for SearchStream</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task SearchStream()
{
// Create client
GoogleAdsServiceClient googleAdsServiceClient = GoogleAdsServiceClient.Create();
// Initialize request argument(s)
string customerId = "";
string query = "";
// Make the request, returning a streaming response
GoogleAdsServiceClient.SearchStreamStream response = googleAdsServiceClient.SearchStream(customerId, query);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <SearchGoogleAdsStreamResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
SearchGoogleAdsStreamResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for SampleRowKeys</summary>
public async Task SampleRowKeys1ResourceNames()
{
// Snippet: SampleRowKeys(TableName, CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
TableName tableName = TableName.FromProjectInstanceTable("[PROJECT]", "[INSTANCE]", "[TABLE]");
// Make the request, returning a streaming response
BigtableClient.SampleRowKeysStream response = bigtableClient.SampleRowKeys(tableName);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <SampleRowKeysResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
SampleRowKeysResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for StreamingReadFeatureValues</summary>
public async Task StreamingReadFeatureValues()
{
// Snippet: StreamingReadFeatureValues(string, CallSettings)
// Create client
FeaturestoreOnlineServingServiceClient featurestoreOnlineServingServiceClient = FeaturestoreOnlineServingServiceClient.Create();
// Initialize request argument(s)
string entityType = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request, returning a streaming response
FeaturestoreOnlineServingServiceClient.StreamingReadFeatureValuesStream response = featurestoreOnlineServingServiceClient.StreamingReadFeatureValues(entityType);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <ReadFeatureValuesResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
ReadFeatureValuesResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
/// <summary>Snippet for MethodServerStreamingResources</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public async Task MethodServerStreamingResources()
{
// Create client
SnippetsClient snippetsClient = SnippetsClient.Create();
// Initialize request argument(s)
string firstName = "items/[ITEM_ID]";
string secondName = "items/[ITEM_ID]";
string thirdName = "items/[ITEM_ID]";
// Make the request, returning a streaming response
SnippetsClient.MethodServerStreamingResourcesStream response = snippetsClient.MethodServerStreamingResources(firstName, secondName, thirdName);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <Response> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
Response responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
}
/// <summary>Snippet for SampleRowKeys</summary>
public async Task SampleRowKeys2()
{
// Snippet: SampleRowKeys(string, string, CallSettings)
// Create client
BigtableClient bigtableClient = BigtableClient.Create();
// Initialize request argument(s)
string tableName = "projects/[PROJECT]/instances/[INSTANCE]/tables/[TABLE]";
string appProfileId = "";
// Make the request, returning a streaming response
BigtableClient.SampleRowKeysStream response = bigtableClient.SampleRowKeys(tableName, appProfileId);
// Read streaming responses from server until complete
// Note that C# 8 code can use await foreach
AsyncResponseStream <SampleRowKeysResponse> responseStream = response.GetResponseStream();
while (await responseStream.MoveNextAsync())
{
SampleRowKeysResponse responseItem = responseStream.Current;
// Do something with streamed response
}
// The response stream has completed
// End snippet
}
public async Task StreamingPull()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Snippet: StreamingPull(*, *)
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.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);
SubscriberServiceApiClient.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;
AsyncResponseStream <StreamingPullResponse> responseStream = stream.GetResponseStream();
// Handle responses as we see them.
while (await responseStream.MoveNextAsync())
{
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
}
