/// <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;
}
