/// <summary>Snippet for ListJobsAsync</summary> public async Task ListJobsAsync() { // Snippet: ListJobsAsync(TenantOrProjectNameOneof,string,string,int?,CallSettings) // Create client JobServiceClient jobServiceClient = await JobServiceClient.CreateAsync(); // Initialize request argument(s) TenantOrProjectNameOneof parent = TenantOrProjectNameOneof.From(new TenantName("[PROJECT]", "[TENANT]")); string filter = ""; // Make the request PagedAsyncEnumerable <ListJobsResponse, Job> response = jobServiceClient.ListJobsAsync(parent, filter); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Job item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListJobsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Job item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Job> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Job item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListSessionEntityTypesAsync</summary> public async Task ListSessionEntityTypesAsync() { // Snippet: ListSessionEntityTypesAsync(string, string, int?, CallSettings) // Create client SessionEntityTypesClient sessionEntityTypesClient = await SessionEntityTypesClient.CreateAsync(); // Initialize request argument(s) string parent = "projects/[PROJECT]/locations/[LOCATION]/agents/[AGENT]/sessions/[SESSION]"; // Make the request PagedAsyncEnumerable <ListSessionEntityTypesResponse, SessionEntityType> response = sessionEntityTypesClient.ListSessionEntityTypesAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((SessionEntityType item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListSessionEntityTypesResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (SessionEntityType item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <SessionEntityType> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (SessionEntityType item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListInstancesAsync</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 ListInstancesRequestObjectAsync() { // Create client InstancesClient instancesClient = await InstancesClient.CreateAsync(); // Initialize request argument(s) ListInstancesRequest request = new ListInstancesRequest { Parent = "", }; // Make the request PagedAsyncEnumerable <ListInstancesResponse, Instance> response = instancesClient.ListInstancesAsync(request); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Instance item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListInstancesResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Instance item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Instance> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Instance item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListIntentsAsync</summary> public async Task ListIntentsAsync2() { // Snippet: ListIntentsAsync(ProjectAgentName,string,string,int?,CallSettings) // Create client IntentsClient intentsClient = await IntentsClient.CreateAsync(); // Initialize request argument(s) ProjectAgentName parent = new ProjectAgentName("[PROJECT]"); string languageCode = ""; // Make the request PagedAsyncEnumerable <ListIntentsResponse, Intent> response = intentsClient.ListIntentsAsync(parent: parent, languageCode: languageCode); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Intent item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListIntentsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Intent item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Intent> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Intent item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
public async Task ListGroupStatsAsync() { // Snippet: ListGroupStatsAsync(ProjectName,QueryTimeRange,string,int?,CallSettings) // Create client ErrorStatsServiceClient errorStatsServiceClient = await ErrorStatsServiceClient.CreateAsync(); // Initialize request argument(s) ProjectName projectName = new ProjectName("[PROJECT]"); QueryTimeRange timeRange = new QueryTimeRange(); // Make the request PagedAsyncEnumerable <ListGroupStatsResponse, ErrorGroupStats> response = errorStatsServiceClient.ListGroupStatsAsync(projectName, timeRange); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((ErrorGroupStats item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListGroupStatsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (ErrorGroupStats item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <ErrorGroupStats> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (ErrorGroupStats item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for SearchAllResources</summary> public async Task SearchAllResourcesAsync() { // Snippet: SearchAllResourcesAsync(string, string, IEnumerable<string>, string, int?, CallSettings) // Create client AssetServiceClient assetServiceClient = await AssetServiceClient.CreateAsync(); // Initialize request argument(s) string scope = ""; string query = ""; IEnumerable<string> assetTypes = new string[] { "", }; // Make the request PagedAsyncEnumerable<SearchAllResourcesResponse, ResourceSearchResult> response = assetServiceClient.SearchAllResourcesAsync(scope, query, assetTypes); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((ResourceSearchResult item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((SearchAllResourcesResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (ResourceSearchResult item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page<ResourceSearchResult> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (ResourceSearchResult item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListCampaignDraftAsyncErrorsAsync</summary> public async Task ListCampaignDraftAsyncErrorsResourceNamesAsync() { // Snippet: ListCampaignDraftAsyncErrorsAsync(CampaignDraftName, string, int?, CallSettings) // Create client CampaignDraftServiceClient campaignDraftServiceClient = await CampaignDraftServiceClient.CreateAsync(); // Initialize request argument(s) CampaignDraftName resourceName = CampaignDraftName.FromCustomerBaseCampaignDraft("[CUSTOMER_ID]", "[BASE_CAMPAIGN_ID]", "[DRAFT_ID]"); // Make the request PagedAsyncEnumerable <ListCampaignDraftAsyncErrorsResponse, Status> response = campaignDraftServiceClient.ListCampaignDraftAsyncErrorsAsync(resourceName); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Status item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListCampaignDraftAsyncErrorsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Status item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Status> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Status item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListBatchJobResultsAsync</summary> public async Task ListBatchJobResultsResourceNamesAsync() { // Snippet: ListBatchJobResultsAsync(BatchJobName, string, int?, CallSettings) // Create client BatchJobServiceClient batchJobServiceClient = await BatchJobServiceClient.CreateAsync(); // Initialize request argument(s) BatchJobName resourceName = BatchJobName.FromCustomerBatchJob("[CUSTOMER]", "[BATCH_JOB]"); // Make the request PagedAsyncEnumerable <ListBatchJobResultsResponse, BatchJobResult> response = batchJobServiceClient.ListBatchJobResultsAsync(resourceName); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((BatchJobResult item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListBatchJobResultsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (BatchJobResult item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <BatchJobResult> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (BatchJobResult item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListGameServerConfigsAsync</summary> public async Task ListGameServerConfigsResourceNamesAsync() { // Snippet: ListGameServerConfigsAsync(GameServerDeploymentName, string, int?, CallSettings) // Create client GameServerConfigsServiceClient gameServerConfigsServiceClient = await GameServerConfigsServiceClient.CreateAsync(); // Initialize request argument(s) GameServerDeploymentName parent = GameServerDeploymentName.FromProjectLocationDeployment("[PROJECT]", "[LOCATION]", "[DEPLOYMENT]"); // Make the request PagedAsyncEnumerable <ListGameServerConfigsResponse, GameServerConfig> response = gameServerConfigsServiceClient.ListGameServerConfigsAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((GameServerConfig item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListGameServerConfigsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (GameServerConfig item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <GameServerConfig> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (GameServerConfig item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for SearchGoogleAdsFieldsAsync</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 SearchGoogleAdsFieldsRequestObjectAsync() { // Create client GoogleAdsFieldServiceClient googleAdsFieldServiceClient = await GoogleAdsFieldServiceClient.CreateAsync(); // Initialize request argument(s) SearchGoogleAdsFieldsRequest request = new SearchGoogleAdsFieldsRequest { Query = "", }; // Make the request PagedAsyncEnumerable <SearchGoogleAdsFieldsResponse, GoogleAdsField> response = googleAdsFieldServiceClient.SearchGoogleAdsFieldsAsync(request); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((GoogleAdsField item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((SearchGoogleAdsFieldsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (GoogleAdsField item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <GoogleAdsField> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (GoogleAdsField item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListAlertPolicies</summary> public async Task ListAlertPoliciesResourceNames4Async() { // Snippet: ListAlertPoliciesAsync(IResourceName, string, int?, CallSettings) // Create client AlertPolicyServiceClient alertPolicyServiceClient = await AlertPolicyServiceClient.CreateAsync(); // Initialize request argument(s) IResourceName name = new UnparsedResourceName("a/wildcard/resource"); // Make the request PagedAsyncEnumerable <ListAlertPoliciesResponse, AlertPolicy> response = alertPolicyServiceClient.ListAlertPoliciesAsync(name); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((AlertPolicy item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListAlertPoliciesResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (AlertPolicy item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <AlertPolicy> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (AlertPolicy item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for AggregatedListAsync</summary> public async Task AggregatedListAsync() { // Snippet: AggregatedListAsync(string, string, int?, CallSettings) // Create client VpnTunnelsClient vpnTunnelsClient = await VpnTunnelsClient.CreateAsync(); // Initialize request argument(s) string project = ""; // Make the request PagedAsyncEnumerable <VpnTunnelAggregatedList, KeyValuePair <string, VpnTunnelsScopedList> > response = vpnTunnelsClient.AggregatedListAsync(project); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((KeyValuePair <string, VpnTunnelsScopedList> item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((VpnTunnelAggregatedList page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (KeyValuePair <string, VpnTunnelsScopedList> item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <KeyValuePair <string, VpnTunnelsScopedList> > singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (KeyValuePair <string, VpnTunnelsScopedList> item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListParticipantsAsync</summary> public async Task ListParticipantsResourceNamesAsync() { // Snippet: ListParticipantsAsync(ConversationName, string, int?, CallSettings) // Create client ParticipantsClient participantsClient = await ParticipantsClient.CreateAsync(); // Initialize request argument(s) ConversationName parent = ConversationName.FromProjectConversation("[PROJECT]", "[CONVERSATION]"); // Make the request PagedAsyncEnumerable <ListParticipantsResponse, Participant> response = participantsClient.ListParticipantsAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Participant item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListParticipantsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Participant item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Participant> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Participant item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListRows</summary> public async Task ListRowsAsync() { // Snippet: ListRowsAsync(string, string, int?, CallSettings) // Create client TablesServiceClient tablesServiceClient = await TablesServiceClient.CreateAsync(); // Initialize request argument(s) string parent = ""; // Make the request PagedAsyncEnumerable <ListRowsResponse, Row> response = tablesServiceClient.ListRowsAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Row item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListRowsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Row item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Row> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Row item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
public async Task ListTopicSubscriptionsAsync() { // Snippet: ListTopicSubscriptionsAsync(TopicName,string,int?,CallSettings) // Create client PublisherClient publisherClient = await PublisherClient.CreateAsync(); // Initialize request argument(s) TopicName topic = new TopicName("[PROJECT]", "[TOPIC]"); // Make the request PagedAsyncEnumerable <ListTopicSubscriptionsResponse, SubscriptionName> response = publisherClient.ListTopicSubscriptionsAsync(topic); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((SubscriptionName item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListTopicSubscriptionsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (SubscriptionName item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <SubscriptionName> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (SubscriptionName item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListModelEvaluationsAsync</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 ListModelEvaluationsResourceNamesAsync() { // Create client AutoMlClient autoMlClient = await AutoMlClient.CreateAsync(); // Initialize request argument(s) ModelName parent = ModelName.FromProjectLocationModel("[PROJECT]", "[LOCATION]", "[MODEL]"); string filter = ""; // Make the request PagedAsyncEnumerable <ListModelEvaluationsResponse, ModelEvaluation> response = autoMlClient.ListModelEvaluationsAsync(parent, filter); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((ModelEvaluation item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListModelEvaluationsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (ModelEvaluation item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <ModelEvaluation> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (ModelEvaluation item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListSnapshotsAsync</summary> public async Task ListSnapshotsAsync() { // Snippet: ListSnapshotsAsync(ClusterName,string,int?,CallSettings) // Create client BigtableTableAdminClient bigtableTableAdminClient = await BigtableTableAdminClient.CreateAsync(); // Initialize request argument(s) ClusterName parent = new ClusterName("[PROJECT]", "[INSTANCE]", "[CLUSTER]"); // Make the request PagedAsyncEnumerable <ListSnapshotsResponse, Snapshot> response = bigtableTableAdminClient.ListSnapshotsAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Snapshot item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListSnapshotsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Snapshot item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Snapshot> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Snapshot item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ResourcedMethodAsync</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 ResourcedMethod2Async() { // Create client PaginatedClient paginatedClient = await PaginatedClient.CreateAsync(); // Initialize request argument(s) string name = "items/[ITEM_ID]"; string extraString = ""; // Make the request PagedAsyncEnumerable <ResourceResponse, string> response = paginatedClient.ResourcedMethodAsync(name, extraString: extraString); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((string item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ResourceResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (string item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <string> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (string item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for SearchCatalogAsync</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 SearchCatalogAsync() { // Create client DataCatalogClient dataCatalogClient = await DataCatalogClient.CreateAsync(); // Initialize request argument(s) SearchCatalogRequest.Types.Scope scope = new SearchCatalogRequest.Types.Scope(); string query = ""; // Make the request PagedAsyncEnumerable <SearchCatalogResponse, SearchCatalogResult> response = dataCatalogClient.SearchCatalogAsync(scope, query); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((SearchCatalogResult item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((SearchCatalogResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (SearchCatalogResult item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <SearchCatalogResult> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (SearchCatalogResult item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListServiceRolloutsAsync</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 ListServiceRolloutsAsync() { // Create client ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync(); // Initialize request argument(s) string serviceName = ""; string filter = ""; // Make the request PagedAsyncEnumerable <ListServiceRolloutsResponse, Rollout> response = serviceManagerClient.ListServiceRolloutsAsync(serviceName, filter); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Rollout item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListServiceRolloutsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Rollout item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Rollout> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Rollout item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListGroupMembersAsync</summary> public async Task ListGroupMembersAsync() { // Snippet: ListGroupMembersAsync(GroupName,string,int?,CallSettings) // Create client GroupServiceClient groupServiceClient = await GroupServiceClient.CreateAsync(); // Initialize request argument(s) GroupName name = new GroupName("[PROJECT]", "[GROUP]"); // Make the request PagedAsyncEnumerable <ListGroupMembersResponse, MonitoredResource> response = groupServiceClient.ListGroupMembersAsync(name); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((MonitoredResource item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListGroupMembersResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (MonitoredResource item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <MonitoredResource> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (MonitoredResource item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for SignatureMethodAsync</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 SignatureMethod1Async() { // Create client PaginatedClient paginatedClient = await PaginatedClient.CreateAsync(); // Initialize request argument(s) string aString = ""; int aNumber = 0; // Make the request PagedAsyncEnumerable <Response, Response.Types.NestedResult> response = paginatedClient.SignatureMethodAsync(aString, aNumber); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Response.Types.NestedResult item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((Response page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Response.Types.NestedResult item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Response.Types.NestedResult> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Response.Types.NestedResult item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListSessionsAsync</summary> public async Task ListSessionsAsync() { // Snippet: ListSessionsAsync(string,string,int?,CallSettings) // Create client SpannerClient spannerClient = await SpannerClient.CreateAsync(); // Initialize request argument(s) string formattedDatabase = new Google.Cloud.Spanner.Common.V1.DatabaseName("[PROJECT]", "[INSTANCE]", "[DATABASE]").ToString(); // Make the request PagedAsyncEnumerable <ListSessionsResponse, Session> response = spannerClient.ListSessionsAsync(formattedDatabase); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Session item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListSessionsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Session item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Session> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Session item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListCollectionIdsAsync</summary> public async Task ListCollectionIdsAsync() { // Snippet: ListCollectionIdsAsync(string,string,int?,CallSettings) // Create client FirestoreClient firestoreClient = await FirestoreClient.CreateAsync(); // Initialize request argument(s) string formattedParent = new AnyPathName("[PROJECT]", "[DATABASE]", "[DOCUMENT]", "[ANY_PATH]").ToString(); // Make the request PagedAsyncEnumerable <ListCollectionIdsResponse, string> response = firestoreClient.ListCollectionIdsAsync(formattedParent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((string item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListCollectionIdsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (string item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <string> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (string item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for ListMonitoredResourceDescriptorsAsync</summary> public async Task ListMonitoredResourceDescriptorsAsync_RequestObject() { // Snippet: ListMonitoredResourceDescriptorsAsync(ListMonitoredResourceDescriptorsRequest,CallSettings) // Create client LoggingServiceV2Client loggingServiceV2Client = await LoggingServiceV2Client.CreateAsync(); // Initialize request argument(s) ListMonitoredResourceDescriptorsRequest request = new ListMonitoredResourceDescriptorsRequest(); // Make the request PagedAsyncEnumerable <ListMonitoredResourceDescriptorsResponse, MonitoredResourceDescriptor> response = loggingServiceV2Client.ListMonitoredResourceDescriptorsAsync(request); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((MonitoredResourceDescriptor item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListMonitoredResourceDescriptorsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (MonitoredResourceDescriptor item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <MonitoredResourceDescriptor> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (MonitoredResourceDescriptor item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
/// <summary>Snippet for SearchAssignmentsAsync</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 SearchAssignmentsResourceNamesAsync() { // Create client ReservationServiceClient reservationServiceClient = await ReservationServiceClient.CreateAsync(); // Initialize request argument(s) LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"); string query = ""; // Make the request PagedAsyncEnumerable <SearchAssignmentsResponse, Assignment> response = reservationServiceClient.SearchAssignmentsAsync(parent, query); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Assignment item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((SearchAssignmentsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Assignment item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Assignment> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Assignment item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListTagsAsync</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 ListTagsAsync() { // Create client DataCatalogClient dataCatalogClient = await DataCatalogClient.CreateAsync(); // Initialize request argument(s) string parent = "projects/[PROJECT]/locations/[LOCATION]/entryGroups/[ENTRY_GROUP]/entries/[ENTRY]"; // Make the request PagedAsyncEnumerable <ListTagsResponse, Tag> response = dataCatalogClient.ListTagsAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Tag item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListTagsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Tag item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Tag> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Tag item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListUserLinksAsync</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 ListUserLinksResourceNames2Async() { // Create client AnalyticsAdminServiceClient analyticsAdminServiceClient = await AnalyticsAdminServiceClient.CreateAsync(); // Initialize request argument(s) PropertyName parent = PropertyName.FromProperty("[PROPERTY]"); // Make the request PagedAsyncEnumerable <ListUserLinksResponse, UserLink> response = analyticsAdminServiceClient.ListUserLinksAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((UserLink item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListUserLinksResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (UserLink item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <UserLink> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (UserLink item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListTransferRunsAsync</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 ListTransferRunsResourceNamesAsync() { // Create client DataTransferServiceClient dataTransferServiceClient = await DataTransferServiceClient.CreateAsync(); // Initialize request argument(s) TransferConfigName parent = TransferConfigName.FromProjectTransferConfig("[PROJECT]", "[TRANSFER_CONFIG]"); // Make the request PagedAsyncEnumerable <ListTransferRunsResponse, TransferRun> response = dataTransferServiceClient.ListTransferRunsAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((TransferRun item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListTransferRunsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (TransferRun item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <TransferRun> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (TransferRun item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }
/// <summary>Snippet for ListAppProfilesAsync</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 ListAppProfilesAsync() { // Create client BigtableInstanceAdminClient bigtableInstanceAdminClient = await BigtableInstanceAdminClient.CreateAsync(); // Initialize request argument(s) string parent = "projects/[PROJECT]/instances/[INSTANCE]"; // Make the request PagedAsyncEnumerable <ListAppProfilesResponse, AppProfile> response = bigtableInstanceAdminClient.ListAppProfilesAsync(parent); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((AppProfile item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListAppProfilesResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (AppProfile item in page) { // Do something with each item Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <AppProfile> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (AppProfile item in singlePage) { // Do something with each item Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; }