Backup and DR Service v1 API - Class BackupDRClient (2.0.0)

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = backupDRClient.CreateBackupPlan(parent, backupPlan, backupPlanId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
CreateBackupPlanRequest request = new CreateBackupPlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlanId = "",
    BackupPlan = new BackupPlan(),
    RequestId = "",
};
// Make the request
Operation<BackupPlan, OperationMetadata> response = backupDRClient.CreateBackupPlan(request);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = backupDRClient.CreateBackupPlan(parent, backupPlan, backupPlanId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlanAssociation backupPlanAssociation = new BackupPlanAssociation();
string backupPlanAssociationId = "";
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = backupDRClient.CreateBackupPlanAssociation(parent, backupPlanAssociation, backupPlanAssociationId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
CreateBackupPlanAssociationRequest request = new CreateBackupPlanAssociationRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlanAssociationId = "",
    BackupPlanAssociation = new BackupPlanAssociation(),
    RequestId = "",
};
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = backupDRClient.CreateBackupPlanAssociation(request);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlanAssociation backupPlanAssociation = new BackupPlanAssociation();
string backupPlanAssociationId = "";
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = backupDRClient.CreateBackupPlanAssociation(parent, backupPlanAssociation, backupPlanAssociationId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlanAssociation backupPlanAssociation = new BackupPlanAssociation();
string backupPlanAssociationId = "";
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = await backupDRClient.CreateBackupPlanAssociationAsync(parent, backupPlanAssociation, backupPlanAssociationId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlanAssociation backupPlanAssociation = new BackupPlanAssociation();
string backupPlanAssociationId = "";
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = await backupDRClient.CreateBackupPlanAssociationAsync(parent, backupPlanAssociation, backupPlanAssociationId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPlanAssociationRequest request = new CreateBackupPlanAssociationRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlanAssociationId = "",
    BackupPlanAssociation = new BackupPlanAssociation(),
    RequestId = "",
};
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = await backupDRClient.CreateBackupPlanAssociationAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPlanAssociationRequest request = new CreateBackupPlanAssociationRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlanAssociationId = "",
    BackupPlanAssociation = new BackupPlanAssociation(),
    RequestId = "",
};
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = await backupDRClient.CreateBackupPlanAssociationAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlanAssociation backupPlanAssociation = new BackupPlanAssociation();
string backupPlanAssociationId = "";
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = await backupDRClient.CreateBackupPlanAssociationAsync(parent, backupPlanAssociation, backupPlanAssociationId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlanAssociation backupPlanAssociation = new BackupPlanAssociation();
string backupPlanAssociationId = "";
// Make the request
Operation<BackupPlanAssociation, OperationMetadata> response = await backupDRClient.CreateBackupPlanAssociationAsync(parent, backupPlanAssociation, backupPlanAssociationId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupDRClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupDRClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPlanRequest request = new CreateBackupPlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlanId = "",
    BackupPlan = new BackupPlan(),
    RequestId = "",
};
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupDRClient.CreateBackupPlanAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPlanRequest request = new CreateBackupPlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlanId = "",
    BackupPlan = new BackupPlan(),
    RequestId = "",
};
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupDRClient.CreateBackupPlanAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupDRClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupDRClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = backupDRClient.CreateBackupVault(parent, backupVault, backupVaultId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
CreateBackupVaultRequest request = new CreateBackupVaultRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupVaultId = "",
    BackupVault = new BackupVault(),
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<BackupVault, OperationMetadata> response = backupDRClient.CreateBackupVault(request);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = backupDRClient.CreateBackupVault(parent, backupVault, backupVaultId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = await backupDRClient.CreateBackupVaultAsync(parent, backupVault, backupVaultId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = await backupDRClient.CreateBackupVaultAsync(parent, backupVault, backupVaultId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateBackupVaultRequest request = new CreateBackupVaultRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupVaultId = "",
    BackupVault = new BackupVault(),
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<BackupVault, OperationMetadata> response = await backupDRClient.CreateBackupVaultAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateBackupVaultRequest request = new CreateBackupVaultRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupVaultId = "",
    BackupVault = new BackupVault(),
    RequestId = "",
    ValidateOnly = false,
};
// Make the request
Operation<BackupVault, OperationMetadata> response = await backupDRClient.CreateBackupVaultAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = await backupDRClient.CreateBackupVaultAsync(parent, backupVault, backupVaultId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = await backupDRClient.CreateBackupVaultAsync(parent, backupVault, backupVaultId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ManagementServer managementServer = new ManagementServer();
string managementServerId = "";
// Make the request
Operation<ManagementServer, OperationMetadata> response = backupDRClient.CreateManagementServer(parent, managementServer, managementServerId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
CreateManagementServerRequest request = new CreateManagementServerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ManagementServerId = "",
    ManagementServer = new ManagementServer(),
    RequestId = "",
};
// Make the request
Operation<ManagementServer, OperationMetadata> response = backupDRClient.CreateManagementServer(request);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ManagementServer managementServer = new ManagementServer();
string managementServerId = "";
// Make the request
Operation<ManagementServer, OperationMetadata> response = backupDRClient.CreateManagementServer(parent, managementServer, managementServerId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ManagementServer managementServer = new ManagementServer();
string managementServerId = "";
// Make the request
Operation<ManagementServer, OperationMetadata> response = await backupDRClient.CreateManagementServerAsync(parent, managementServer, managementServerId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ManagementServer managementServer = new ManagementServer();
string managementServerId = "";
// Make the request
Operation<ManagementServer, OperationMetadata> response = await backupDRClient.CreateManagementServerAsync(parent, managementServer, managementServerId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateManagementServerRequest request = new CreateManagementServerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ManagementServerId = "",
    ManagementServer = new ManagementServer(),
    RequestId = "",
};
// Make the request
Operation<ManagementServer, OperationMetadata> response = await backupDRClient.CreateManagementServerAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
CreateManagementServerRequest request = new CreateManagementServerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ManagementServerId = "",
    ManagementServer = new ManagementServer(),
    RequestId = "",
};
// Make the request
Operation<ManagementServer, OperationMetadata> response = await backupDRClient.CreateManagementServerAsync(request);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ManagementServer managementServer = new ManagementServer();
string managementServerId = "";
// Make the request
Operation<ManagementServer, OperationMetadata> response = await backupDRClient.CreateManagementServerAsync(parent, managementServer, managementServerId);

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

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ManagementServer managementServer = new ManagementServer();
string managementServerId = "";
// Make the request
Operation<ManagementServer, OperationMetadata> response = await backupDRClient.CreateManagementServerAsync(parent, managementServer, managementServerId);

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

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]");
// Make the request
Operation<Backup, OperationMetadata> response = backupDRClient.DeleteBackup(name);

// 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 = backupDRClient.PollOnceDeleteBackup(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = backupDRClient.DeleteBackup(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 = backupDRClient.PollOnceDeleteBackup(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]/dataSources/[DATASOURCE]/backups/[BACKUP]";
// Make the request
Operation<Backup, OperationMetadata> response = backupDRClient.DeleteBackup(name);

// 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 = backupDRClient.PollOnceDeleteBackup(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]");
// Make the request
Operation<Backup, OperationMetadata> response = await backupDRClient.DeleteBackupAsync(name);

// 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 backupDRClient.PollOnceDeleteBackupAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]");
// Make the request
Operation<Backup, OperationMetadata> response = await backupDRClient.DeleteBackupAsync(name);

// 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 backupDRClient.PollOnceDeleteBackupAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = await backupDRClient.DeleteBackupAsync(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 backupDRClient.PollOnceDeleteBackupAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = await backupDRClient.DeleteBackupAsync(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 backupDRClient.PollOnceDeleteBackupAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]/dataSources/[DATASOURCE]/backups/[BACKUP]";
// Make the request
Operation<Backup, OperationMetadata> response = await backupDRClient.DeleteBackupAsync(name);

// 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 backupDRClient.PollOnceDeleteBackupAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]/dataSources/[DATASOURCE]/backups/[BACKUP]";
// Make the request
Operation<Backup, OperationMetadata> response = await backupDRClient.DeleteBackupAsync(name);

// 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 backupDRClient.PollOnceDeleteBackupAsync(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupPlan(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 = backupDRClient.PollOnceDeleteBackupPlan(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
DeleteBackupPlanRequest request = new DeleteBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupPlan(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 = backupDRClient.PollOnceDeleteBackupPlan(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupPlan(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 = backupDRClient.PollOnceDeleteBackupPlan(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupPlanAssociationName name = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]");
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupPlanAssociation(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 = backupDRClient.PollOnceDeleteBackupPlanAssociation(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
DeleteBackupPlanAssociationRequest request = new DeleteBackupPlanAssociationRequest
{
    BackupPlanAssociationName = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupPlanAssociation(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 = backupDRClient.PollOnceDeleteBackupPlanAssociation(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlanAssociations/[BACKUP_PLAN_ASSOCIATION]";
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupPlanAssociation(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 = backupDRClient.PollOnceDeleteBackupPlanAssociation(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanAssociationName name = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAssociationAsync(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 backupDRClient.PollOnceDeleteBackupPlanAssociationAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanAssociationName name = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAssociationAsync(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 backupDRClient.PollOnceDeleteBackupPlanAssociationAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupPlanAssociationRequest request = new DeleteBackupPlanAssociationRequest
{
    BackupPlanAssociationName = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAssociationAsync(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 backupDRClient.PollOnceDeleteBackupPlanAssociationAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupPlanAssociationRequest request = new DeleteBackupPlanAssociationRequest
{
    BackupPlanAssociationName = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAssociationAsync(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 backupDRClient.PollOnceDeleteBackupPlanAssociationAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlanAssociations/[BACKUP_PLAN_ASSOCIATION]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAssociationAsync(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 backupDRClient.PollOnceDeleteBackupPlanAssociationAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlanAssociations/[BACKUP_PLAN_ASSOCIATION]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAssociationAsync(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 backupDRClient.PollOnceDeleteBackupPlanAssociationAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAsync(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 backupDRClient.PollOnceDeleteBackupPlanAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAsync(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 backupDRClient.PollOnceDeleteBackupPlanAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupPlanRequest request = new DeleteBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAsync(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 backupDRClient.PollOnceDeleteBackupPlanAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupPlanRequest request = new DeleteBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAsync(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 backupDRClient.PollOnceDeleteBackupPlanAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAsync(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 backupDRClient.PollOnceDeleteBackupPlanAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupPlanAsync(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 backupDRClient.PollOnceDeleteBackupPlanAsync(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupVaultName name = BackupVaultName.FromProjectLocationBackupvault("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]");
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupVault(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 = backupDRClient.PollOnceDeleteBackupVault(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
DeleteBackupVaultRequest request = new DeleteBackupVaultRequest
{
    BackupVaultName = BackupVaultName.FromProjectLocationBackupvault("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]"),
    RequestId = "",
    Force = false,
    Etag = "",
    ValidateOnly = false,
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupVault(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 = backupDRClient.PollOnceDeleteBackupVault(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]";
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteBackupVault(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 = backupDRClient.PollOnceDeleteBackupVault(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupVaultName name = BackupVaultName.FromProjectLocationBackupvault("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupVaultAsync(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 backupDRClient.PollOnceDeleteBackupVaultAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupVaultName name = BackupVaultName.FromProjectLocationBackupvault("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupVaultAsync(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 backupDRClient.PollOnceDeleteBackupVaultAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupVaultRequest request = new DeleteBackupVaultRequest
{
    BackupVaultName = BackupVaultName.FromProjectLocationBackupvault("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]"),
    RequestId = "",
    Force = false,
    Etag = "",
    ValidateOnly = false,
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupVaultAsync(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 backupDRClient.PollOnceDeleteBackupVaultAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupVaultRequest request = new DeleteBackupVaultRequest
{
    BackupVaultName = BackupVaultName.FromProjectLocationBackupvault("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]"),
    RequestId = "",
    Force = false,
    Etag = "",
    ValidateOnly = false,
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupVaultAsync(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 backupDRClient.PollOnceDeleteBackupVaultAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupVaultAsync(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 backupDRClient.PollOnceDeleteBackupVaultAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteBackupVaultAsync(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 backupDRClient.PollOnceDeleteBackupVaultAsync(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
DeleteManagementServerRequest request = new DeleteManagementServerRequest
{
    ManagementServerName = ManagementServerName.FromProjectLocationManagementserver("[PROJECT]", "[LOCATION]", "[MANAGEMENTSERVER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteManagementServer(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 = backupDRClient.PollOnceDeleteManagementServer(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
ManagementServerName name = ManagementServerName.FromProjectLocationManagementserver("[PROJECT]", "[LOCATION]", "[MANAGEMENTSERVER]");
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteManagementServer(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 = backupDRClient.PollOnceDeleteManagementServer(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/managementServers/[MANAGEMENTSERVER]";
// Make the request
Operation<Empty, OperationMetadata> response = backupDRClient.DeleteManagementServer(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 = backupDRClient.PollOnceDeleteManagementServer(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteManagementServerRequest request = new DeleteManagementServerRequest
{
    ManagementServerName = ManagementServerName.FromProjectLocationManagementserver("[PROJECT]", "[LOCATION]", "[MANAGEMENTSERVER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteManagementServerAsync(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 backupDRClient.PollOnceDeleteManagementServerAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
DeleteManagementServerRequest request = new DeleteManagementServerRequest
{
    ManagementServerName = ManagementServerName.FromProjectLocationManagementserver("[PROJECT]", "[LOCATION]", "[MANAGEMENTSERVER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteManagementServerAsync(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 backupDRClient.PollOnceDeleteManagementServerAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
ManagementServerName name = ManagementServerName.FromProjectLocationManagementserver("[PROJECT]", "[LOCATION]", "[MANAGEMENTSERVER]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteManagementServerAsync(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 backupDRClient.PollOnceDeleteManagementServerAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
ManagementServerName name = ManagementServerName.FromProjectLocationManagementserver("[PROJECT]", "[LOCATION]", "[MANAGEMENTSERVER]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteManagementServerAsync(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 backupDRClient.PollOnceDeleteManagementServerAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/managementServers/[MANAGEMENTSERVER]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteManagementServerAsync(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 backupDRClient.PollOnceDeleteManagementServerAsync(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
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/managementServers/[MANAGEMENTSERVER]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupDRClient.DeleteManagementServerAsync(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 backupDRClient.PollOnceDeleteManagementServerAsync(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
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<FetchUsableBackupVaultsResponse, BackupVault> response = backupDRClient.FetchUsableBackupVaults(parent);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (FetchUsableBackupVaultsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (BackupVault item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<BackupVault> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (BackupVault item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
FetchUsableBackupVaultsRequest request = new FetchUsableBackupVaultsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<FetchUsableBackupVaultsResponse, BackupVault> response = backupDRClient.FetchUsableBackupVaults(request);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (FetchUsableBackupVaultsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (BackupVault item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<BackupVault> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (BackupVault item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<FetchUsableBackupVaultsResponse, BackupVault> response = backupDRClient.FetchUsableBackupVaults(parent);

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

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (FetchUsableBackupVaultsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (BackupVault item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<BackupVault> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (BackupVault item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<FetchUsableBackupVaultsResponse, BackupVault> response = backupDRClient.FetchUsableBackupVaultsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((BackupVault item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((FetchUsableBackupVaultsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (BackupVault item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<BackupVault> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (BackupVault item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
FetchUsableBackupVaultsRequest request = new FetchUsableBackupVaultsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<FetchUsableBackupVaultsResponse, BackupVault> response = backupDRClient.FetchUsableBackupVaultsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((BackupVault item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((FetchUsableBackupVaultsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (BackupVault item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<BackupVault> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (BackupVault item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<FetchUsableBackupVaultsResponse, BackupVault> response = backupDRClient.FetchUsableBackupVaultsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((BackupVault item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((FetchUsableBackupVaultsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (BackupVault item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<BackupVault> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (BackupVault item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]");
// Make the request
Backup response = backupDRClient.GetBackup(name);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]"),
    View = BackupView.Unspecified,
};
// Make the request
Backup response = backupDRClient.GetBackup(request);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]/dataSources/[DATASOURCE]/backups/[BACKUP]";
// Make the request
Backup response = backupDRClient.GetBackup(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]");
// Make the request
Backup response = await backupDRClient.GetBackupAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]");
// Make the request
Backup response = await backupDRClient.GetBackupAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]"),
    View = BackupView.Unspecified,
};
// Make the request
Backup response = await backupDRClient.GetBackupAsync(request);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupvaultDatasourceBackup("[PROJECT]", "[LOCATION]", "[BACKUPVAULT]", "[DATASOURCE]", "[BACKUP]"),
    View = BackupView.Unspecified,
};
// Make the request
Backup response = await backupDRClient.GetBackupAsync(request);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]/dataSources/[DATASOURCE]/backups/[BACKUP]";
// Make the request
Backup response = await backupDRClient.GetBackupAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUPVAULT]/dataSources/[DATASOURCE]/backups/[BACKUP]";
// Make the request
Backup response = await backupDRClient.GetBackupAsync(name);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
BackupPlan response = backupDRClient.GetBackupPlan(name);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
GetBackupPlanRequest request = new GetBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
};
// Make the request
BackupPlan response = backupDRClient.GetBackupPlan(request);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
BackupPlan response = backupDRClient.GetBackupPlan(name);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
BackupPlanAssociationName name = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]");
// Make the request
BackupPlanAssociation response = backupDRClient.GetBackupPlanAssociation(name);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
GetBackupPlanAssociationRequest request = new GetBackupPlanAssociationRequest
{
    BackupPlanAssociationName = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]"),
};
// Make the request
BackupPlanAssociation response = backupDRClient.GetBackupPlanAssociation(request);

// Create client
BackupDRClient backupDRClient = BackupDRClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlanAssociations/[BACKUP_PLAN_ASSOCIATION]";
// Make the request
BackupPlanAssociation response = backupDRClient.GetBackupPlanAssociation(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanAssociationName name = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]");
// Make the request
BackupPlanAssociation response = await backupDRClient.GetBackupPlanAssociationAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanAssociationName name = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]");
// Make the request
BackupPlanAssociation response = await backupDRClient.GetBackupPlanAssociationAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
GetBackupPlanAssociationRequest request = new GetBackupPlanAssociationRequest
{
    BackupPlanAssociationName = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]"),
};
// Make the request
BackupPlanAssociation response = await backupDRClient.GetBackupPlanAssociationAsync(request);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
GetBackupPlanAssociationRequest request = new GetBackupPlanAssociationRequest
{
    BackupPlanAssociationName = BackupPlanAssociationName.FromProjectLocationBackupPlanAssociation("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN_ASSOCIATION]"),
};
// Make the request
BackupPlanAssociation response = await backupDRClient.GetBackupPlanAssociationAsync(request);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlanAssociations/[BACKUP_PLAN_ASSOCIATION]";
// Make the request
BackupPlanAssociation response = await backupDRClient.GetBackupPlanAssociationAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlanAssociations/[BACKUP_PLAN_ASSOCIATION]";
// Make the request
BackupPlanAssociation response = await backupDRClient.GetBackupPlanAssociationAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
BackupPlan response = await backupDRClient.GetBackupPlanAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
BackupPlan response = await backupDRClient.GetBackupPlanAsync(name);

// Create client
BackupDRClient backupDRClient = await BackupDRClient.CreateAsync();
// Initialize request argument(s)
GetBackupPlanRequest request = new GetBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
};
// Make the request
BackupPlan response = await backupDRClient.GetBackupPlanAsync(request);