Google Cloud Memorystore for Redis (cluster management) v1 API - Class CloudRedisClusterClient (1.1.0)

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.CreateCluster(parent, cluster, clusterId);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = cloudRedisClusterClient.PollOnceCreateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ClusterId = "",
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.CreateCluster(request);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = cloudRedisClusterClient.PollOnceCreateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.CreateCluster(parent, cluster, clusterId);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = cloudRedisClusterClient.PollOnceCreateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ClusterId = "",
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ClusterId = "",
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceCreateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
DeleteClusterRequest request = new DeleteClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteCluster(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteClusterRequest request = new DeleteClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteClusterRequest request = new DeleteClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Cluster response = cloudRedisClusterClient.GetCluster(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
};
// Make the request
Cluster response = cloudRedisClusterClient.GetCluster(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Cluster response = cloudRedisClusterClient.GetCluster(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Cluster response = await cloudRedisClusterClient.GetClusterAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Cluster response = await cloudRedisClusterClient.GetClusterAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
};
// Make the request
Cluster response = await cloudRedisClusterClient.GetClusterAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
GetClusterRequest request = new GetClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
};
// Make the request
Cluster response = await cloudRedisClusterClient.GetClusterAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Cluster response = await cloudRedisClusterClient.GetClusterAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Cluster response = await cloudRedisClusterClient.GetClusterAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListClustersResponse, Cluster> response = cloudRedisClusterClient.ListClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Cluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Cluster 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<Cluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Cluster 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;

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ListClustersRequest request = new ListClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListClustersResponse, Cluster> response = cloudRedisClusterClient.ListClusters(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Cluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Cluster 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<Cluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Cluster 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;

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListClustersResponse, Cluster> response = cloudRedisClusterClient.ListClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Cluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Cluster 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<Cluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Cluster 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;

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListClustersResponse, Cluster> response = cloudRedisClusterClient.ListClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Cluster 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((ListClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Cluster 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<Cluster> 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 (Cluster 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;

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ListClustersRequest request = new ListClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListClustersResponse, Cluster> response = cloudRedisClusterClient.ListClustersAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Cluster 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((ListClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Cluster 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<Cluster> 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 (Cluster 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;

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListClustersResponse, Cluster> response = cloudRedisClusterClient.ListClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Cluster 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((ListClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Cluster 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<Cluster> 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 (Cluster 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;

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
Cluster cluster = new Cluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.UpdateCluster(cluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = cloudRedisClusterClient.PollOnceUpdateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
UpdateClusterRequest request = new UpdateClusterRequest
{
    UpdateMask = new FieldMask(),
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.UpdateCluster(request);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = cloudRedisClusterClient.PollOnceUpdateCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
Cluster cluster = new Cluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.UpdateClusterAsync(cluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceUpdateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
Cluster cluster = new Cluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.UpdateClusterAsync(cluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceUpdateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
UpdateClusterRequest request = new UpdateClusterRequest
{
    UpdateMask = new FieldMask(),
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.UpdateClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceUpdateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
UpdateClusterRequest request = new UpdateClusterRequest
{
    UpdateMask = new FieldMask(),
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.UpdateClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Cluster, Any> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Cluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Cluster, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceUpdateClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Cluster retrievedResult = retrievedResponse.Result;
}