Memorystore v1 API - Class MemorystoreClient (1.0.0-beta09)

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
AddAuthTokenRequest request = new AddAuthTokenRequest
{
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]"),
    AuthToken = new AuthToken(),
};
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = memorystoreClient.AddAuthToken(request);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = memorystoreClient.PollOnceAddAuthToken(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]");
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = memorystoreClient.AddAuthToken(tokenAuthUser, authToken);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = memorystoreClient.PollOnceAddAuthToken(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]";
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = memorystoreClient.AddAuthToken(tokenAuthUser, authToken);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = memorystoreClient.PollOnceAddAuthToken(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AddAuthTokenRequest request = new AddAuthTokenRequest
{
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]"),
    AuthToken = new AuthToken(),
};
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await memorystoreClient.AddAuthTokenAsync(request);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceAddAuthTokenAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AddAuthTokenRequest request = new AddAuthTokenRequest
{
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]"),
    AuthToken = new AuthToken(),
};
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await memorystoreClient.AddAuthTokenAsync(request);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceAddAuthTokenAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]");
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await memorystoreClient.AddAuthTokenAsync(tokenAuthUser, authToken);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceAddAuthTokenAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]");
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await memorystoreClient.AddAuthTokenAsync(tokenAuthUser, authToken);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceAddAuthTokenAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]";
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await memorystoreClient.AddAuthTokenAsync(tokenAuthUser, authToken);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceAddAuthTokenAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]";
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await memorystoreClient.AddAuthTokenAsync(tokenAuthUser, authToken);

// Poll until the returned long-running operation is complete
Operation<TokenAuthUser, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
TokenAuthUser 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<TokenAuthUser, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceAddAuthTokenAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    TokenAuthUser retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
AddTokenAuthUserRequest request = new AddTokenAuthUserRequest
{
    InstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    TokenAuthUser = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.AddTokenAuthUser(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 = memorystoreClient.PollOnceAddTokenAuthUser(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
InstanceName instance = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
string tokenAuthUser = "";
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.AddTokenAuthUser(instance, tokenAuthUser);

// 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 = memorystoreClient.PollOnceAddTokenAuthUser(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string instance = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
string tokenAuthUser = "";
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.AddTokenAuthUser(instance, tokenAuthUser);

// 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 = memorystoreClient.PollOnceAddTokenAuthUser(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AddTokenAuthUserRequest request = new AddTokenAuthUserRequest
{
    InstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    TokenAuthUser = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.AddTokenAuthUserAsync(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 memorystoreClient.PollOnceAddTokenAuthUserAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AddTokenAuthUserRequest request = new AddTokenAuthUserRequest
{
    InstanceAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    TokenAuthUser = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.AddTokenAuthUserAsync(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 memorystoreClient.PollOnceAddTokenAuthUserAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName instance = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
string tokenAuthUser = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.AddTokenAuthUserAsync(instance, tokenAuthUser);

// 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 memorystoreClient.PollOnceAddTokenAuthUserAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName instance = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
string tokenAuthUser = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.AddTokenAuthUserAsync(instance, tokenAuthUser);

// 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 memorystoreClient.PollOnceAddTokenAuthUserAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string instance = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
string tokenAuthUser = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.AddTokenAuthUserAsync(instance, tokenAuthUser);

// 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 memorystoreClient.PollOnceAddTokenAuthUserAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string instance = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
string tokenAuthUser = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.AddTokenAuthUserAsync(instance, tokenAuthUser);

// 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 memorystoreClient.PollOnceAddTokenAuthUserAsync(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
BackupInstanceRequest request = new BackupInstanceRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Ttl = new Duration(),
    BackupId = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.BackupInstance(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 = memorystoreClient.PollOnceBackupInstance(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.BackupInstance(name);

// 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 = memorystoreClient.PollOnceBackupInstance(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.BackupInstance(name);

// 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 = memorystoreClient.PollOnceBackupInstance(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupInstanceRequest request = new BackupInstanceRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Ttl = new Duration(),
    BackupId = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.BackupInstanceAsync(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 memorystoreClient.PollOnceBackupInstanceAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupInstanceRequest request = new BackupInstanceRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Ttl = new Duration(),
    BackupId = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.BackupInstanceAsync(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 memorystoreClient.PollOnceBackupInstanceAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.BackupInstanceAsync(name);

// 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 memorystoreClient.PollOnceBackupInstanceAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.BackupInstanceAsync(name);

// 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 memorystoreClient.PollOnceBackupInstanceAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.BackupInstanceAsync(name);

// 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 memorystoreClient.PollOnceBackupInstanceAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.BackupInstanceAsync(name);

// 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 memorystoreClient.PollOnceBackupInstanceAsync(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Instance instance = new Instance();
string instanceId = "";
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.CreateInstance(parent, instance, instanceId);

// 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 = memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
CreateInstanceRequest request = new CreateInstanceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    InstanceId = "",
    Instance = new Instance(),
    RequestId = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.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 = memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Instance instance = new Instance();
string instanceId = "";
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.CreateInstance(parent, instance, instanceId);

// 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 = memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Instance instance = new Instance();
string instanceId = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.CreateInstanceAsync(parent, instance, instanceId);

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

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Instance instance = new Instance();
string instanceId = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.CreateInstanceAsync(parent, instance, instanceId);

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

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
CreateInstanceRequest request = new CreateInstanceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    InstanceId = "",
    Instance = new Instance(),
    RequestId = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
CreateInstanceRequest request = new CreateInstanceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    InstanceId = "",
    Instance = new Instance(),
    RequestId = "",
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Instance instance = new Instance();
string instanceId = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.CreateInstanceAsync(parent, instance, instanceId);

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

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Instance instance = new Instance();
string instanceId = "";
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.CreateInstanceAsync(parent, instance, instanceId);

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

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteAuthToken(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 = memorystoreClient.PollOnceDeleteAuthToken(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
DeleteAuthTokenRequest request = new DeleteAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteAuthToken(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 = memorystoreClient.PollOnceDeleteAuthToken(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteAuthToken(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 = memorystoreClient.PollOnceDeleteAuthToken(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteAuthTokenAsync(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 memorystoreClient.PollOnceDeleteAuthTokenAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteAuthTokenAsync(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 memorystoreClient.PollOnceDeleteAuthTokenAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteAuthTokenRequest request = new DeleteAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteAuthTokenAsync(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 memorystoreClient.PollOnceDeleteAuthTokenAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteAuthTokenRequest request = new DeleteAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteAuthTokenAsync(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 memorystoreClient.PollOnceDeleteAuthTokenAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteAuthTokenAsync(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 memorystoreClient.PollOnceDeleteAuthTokenAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteAuthTokenAsync(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 memorystoreClient.PollOnceDeleteAuthTokenAsync(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteBackup(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 = memorystoreClient.PollOnceDeleteBackup(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteBackup(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 = memorystoreClient.PollOnceDeleteBackup(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteBackup(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 = memorystoreClient.PollOnceDeleteBackup(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteBackupAsync(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 memorystoreClient.PollOnceDeleteBackupAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteBackupAsync(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 memorystoreClient.PollOnceDeleteBackupAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteBackupAsync(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 memorystoreClient.PollOnceDeleteBackupAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteBackupAsync(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 memorystoreClient.PollOnceDeleteBackupAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteBackupAsync(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 memorystoreClient.PollOnceDeleteBackupAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteBackupAsync(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 memorystoreClient.PollOnceDeleteBackupAsync(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
DeleteInstanceRequest request = new DeleteInstanceRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.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 = memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.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 = memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.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 = memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteInstanceRequest request = new DeleteInstanceRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteInstanceRequest request = new DeleteInstanceRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.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 memorystoreClient.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;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
DeleteTokenAuthUserRequest request = new DeleteTokenAuthUserRequest
{
    TokenAuthUserName = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteTokenAuthUser(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 = memorystoreClient.PollOnceDeleteTokenAuthUser(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
TokenAuthUserName name = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteTokenAuthUser(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 = memorystoreClient.PollOnceDeleteTokenAuthUser(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Empty, OperationMetadata> response = memorystoreClient.DeleteTokenAuthUser(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 = memorystoreClient.PollOnceDeleteTokenAuthUser(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteTokenAuthUserRequest request = new DeleteTokenAuthUserRequest
{
    TokenAuthUserName = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteTokenAuthUserAsync(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 memorystoreClient.PollOnceDeleteTokenAuthUserAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
DeleteTokenAuthUserRequest request = new DeleteTokenAuthUserRequest
{
    TokenAuthUserName = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteTokenAuthUserAsync(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 memorystoreClient.PollOnceDeleteTokenAuthUserAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName name = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteTokenAuthUserAsync(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 memorystoreClient.PollOnceDeleteTokenAuthUserAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName name = TokenAuthUserName.FromProjectLocationInstanceTokenAuthUser("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteTokenAuthUserAsync(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 memorystoreClient.PollOnceDeleteTokenAuthUserAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteTokenAuthUserAsync(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 memorystoreClient.PollOnceDeleteTokenAuthUserAsync(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
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Empty, OperationMetadata> response = await memorystoreClient.DeleteTokenAuthUserAsync(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 memorystoreClient.PollOnceDeleteTokenAuthUserAsync(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
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
ExportBackupRequest request = new ExportBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    GcsBucket = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = memorystoreClient.ExportBackup(request);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Backup 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<Backup, OperationMetadata> retrievedResponse = memorystoreClient.PollOnceExportBackup(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Backup retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
ExportBackupRequest request = new ExportBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    GcsBucket = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = await memorystoreClient.ExportBackupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Backup 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<Backup, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceExportBackupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Backup retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
ExportBackupRequest request = new ExportBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    GcsBucket = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = await memorystoreClient.ExportBackupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Backup 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<Backup, OperationMetadata> retrievedResponse = await memorystoreClient.PollOnceExportBackupAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Backup retrievedResult = retrievedResponse.Result;
}

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
FinishMigrationRequest request = new FinishMigrationRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Force = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.FinishMigration(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 = memorystoreClient.PollOnceFinishMigration(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
bool force = false;
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.FinishMigration(name, force);

// 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 = memorystoreClient.PollOnceFinishMigration(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
bool force = false;
// Make the request
Operation<Instance, OperationMetadata> response = memorystoreClient.FinishMigration(name, force);

// 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 = memorystoreClient.PollOnceFinishMigration(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
FinishMigrationRequest request = new FinishMigrationRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Force = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.FinishMigrationAsync(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 memorystoreClient.PollOnceFinishMigrationAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
FinishMigrationRequest request = new FinishMigrationRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Force = false,
};
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.FinishMigrationAsync(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 memorystoreClient.PollOnceFinishMigrationAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
bool force = false;
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.FinishMigrationAsync(name, force);

// 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 memorystoreClient.PollOnceFinishMigrationAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
bool force = false;
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.FinishMigrationAsync(name, force);

// 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 memorystoreClient.PollOnceFinishMigrationAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
bool force = false;
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.FinishMigrationAsync(name, force);

// 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 memorystoreClient.PollOnceFinishMigrationAsync(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 client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
bool force = false;
// Make the request
Operation<Instance, OperationMetadata> response = await memorystoreClient.FinishMigrationAsync(name, force);

// 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 memorystoreClient.PollOnceFinishMigrationAsync(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 client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
AuthToken response = memorystoreClient.GetAuthToken(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
GetAuthTokenRequest request = new GetAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
AuthToken response = memorystoreClient.GetAuthToken(request);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
AuthToken response = memorystoreClient.GetAuthToken(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
AuthToken response = await memorystoreClient.GetAuthTokenAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
AuthToken response = await memorystoreClient.GetAuthTokenAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetAuthTokenRequest request = new GetAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
AuthToken response = await memorystoreClient.GetAuthTokenAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetAuthTokenRequest request = new GetAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationInstanceTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
AuthToken response = await memorystoreClient.GetAuthTokenAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
AuthToken response = await memorystoreClient.GetAuthTokenAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
AuthToken response = await memorystoreClient.GetAuthTokenAsync(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Backup response = memorystoreClient.GetBackup(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
};
// Make the request
Backup response = memorystoreClient.GetBackup(request);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Backup response = memorystoreClient.GetBackup(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Backup response = await memorystoreClient.GetBackupAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Backup response = await memorystoreClient.GetBackupAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
};
// Make the request
Backup response = await memorystoreClient.GetBackupAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
};
// Make the request
Backup response = await memorystoreClient.GetBackupAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Backup response = await memorystoreClient.GetBackupAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Backup response = await memorystoreClient.GetBackupAsync(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
BackupCollectionName name = BackupCollectionName.FromProjectLocationBackupCollection("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]");
// Make the request
BackupCollection response = memorystoreClient.GetBackupCollection(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
GetBackupCollectionRequest request = new GetBackupCollectionRequest
{
    BackupCollectionName = BackupCollectionName.FromProjectLocationBackupCollection("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]"),
};
// Make the request
BackupCollection response = memorystoreClient.GetBackupCollection(request);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]";
// Make the request
BackupCollection response = memorystoreClient.GetBackupCollection(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupCollectionName name = BackupCollectionName.FromProjectLocationBackupCollection("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]");
// Make the request
BackupCollection response = await memorystoreClient.GetBackupCollectionAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
BackupCollectionName name = BackupCollectionName.FromProjectLocationBackupCollection("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]");
// Make the request
BackupCollection response = await memorystoreClient.GetBackupCollectionAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetBackupCollectionRequest request = new GetBackupCollectionRequest
{
    BackupCollectionName = BackupCollectionName.FromProjectLocationBackupCollection("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]"),
};
// Make the request
BackupCollection response = await memorystoreClient.GetBackupCollectionAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetBackupCollectionRequest request = new GetBackupCollectionRequest
{
    BackupCollectionName = BackupCollectionName.FromProjectLocationBackupCollection("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]"),
};
// Make the request
BackupCollection response = await memorystoreClient.GetBackupCollectionAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]";
// Make the request
BackupCollection response = await memorystoreClient.GetBackupCollectionAsync(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]";
// Make the request
BackupCollection response = await memorystoreClient.GetBackupCollectionAsync(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
GetCertificateAuthorityRequest request = new GetCertificateAuthorityRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
CertificateAuthority response = memorystoreClient.GetCertificateAuthority(request);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
InstanceName name = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
CertificateAuthority response = memorystoreClient.GetCertificateAuthority(name);

// Create client
MemorystoreClient memorystoreClient = MemorystoreClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
CertificateAuthority response = memorystoreClient.GetCertificateAuthority(name);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetCertificateAuthorityRequest request = new GetCertificateAuthorityRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
CertificateAuthority response = await memorystoreClient.GetCertificateAuthorityAsync(request);

// Create client
MemorystoreClient memorystoreClient = await MemorystoreClient.CreateAsync();
// Initialize request argument(s)
GetCertificateAuthorityRequest request = new GetCertificateAuthorityRequest
{
    InstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
};
// Make the request
CertificateAuthority response = await memorystoreClient.GetCertificateAuthorityAsync(request);