public abstract class CloudMemcacheClient
Reference documentation and code samples for the Google Cloud Memorystore for Memcache v1beta2 API class CloudMemcacheClient.
CloudMemcache client wrapper, for convenient use.
Derived Types
Namespace
Google.Cloud.Memcache.V1Beta2Assembly
Google.Cloud.Memcache.V1Beta2.dll
Remarks
Configures and manages Cloud Memorystore for Memcached instances.
The memcache.googleapis.com
service implements the Google Cloud Memorystore
for Memcached API and defines the following resource model for managing
Memorystore Memcached (also called Memcached below) instances:
- The service works with a collection of cloud projects, named:
/projects/*
- Each project has a collection of available locations, named:
/locations/*
- Each location has a collection of Memcached instances, named:
/instances/*
- As such, Memcached instances are resources of the form:
/projects/{project_id}/locations/{location_id}/instances/{instance_id}
Note that location_id must be a GCP region
; for example:
projects/my-memcached-project/locations/us-central1/instances/my-memcached
Properties
ApplyParametersOperationsClient
public virtual OperationsClient ApplyParametersOperationsClient { get; }
The long-running operations client for ApplyParameters
.
Type | Description |
OperationsClient |
ApplySoftwareUpdateOperationsClient
public virtual OperationsClient ApplySoftwareUpdateOperationsClient { get; }
The long-running operations client for ApplySoftwareUpdate
.
Type | Description |
OperationsClient |
CreateInstanceOperationsClient
public virtual OperationsClient CreateInstanceOperationsClient { get; }
The long-running operations client for CreateInstance
.
Type | Description |
OperationsClient |
DefaultEndpoint
public static string DefaultEndpoint { get; }
The default endpoint for the CloudMemcache service, which is a host of "memcache.googleapis.com" and a port of 443.
Type | Description |
String |
DefaultScopes
public static IReadOnlyList<string> DefaultScopes { get; }
The default CloudMemcache scopes.
Type | Description |
IReadOnlyList<String> |
The default CloudMemcache scopes are:
DeleteInstanceOperationsClient
public virtual OperationsClient DeleteInstanceOperationsClient { get; }
The long-running operations client for DeleteInstance
.
Type | Description |
OperationsClient |
GrpcClient
public virtual CloudMemcache.CloudMemcacheClient GrpcClient { get; }
The underlying gRPC CloudMemcache client
Type | Description |
CloudMemcache.CloudMemcacheClient |
LocationsClient
public virtual LocationsClient LocationsClient { get; }
The LocationsClient associated with this client.
Type | Description |
LocationsClient |
RescheduleMaintenanceOperationsClient
public virtual OperationsClient RescheduleMaintenanceOperationsClient { get; }
The long-running operations client for RescheduleMaintenance
.
Type | Description |
OperationsClient |
ServiceMetadata
public static ServiceMetadata ServiceMetadata { get; }
The service metadata associated with this client type.
Type | Description |
ServiceMetadata |
UpdateInstanceOperationsClient
public virtual OperationsClient UpdateInstanceOperationsClient { get; }
The long-running operations client for UpdateInstance
.
Type | Description |
OperationsClient |
UpdateParametersOperationsClient
public virtual OperationsClient UpdateParametersOperationsClient { get; }
The long-running operations client for UpdateParameters
.
Type | Description |
OperationsClient |
Methods
ApplyParameters(ApplyParametersRequest, CallSettings)
public virtual Operation<Instance, OperationMetadata> ApplyParameters(ApplyParametersRequest request, CallSettings callSettings = null)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
request | ApplyParametersRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
ApplyParametersRequest request = new ApplyParametersRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
NodeIds = { "", },
ApplyAll = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.ApplyParameters(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceApplyParameters(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParameters(InstanceName, IEnumerable<String>, Boolean, CallSettings)
public virtual Operation<Instance, OperationMetadata> ApplyParameters(InstanceName name, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
name | InstanceName Required. Resource name of the Memcached instance for which parameter group updates should be applied. |
nodeIds | IEnumerable<String> Nodes to which the instance-level parameter group is applied. |
applyAll | Boolean Whether to apply instance-level parameter group to all nodes. If set to
true, users are restricted from specifying individual nodes, and
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.ApplyParameters(name, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceApplyParameters(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParameters(String, IEnumerable<String>, Boolean, CallSettings)
public virtual Operation<Instance, OperationMetadata> ApplyParameters(string name, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
name | String Required. Resource name of the Memcached instance for which parameter group updates should be applied. |
nodeIds | IEnumerable<String> Nodes to which the instance-level parameter group is applied. |
applyAll | Boolean Whether to apply instance-level parameter group to all nodes. If set to
true, users are restricted from specifying individual nodes, and
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.ApplyParameters(name, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceApplyParameters(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParametersAsync(ApplyParametersRequest, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> ApplyParametersAsync(ApplyParametersRequest request, CallSettings callSettings = null)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
request | ApplyParametersRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
ApplyParametersRequest request = new ApplyParametersRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
NodeIds = { "", },
ApplyAll = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplyParametersAsync(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplyParametersAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParametersAsync(ApplyParametersRequest, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> ApplyParametersAsync(ApplyParametersRequest request, CancellationToken cancellationToken)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
request | ApplyParametersRequest The request object containing all of the parameters for the API call. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
ApplyParametersRequest request = new ApplyParametersRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
NodeIds = { "", },
ApplyAll = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplyParametersAsync(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplyParametersAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParametersAsync(InstanceName, IEnumerable<String>, Boolean, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> ApplyParametersAsync(InstanceName name, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
name | InstanceName Required. Resource name of the Memcached instance for which parameter group updates should be applied. |
nodeIds | IEnumerable<String> Nodes to which the instance-level parameter group is applied. |
applyAll | Boolean Whether to apply instance-level parameter group to all nodes. If set to
true, users are restricted from specifying individual nodes, and
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplyParametersAsync(name, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplyParametersAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParametersAsync(InstanceName, IEnumerable<String>, Boolean, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> ApplyParametersAsync(InstanceName name, IEnumerable<string> nodeIds, bool applyAll, CancellationToken cancellationToken)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
name | InstanceName Required. Resource name of the Memcached instance for which parameter group updates should be applied. |
nodeIds | IEnumerable<String> Nodes to which the instance-level parameter group is applied. |
applyAll | Boolean Whether to apply instance-level parameter group to all nodes. If set to
true, users are restricted from specifying individual nodes, and
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplyParametersAsync(name, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplyParametersAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParametersAsync(String, IEnumerable<String>, Boolean, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> ApplyParametersAsync(string name, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
name | String Required. Resource name of the Memcached instance for which parameter group updates should be applied. |
nodeIds | IEnumerable<String> Nodes to which the instance-level parameter group is applied. |
applyAll | Boolean Whether to apply instance-level parameter group to all nodes. If set to
true, users are restricted from specifying individual nodes, and
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplyParametersAsync(name, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplyParametersAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplyParametersAsync(String, IEnumerable<String>, Boolean, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> ApplyParametersAsync(string name, IEnumerable<string> nodeIds, bool applyAll, CancellationToken cancellationToken)
ApplyParameters
restarts the set of specified nodes in order to update
them to the current set of parameters for the Memcached Instance.
Name | Description |
name | String Required. Resource name of the Memcached instance for which parameter group updates should be applied. |
nodeIds | IEnumerable<String> Nodes to which the instance-level parameter group is applied. |
applyAll | Boolean Whether to apply instance-level parameter group to all nodes. If set to
true, users are restricted from specifying individual nodes, and
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplyParametersAsync(name, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplyParametersAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdate(ApplySoftwareUpdateRequest, CallSettings)
public virtual Operation<Instance, OperationMetadata> ApplySoftwareUpdate(ApplySoftwareUpdateRequest request, CallSettings callSettings = null)
Updates software on the selected nodes of the Instance.
Name | Description |
request | ApplySoftwareUpdateRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
ApplySoftwareUpdateRequest request = new ApplySoftwareUpdateRequest
{
InstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
NodeIds = { "", },
ApplyAll = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.ApplySoftwareUpdate(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceApplySoftwareUpdate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdate(InstanceName, IEnumerable<String>, Boolean, CallSettings)
public virtual Operation<Instance, OperationMetadata> ApplySoftwareUpdate(InstanceName instance, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
Updates software on the selected nodes of the Instance.
Name | Description |
instance | InstanceName Required. Resource name of the Memcached instance for which software update should be applied. |
nodeIds | IEnumerable<String> Nodes to which we should apply the update to. Note all the selected nodes are updated in parallel. |
applyAll | Boolean Whether to apply the update to all nodes. If set to true, will explicitly restrict users from specifying any nodes, and apply software update to all nodes (where applicable) within the instance. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
InstanceName instance = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.ApplySoftwareUpdate(instance, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceApplySoftwareUpdate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdate(String, IEnumerable<String>, Boolean, CallSettings)
public virtual Operation<Instance, OperationMetadata> ApplySoftwareUpdate(string instance, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
Updates software on the selected nodes of the Instance.
Name | Description |
instance | String Required. Resource name of the Memcached instance for which software update should be applied. |
nodeIds | IEnumerable<String> Nodes to which we should apply the update to. Note all the selected nodes are updated in parallel. |
applyAll | Boolean Whether to apply the update to all nodes. If set to true, will explicitly restrict users from specifying any nodes, and apply software update to all nodes (where applicable) within the instance. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
string instance = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.ApplySoftwareUpdate(instance, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceApplySoftwareUpdate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdateAsync(ApplySoftwareUpdateRequest, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> ApplySoftwareUpdateAsync(ApplySoftwareUpdateRequest request, CallSettings callSettings = null)
Updates software on the selected nodes of the Instance.
Name | Description |
request | ApplySoftwareUpdateRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
ApplySoftwareUpdateRequest request = new ApplySoftwareUpdateRequest
{
InstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
NodeIds = { "", },
ApplyAll = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplySoftwareUpdateAsync(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplySoftwareUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdateAsync(ApplySoftwareUpdateRequest, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> ApplySoftwareUpdateAsync(ApplySoftwareUpdateRequest request, CancellationToken cancellationToken)
Updates software on the selected nodes of the Instance.
Name | Description |
request | ApplySoftwareUpdateRequest The request object containing all of the parameters for the API call. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
ApplySoftwareUpdateRequest request = new ApplySoftwareUpdateRequest
{
InstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
NodeIds = { "", },
ApplyAll = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplySoftwareUpdateAsync(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplySoftwareUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdateAsync(InstanceName, IEnumerable<String>, Boolean, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> ApplySoftwareUpdateAsync(InstanceName instance, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
Updates software on the selected nodes of the Instance.
Name | Description |
instance | InstanceName Required. Resource name of the Memcached instance for which software update should be applied. |
nodeIds | IEnumerable<String> Nodes to which we should apply the update to. Note all the selected nodes are updated in parallel. |
applyAll | Boolean Whether to apply the update to all nodes. If set to true, will explicitly restrict users from specifying any nodes, and apply software update to all nodes (where applicable) within the instance. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName instance = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplySoftwareUpdateAsync(instance, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplySoftwareUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdateAsync(InstanceName, IEnumerable<String>, Boolean, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> ApplySoftwareUpdateAsync(InstanceName instance, IEnumerable<string> nodeIds, bool applyAll, CancellationToken cancellationToken)
Updates software on the selected nodes of the Instance.
Name | Description |
instance | InstanceName Required. Resource name of the Memcached instance for which software update should be applied. |
nodeIds | IEnumerable<String> Nodes to which we should apply the update to. Note all the selected nodes are updated in parallel. |
applyAll | Boolean Whether to apply the update to all nodes. If set to true, will explicitly restrict users from specifying any nodes, and apply software update to all nodes (where applicable) within the instance. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName instance = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplySoftwareUpdateAsync(instance, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplySoftwareUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdateAsync(String, IEnumerable<String>, Boolean, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> ApplySoftwareUpdateAsync(string instance, IEnumerable<string> nodeIds, bool applyAll, CallSettings callSettings = null)
Updates software on the selected nodes of the Instance.
Name | Description |
instance | String Required. Resource name of the Memcached instance for which software update should be applied. |
nodeIds | IEnumerable<String> Nodes to which we should apply the update to. Note all the selected nodes are updated in parallel. |
applyAll | Boolean Whether to apply the update to all nodes. If set to true, will explicitly restrict users from specifying any nodes, and apply software update to all nodes (where applicable) within the instance. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string instance = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplySoftwareUpdateAsync(instance, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplySoftwareUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
ApplySoftwareUpdateAsync(String, IEnumerable<String>, Boolean, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> ApplySoftwareUpdateAsync(string instance, IEnumerable<string> nodeIds, bool applyAll, CancellationToken cancellationToken)
Updates software on the selected nodes of the Instance.
Name | Description |
instance | String Required. Resource name of the Memcached instance for which software update should be applied. |
nodeIds | IEnumerable<String> Nodes to which we should apply the update to. Note all the selected nodes are updated in parallel. |
applyAll | Boolean Whether to apply the update to all nodes. If set to true, will explicitly restrict users from specifying any nodes, and apply software update to all nodes (where applicable) within the instance. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string instance = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
IEnumerable<string> nodeIds = new string[] { "", };
bool applyAll = false;
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.ApplySoftwareUpdateAsync(instance, nodeIds, applyAll);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceApplySoftwareUpdateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
Create()
public static CloudMemcacheClient Create()
Synchronously creates a CloudMemcacheClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use CloudMemcacheClientBuilder.
Type | Description |
CloudMemcacheClient | The created CloudMemcacheClient. |
CreateAsync(CancellationToken)
public static Task<CloudMemcacheClient> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))
Asynchronously creates a CloudMemcacheClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use CloudMemcacheClientBuilder.
Name | Description |
cancellationToken | CancellationToken The CancellationToken to use while creating the client. |
Type | Description |
Task<CloudMemcacheClient> | The task representing the created CloudMemcacheClient. |
CreateInstance(LocationName, String, Instance, CallSettings)
public virtual Operation<Instance, OperationMetadata> CreateInstance(LocationName parent, string instanceId, Instance resource, CallSettings callSettings = null)
Creates a new Instance in a given location.
Name | Description |
parent | LocationName Required. The resource name of the instance location using the form:
|
instanceId | String Required. The logical name of the Memcached instance in the user project with the following restrictions:
If any of the above are not met, the API raises an invalid argument error. |
resource | Instance Required. A Memcached [Instance] resource |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string instanceId = "";
Instance resource = new Instance();
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.CreateInstance(parent, instanceId, resource);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceCreateInstance(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstance(CreateInstanceRequest, CallSettings)
public virtual Operation<Instance, OperationMetadata> CreateInstance(CreateInstanceRequest request, CallSettings callSettings = null)
Creates a new Instance in a given location.
Name | Description |
request | CreateInstanceRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
CreateInstanceRequest request = new CreateInstanceRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
InstanceId = "",
Resource = new Instance(),
};
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.CreateInstance(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceCreateInstance(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstance(String, String, Instance, CallSettings)
public virtual Operation<Instance, OperationMetadata> CreateInstance(string parent, string instanceId, Instance resource, CallSettings callSettings = null)
Creates a new Instance in a given location.
Name | Description |
parent | String Required. The resource name of the instance location using the form:
|
instanceId | String Required. The logical name of the Memcached instance in the user project with the following restrictions:
If any of the above are not met, the API raises an invalid argument error. |
resource | Instance Required. A Memcached [Instance] resource |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Instance, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string instanceId = "";
Instance resource = new Instance();
// Make the request
Operation<Instance, OperationMetadata> response = cloudMemcacheClient.CreateInstance(parent, instanceId, resource);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceCreateInstance(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstanceAsync(LocationName, String, Instance, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> CreateInstanceAsync(LocationName parent, string instanceId, Instance resource, CallSettings callSettings = null)
Creates a new Instance in a given location.
Name | Description |
parent | LocationName Required. The resource name of the instance location using the form:
|
instanceId | String Required. The logical name of the Memcached instance in the user project with the following restrictions:
If any of the above are not met, the API raises an invalid argument error. |
resource | Instance Required. A Memcached [Instance] resource |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string instanceId = "";
Instance resource = new Instance();
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.CreateInstanceAsync(parent, instanceId, resource);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstanceAsync(LocationName, String, Instance, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> CreateInstanceAsync(LocationName parent, string instanceId, Instance resource, CancellationToken cancellationToken)
Creates a new Instance in a given location.
Name | Description |
parent | LocationName Required. The resource name of the instance location using the form:
|
instanceId | String Required. The logical name of the Memcached instance in the user project with the following restrictions:
If any of the above are not met, the API raises an invalid argument error. |
resource | Instance Required. A Memcached [Instance] resource |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string instanceId = "";
Instance resource = new Instance();
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.CreateInstanceAsync(parent, instanceId, resource);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstanceAsync(CreateInstanceRequest, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> CreateInstanceAsync(CreateInstanceRequest request, CallSettings callSettings = null)
Creates a new Instance in a given location.
Name | Description |
request | CreateInstanceRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
CreateInstanceRequest request = new CreateInstanceRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
InstanceId = "",
Resource = new Instance(),
};
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.CreateInstanceAsync(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstanceAsync(CreateInstanceRequest, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> CreateInstanceAsync(CreateInstanceRequest request, CancellationToken cancellationToken)
Creates a new Instance in a given location.
Name | Description |
request | CreateInstanceRequest The request object containing all of the parameters for the API call. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
CreateInstanceRequest request = new CreateInstanceRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
InstanceId = "",
Resource = new Instance(),
};
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.CreateInstanceAsync(request);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstanceAsync(String, String, Instance, CallSettings)
public virtual Task<Operation<Instance, OperationMetadata>> CreateInstanceAsync(string parent, string instanceId, Instance resource, CallSettings callSettings = null)
Creates a new Instance in a given location.
Name | Description |
parent | String Required. The resource name of the instance location using the form:
|
instanceId | String Required. The logical name of the Memcached instance in the user project with the following restrictions:
If any of the above are not met, the API raises an invalid argument error. |
resource | Instance Required. A Memcached [Instance] resource |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string instanceId = "";
Instance resource = new Instance();
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.CreateInstanceAsync(parent, instanceId, resource);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
CreateInstanceAsync(String, String, Instance, CancellationToken)
public virtual Task<Operation<Instance, OperationMetadata>> CreateInstanceAsync(string parent, string instanceId, Instance resource, CancellationToken cancellationToken)
Creates a new Instance in a given location.
Name | Description |
parent | String Required. The resource name of the instance location using the form:
|
instanceId | String Required. The logical name of the Memcached instance in the user project with the following restrictions:
If any of the above are not met, the API raises an invalid argument error. |
resource | Instance Required. A Memcached [Instance] resource |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Instance, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string instanceId = "";
Instance resource = new Instance();
// Make the request
Operation<Instance, OperationMetadata> response = await cloudMemcacheClient.CreateInstanceAsync(parent, instanceId, resource);
// Poll until the returned long-running operation is complete
Operation<Instance, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Instance 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<Instance, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceCreateInstanceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Instance retrievedResult = retrievedResponse.Result;
}
DeleteInstance(DeleteInstanceRequest, CallSettings)
public virtual Operation<Empty, OperationMetadata> DeleteInstance(DeleteInstanceRequest request, CallSettings callSettings = null)
Deletes a single Instance.
Name | Description |
request | DeleteInstanceRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
DeleteInstanceRequest request = new DeleteInstanceRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = cloudMemcacheClient.DeleteInstance(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceDeleteInstance(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;
}
DeleteInstance(InstanceName, CallSettings)
public virtual Operation<Empty, OperationMetadata> DeleteInstance(InstanceName name, CallSettings callSettings = null)
Deletes a single Instance.
Name | Description |
name | InstanceName Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Empty, OperationMetadata> response = cloudMemcacheClient.DeleteInstance(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceDeleteInstance(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;
}
DeleteInstance(String, CallSettings)
public virtual Operation<Empty, OperationMetadata> DeleteInstance(string name, CallSettings callSettings = null)
Deletes a single Instance.
Name | Description |
name | String Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Empty, OperationMetadata> response = cloudMemcacheClient.DeleteInstance(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = cloudMemcacheClient.PollOnceDeleteInstance(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;
}
DeleteInstanceAsync(DeleteInstanceRequest, CallSettings)
public virtual Task<Operation<Empty, OperationMetadata>> DeleteInstanceAsync(DeleteInstanceRequest request, CallSettings callSettings = null)
Deletes a single Instance.
Name | Description |
request | DeleteInstanceRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
DeleteInstanceRequest request = new DeleteInstanceRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudMemcacheClient.DeleteInstanceAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceDeleteInstanceAsync(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;
}
DeleteInstanceAsync(DeleteInstanceRequest, CancellationToken)
public virtual Task<Operation<Empty, OperationMetadata>> DeleteInstanceAsync(DeleteInstanceRequest request, CancellationToken cancellationToken)
Deletes a single Instance.
Name | Description |
request | DeleteInstanceRequest The request object containing all of the parameters for the API call. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
DeleteInstanceRequest request = new DeleteInstanceRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudMemcacheClient.DeleteInstanceAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceDeleteInstanceAsync(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;
}
DeleteInstanceAsync(InstanceName, CallSettings)
public virtual Task<Operation<Empty, OperationMetadata>> DeleteInstanceAsync(InstanceName name, CallSettings callSettings = null)
Deletes a single Instance.
Name | Description |
name | InstanceName Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudMemcacheClient.DeleteInstanceAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceDeleteInstanceAsync(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;
}
DeleteInstanceAsync(InstanceName, CancellationToken)
public virtual Task<Operation<Empty, OperationMetadata>> DeleteInstanceAsync(InstanceName name, CancellationToken cancellationToken)
Deletes a single Instance.
Name | Description |
name | InstanceName Required. Memcached instance resource name in the format:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudMemcacheClient.DeleteInstanceAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceDeleteInstanceAsync(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;
}
DeleteInstanceAsync(String, CallSettings)
public virtual Task<Operation<Empty, OperationMetadata>> DeleteInstanceAsync(string name, CallSettings callSettings = null)
Deletes a single Instance.
Name | Description |
name | String Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudMemcacheClient.DeleteInstanceAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceDeleteInstanceAsync(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;
}
DeleteInstanceAsync(String, CancellationToken)
public virtual Task<Operation<Empty, OperationMetadata>> DeleteInstanceAsync(string name, CancellationToken cancellationToken)
Deletes a single Instance.
Name | Description |
name | String Required. Memcached instance resource name in the format:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudMemcacheClient.DeleteInstanceAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> 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, OperationMetadata> retrievedResponse = await cloudMemcacheClient.PollOnceDeleteInstanceAsync(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;
}
GetInstance(GetInstanceRequest, CallSettings)
public virtual Instance GetInstance(GetInstanceRequest request, CallSettings callSettings = null)
Gets details of a single Instance.
Name | Description |
request | GetInstanceRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Instance | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
GetInstanceRequest request = new GetInstanceRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
Instance response = cloudMemcacheClient.GetInstance(request);
GetInstance(InstanceName, CallSettings)
public virtual Instance GetInstance(InstanceName name, CallSettings callSettings = null)
Gets details of a single Instance.
Name | Description |
name | InstanceName Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Instance | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Instance response = cloudMemcacheClient.GetInstance(name);
GetInstance(String, CallSettings)
public virtual Instance GetInstance(string name, CallSettings callSettings = null)
Gets details of a single Instance.
Name | Description |
name | String Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Instance | The RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Instance response = cloudMemcacheClient.GetInstance(name);
GetInstanceAsync(GetInstanceRequest, CallSettings)
public virtual Task<Instance> GetInstanceAsync(GetInstanceRequest request, CallSettings callSettings = null)
Gets details of a single Instance.
Name | Description |
request | GetInstanceRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Instance> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
GetInstanceRequest request = new GetInstanceRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
Instance response = await cloudMemcacheClient.GetInstanceAsync(request);
GetInstanceAsync(GetInstanceRequest, CancellationToken)
public virtual Task<Instance> GetInstanceAsync(GetInstanceRequest request, CancellationToken cancellationToken)
Gets details of a single Instance.
Name | Description |
request | GetInstanceRequest The request object containing all of the parameters for the API call. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Instance> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
GetInstanceRequest request = new GetInstanceRequest
{
InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
Instance response = await cloudMemcacheClient.GetInstanceAsync(request);
GetInstanceAsync(InstanceName, CallSettings)
public virtual Task<Instance> GetInstanceAsync(InstanceName name, CallSettings callSettings = null)
Gets details of a single Instance.
Name | Description |
name | InstanceName Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Instance> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Instance response = await cloudMemcacheClient.GetInstanceAsync(name);
GetInstanceAsync(InstanceName, CancellationToken)
public virtual Task<Instance> GetInstanceAsync(InstanceName name, CancellationToken cancellationToken)
Gets details of a single Instance.
Name | Description |
name | InstanceName Required. Memcached instance resource name in the format:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Instance> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Instance response = await cloudMemcacheClient.GetInstanceAsync(name);
GetInstanceAsync(String, CallSettings)
public virtual Task<Instance> GetInstanceAsync(string name, CallSettings callSettings = null)
Gets details of a single Instance.
Name | Description |
name | String Required. Memcached instance resource name in the format:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
Task<Instance> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Instance response = await cloudMemcacheClient.GetInstanceAsync(name);
GetInstanceAsync(String, CancellationToken)
public virtual Task<Instance> GetInstanceAsync(string name, CancellationToken cancellationToken)
Gets details of a single Instance.
Name | Description |
name | String Required. Memcached instance resource name in the format:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Type | Description |
Task<Instance> | A Task containing the RPC response. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Instance response = await cloudMemcacheClient.GetInstanceAsync(name);
ListInstances(LocationName, String, Nullable<Int32>, CallSettings)
public virtual PagedEnumerable<ListInstancesResponse, Instance> ListInstances(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)
Lists Instances in a given location.
Name | Description |
parent | LocationName Required. The resource name of the instance location using the form:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
PagedEnumerable<ListInstancesResponse, Instance> | A pageable sequence of Instance resources. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListInstancesResponse, Instance> response = cloudMemcacheClient.ListInstances(parent);
// Iterate over all response items, lazily performing RPCs as required
foreach (Instance 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 (ListInstancesResponse page in response.AsRawResponses())
{
// 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 = response.ReadPage(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;
ListInstances(ListInstancesRequest, CallSettings)
public virtual PagedEnumerable<ListInstancesResponse, Instance> ListInstances(ListInstancesRequest request, CallSettings callSettings = null)
Lists Instances in a given location.
Name | Description |
request | ListInstancesRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
PagedEnumerable<ListInstancesResponse, Instance> | A pageable sequence of Instance resources. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
ListInstancesRequest request = new ListInstancesRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
Filter = "",
OrderBy = "",
};
// Make the request
PagedEnumerable<ListInstancesResponse, Instance> response = cloudMemcacheClient.ListInstances(request);
// Iterate over all response items, lazily performing RPCs as required
foreach (Instance 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 (ListInstancesResponse page in response.AsRawResponses())
{
// 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 = response.ReadPage(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;
ListInstances(String, String, Nullable<Int32>, CallSettings)
public virtual PagedEnumerable<ListInstancesResponse, Instance> ListInstances(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)
Lists Instances in a given location.
Name | Description |
parent | String Required. The resource name of the instance location using the form:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
PagedEnumerable<ListInstancesResponse, Instance> | A pageable sequence of Instance resources. |
// Create client
CloudMemcacheClient cloudMemcacheClient = CloudMemcacheClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListInstancesResponse, Instance> response = cloudMemcacheClient.ListInstances(parent);
// Iterate over all response items, lazily performing RPCs as required
foreach (Instance 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 (ListInstancesResponse page in response.AsRawResponses())
{
// 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 = response.ReadPage(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;
ListInstancesAsync(LocationName, String, Nullable<Int32>, CallSettings)
public virtual PagedAsyncEnumerable<ListInstancesResponse, Instance> ListInstancesAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)
Lists Instances in a given location.
Name | Description |
parent | LocationName Required. The resource name of the instance location using the form:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
PagedAsyncEnumerable<ListInstancesResponse, Instance> | A pageable asynchronous sequence of Instance resources. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListInstancesResponse, Instance> response = cloudMemcacheClient.ListInstancesAsync(parent);
// 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;
ListInstancesAsync(ListInstancesRequest, CallSettings)
public virtual PagedAsyncEnumerable<ListInstancesResponse, Instance> ListInstancesAsync(ListInstancesRequest request, CallSettings callSettings = null)
Lists Instances in a given location.
Name | Description |
request | ListInstancesRequest The request object containing all of the parameters for the API call. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
PagedAsyncEnumerable<ListInstancesResponse, Instance> | A pageable asynchronous sequence of Instance resources. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
ListInstancesRequest request = new ListInstancesRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
Filter = "",
OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListInstancesResponse, Instance> response = cloudMemcacheClient.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;
ListInstancesAsync(String, String, Nullable<Int32>, CallSettings)
public virtual PagedAsyncEnumerable<ListInstancesResponse, Instance> ListInstancesAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)
Lists Instances in a given location.
Name | Description |
parent | String Required. The resource name of the instance location using the form:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Type | Description |
PagedAsyncEnumerable<ListInstancesResponse, Instance> | A pageable asynchronous sequence of Instance resources. |
// Create client
CloudMemcacheClient cloudMemcacheClient = await CloudMemcacheClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListInstancesResponse, Instance> response = cloudMemcacheClient.ListInstancesAsync(parent);
// 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;
PollOnceApplyParameters(String, CallSettings)
public virtual Operation<Instance, OperationMetadata> PollOnceApplyParameters(string operationName, CallSettings callSettings = null)
Poll an operation once, using an <