NetApp v1 API - Class NetAppClient (1.11.0)

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ActiveDirectory activeDirectory = new ActiveDirectory();
string activeDirectoryId = "";
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = netAppClient.CreateActiveDirectory(parent, activeDirectory, activeDirectoryId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateActiveDirectoryRequest request = new CreateActiveDirectoryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ActiveDirectory = new ActiveDirectory(),
    ActiveDirectoryId = "",
};
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = netAppClient.CreateActiveDirectory(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ActiveDirectory activeDirectory = new ActiveDirectory();
string activeDirectoryId = "";
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = netAppClient.CreateActiveDirectory(parent, activeDirectory, activeDirectoryId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ActiveDirectory activeDirectory = new ActiveDirectory();
string activeDirectoryId = "";
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = await netAppClient.CreateActiveDirectoryAsync(parent, activeDirectory, activeDirectoryId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ActiveDirectory activeDirectory = new ActiveDirectory();
string activeDirectoryId = "";
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = await netAppClient.CreateActiveDirectoryAsync(parent, activeDirectory, activeDirectoryId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateActiveDirectoryRequest request = new CreateActiveDirectoryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ActiveDirectory = new ActiveDirectory(),
    ActiveDirectoryId = "",
};
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = await netAppClient.CreateActiveDirectoryAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateActiveDirectoryRequest request = new CreateActiveDirectoryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ActiveDirectory = new ActiveDirectory(),
    ActiveDirectoryId = "",
};
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = await netAppClient.CreateActiveDirectoryAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ActiveDirectory activeDirectory = new ActiveDirectory();
string activeDirectoryId = "";
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = await netAppClient.CreateActiveDirectoryAsync(parent, activeDirectory, activeDirectoryId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ActiveDirectory activeDirectory = new ActiveDirectory();
string activeDirectoryId = "";
// Make the request
Operation<ActiveDirectory, OperationMetadata> response = await netAppClient.CreateActiveDirectoryAsync(parent, activeDirectory, activeDirectoryId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
BackupVaultName parent = BackupVaultName.FromProjectLocationBackupVault("[PROJECT]", "[LOCATION]", "[BACKUP_VAULT]");
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = netAppClient.CreateBackup(parent, backup, backupId);

// 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 = netAppClient.PollOnceCreateBackup(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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateBackupRequest request = new CreateBackupRequest
{
    ParentAsBackupVaultName = BackupVaultName.FromProjectLocationBackupVault("[PROJECT]", "[LOCATION]", "[BACKUP_VAULT]"),
    BackupId = "",
    Backup = new Backup(),
};
// Make the request
Operation<Backup, OperationMetadata> response = netAppClient.CreateBackup(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 = netAppClient.PollOnceCreateBackup(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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUP_VAULT]";
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = netAppClient.CreateBackup(parent, backup, backupId);

// 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 = netAppClient.PollOnceCreateBackup(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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
BackupVaultName parent = BackupVaultName.FromProjectLocationBackupVault("[PROJECT]", "[LOCATION]", "[BACKUP_VAULT]");
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await netAppClient.CreateBackupAsync(parent, backup, backupId);

// 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 netAppClient.PollOnceCreateBackupAsync(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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
BackupVaultName parent = BackupVaultName.FromProjectLocationBackupVault("[PROJECT]", "[LOCATION]", "[BACKUP_VAULT]");
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await netAppClient.CreateBackupAsync(parent, backup, backupId);

// 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 netAppClient.PollOnceCreateBackupAsync(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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateBackupRequest request = new CreateBackupRequest
{
    ParentAsBackupVaultName = BackupVaultName.FromProjectLocationBackupVault("[PROJECT]", "[LOCATION]", "[BACKUP_VAULT]"),
    BackupId = "",
    Backup = new Backup(),
};
// Make the request
Operation<Backup, OperationMetadata> response = await netAppClient.CreateBackupAsync(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 netAppClient.PollOnceCreateBackupAsync(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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateBackupRequest request = new CreateBackupRequest
{
    ParentAsBackupVaultName = BackupVaultName.FromProjectLocationBackupVault("[PROJECT]", "[LOCATION]", "[BACKUP_VAULT]"),
    BackupId = "",
    Backup = new Backup(),
};
// Make the request
Operation<Backup, OperationMetadata> response = await netAppClient.CreateBackupAsync(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 netAppClient.PollOnceCreateBackupAsync(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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUP_VAULT]";
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await netAppClient.CreateBackupAsync(parent, backup, backupId);

// 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 netAppClient.PollOnceCreateBackupAsync(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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/backupVaults/[BACKUP_VAULT]";
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await netAppClient.CreateBackupAsync(parent, backup, backupId);

// 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 netAppClient.PollOnceCreateBackupAsync(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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPolicy backupPolicy = new BackupPolicy();
string backupPolicyId = "";
// Make the request
Operation<BackupPolicy, OperationMetadata> response = netAppClient.CreateBackupPolicy(parent, backupPolicy, backupPolicyId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateBackupPolicyRequest request = new CreateBackupPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPolicy = new BackupPolicy(),
    BackupPolicyId = "",
};
// Make the request
Operation<BackupPolicy, OperationMetadata> response = netAppClient.CreateBackupPolicy(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPolicy backupPolicy = new BackupPolicy();
string backupPolicyId = "";
// Make the request
Operation<BackupPolicy, OperationMetadata> response = netAppClient.CreateBackupPolicy(parent, backupPolicy, backupPolicyId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPolicy backupPolicy = new BackupPolicy();
string backupPolicyId = "";
// Make the request
Operation<BackupPolicy, OperationMetadata> response = await netAppClient.CreateBackupPolicyAsync(parent, backupPolicy, backupPolicyId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPolicy backupPolicy = new BackupPolicy();
string backupPolicyId = "";
// Make the request
Operation<BackupPolicy, OperationMetadata> response = await netAppClient.CreateBackupPolicyAsync(parent, backupPolicy, backupPolicyId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPolicyRequest request = new CreateBackupPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPolicy = new BackupPolicy(),
    BackupPolicyId = "",
};
// Make the request
Operation<BackupPolicy, OperationMetadata> response = await netAppClient.CreateBackupPolicyAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPolicyRequest request = new CreateBackupPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPolicy = new BackupPolicy(),
    BackupPolicyId = "",
};
// Make the request
Operation<BackupPolicy, OperationMetadata> response = await netAppClient.CreateBackupPolicyAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPolicy backupPolicy = new BackupPolicy();
string backupPolicyId = "";
// Make the request
Operation<BackupPolicy, OperationMetadata> response = await netAppClient.CreateBackupPolicyAsync(parent, backupPolicy, backupPolicyId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPolicy backupPolicy = new BackupPolicy();
string backupPolicyId = "";
// Make the request
Operation<BackupPolicy, OperationMetadata> response = await netAppClient.CreateBackupPolicyAsync(parent, backupPolicy, backupPolicyId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = netAppClient.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 = netAppClient.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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateBackupVaultRequest request = new CreateBackupVaultRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupVaultId = "",
    BackupVault = new BackupVault(),
};
// Make the request
Operation<BackupVault, OperationMetadata> response = netAppClient.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 = netAppClient.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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupVault backupVault = new BackupVault();
string backupVaultId = "";
// Make the request
Operation<BackupVault, OperationMetadata> response = netAppClient.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 = netAppClient.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
NetAppClient netAppClient = await NetAppClient.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 netAppClient.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 netAppClient.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
NetAppClient netAppClient = await NetAppClient.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 netAppClient.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 netAppClient.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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateBackupVaultRequest request = new CreateBackupVaultRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupVaultId = "",
    BackupVault = new BackupVault(),
};
// Make the request
Operation<BackupVault, OperationMetadata> response = await netAppClient.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 netAppClient.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
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateBackupVaultRequest request = new CreateBackupVaultRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupVaultId = "",
    BackupVault = new BackupVault(),
};
// Make the request
Operation<BackupVault, OperationMetadata> response = await netAppClient.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 netAppClient.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
NetAppClient netAppClient = await NetAppClient.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 netAppClient.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 netAppClient.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
NetAppClient netAppClient = await NetAppClient.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 netAppClient.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 netAppClient.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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
KmsConfig kmsConfig = new KmsConfig();
string kmsConfigId = "";
// Make the request
Operation<KmsConfig, OperationMetadata> response = netAppClient.CreateKmsConfig(parent, kmsConfig, kmsConfigId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateKmsConfigRequest request = new CreateKmsConfigRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    KmsConfigId = "",
    KmsConfig = new KmsConfig(),
};
// Make the request
Operation<KmsConfig, OperationMetadata> response = netAppClient.CreateKmsConfig(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
KmsConfig kmsConfig = new KmsConfig();
string kmsConfigId = "";
// Make the request
Operation<KmsConfig, OperationMetadata> response = netAppClient.CreateKmsConfig(parent, kmsConfig, kmsConfigId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
KmsConfig kmsConfig = new KmsConfig();
string kmsConfigId = "";
// Make the request
Operation<KmsConfig, OperationMetadata> response = await netAppClient.CreateKmsConfigAsync(parent, kmsConfig, kmsConfigId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
KmsConfig kmsConfig = new KmsConfig();
string kmsConfigId = "";
// Make the request
Operation<KmsConfig, OperationMetadata> response = await netAppClient.CreateKmsConfigAsync(parent, kmsConfig, kmsConfigId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateKmsConfigRequest request = new CreateKmsConfigRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    KmsConfigId = "",
    KmsConfig = new KmsConfig(),
};
// Make the request
Operation<KmsConfig, OperationMetadata> response = await netAppClient.CreateKmsConfigAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateKmsConfigRequest request = new CreateKmsConfigRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    KmsConfigId = "",
    KmsConfig = new KmsConfig(),
};
// Make the request
Operation<KmsConfig, OperationMetadata> response = await netAppClient.CreateKmsConfigAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
KmsConfig kmsConfig = new KmsConfig();
string kmsConfigId = "";
// Make the request
Operation<KmsConfig, OperationMetadata> response = await netAppClient.CreateKmsConfigAsync(parent, kmsConfig, kmsConfigId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
KmsConfig kmsConfig = new KmsConfig();
string kmsConfigId = "";
// Make the request
Operation<KmsConfig, OperationMetadata> response = await netAppClient.CreateKmsConfigAsync(parent, kmsConfig, kmsConfigId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateQuotaRuleRequest request = new CreateQuotaRuleRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    QuotaRule = new QuotaRule(),
    QuotaRuleId = "",
};
// Make the request
Operation<QuotaRule, OperationMetadata> response = netAppClient.CreateQuotaRule(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
QuotaRule quotaRule = new QuotaRule();
string quotaRuleId = "";
// Make the request
Operation<QuotaRule, OperationMetadata> response = netAppClient.CreateQuotaRule(parent, quotaRule, quotaRuleId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
QuotaRule quotaRule = new QuotaRule();
string quotaRuleId = "";
// Make the request
Operation<QuotaRule, OperationMetadata> response = netAppClient.CreateQuotaRule(parent, quotaRule, quotaRuleId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateQuotaRuleRequest request = new CreateQuotaRuleRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    QuotaRule = new QuotaRule(),
    QuotaRuleId = "",
};
// Make the request
Operation<QuotaRule, OperationMetadata> response = await netAppClient.CreateQuotaRuleAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateQuotaRuleRequest request = new CreateQuotaRuleRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    QuotaRule = new QuotaRule(),
    QuotaRuleId = "",
};
// Make the request
Operation<QuotaRule, OperationMetadata> response = await netAppClient.CreateQuotaRuleAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
QuotaRule quotaRule = new QuotaRule();
string quotaRuleId = "";
// Make the request
Operation<QuotaRule, OperationMetadata> response = await netAppClient.CreateQuotaRuleAsync(parent, quotaRule, quotaRuleId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
QuotaRule quotaRule = new QuotaRule();
string quotaRuleId = "";
// Make the request
Operation<QuotaRule, OperationMetadata> response = await netAppClient.CreateQuotaRuleAsync(parent, quotaRule, quotaRuleId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
QuotaRule quotaRule = new QuotaRule();
string quotaRuleId = "";
// Make the request
Operation<QuotaRule, OperationMetadata> response = await netAppClient.CreateQuotaRuleAsync(parent, quotaRule, quotaRuleId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
QuotaRule quotaRule = new QuotaRule();
string quotaRuleId = "";
// Make the request
Operation<QuotaRule, OperationMetadata> response = await netAppClient.CreateQuotaRuleAsync(parent, quotaRule, quotaRuleId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateReplicationRequest request = new CreateReplicationRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    Replication = new Replication(),
    ReplicationId = "",
};
// Make the request
Operation<Replication, OperationMetadata> response = netAppClient.CreateReplication(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
Replication replication = new Replication();
string replicationId = "";
// Make the request
Operation<Replication, OperationMetadata> response = netAppClient.CreateReplication(parent, replication, replicationId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
Replication replication = new Replication();
string replicationId = "";
// Make the request
Operation<Replication, OperationMetadata> response = netAppClient.CreateReplication(parent, replication, replicationId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateReplicationRequest request = new CreateReplicationRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    Replication = new Replication(),
    ReplicationId = "",
};
// Make the request
Operation<Replication, OperationMetadata> response = await netAppClient.CreateReplicationAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateReplicationRequest request = new CreateReplicationRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    Replication = new Replication(),
    ReplicationId = "",
};
// Make the request
Operation<Replication, OperationMetadata> response = await netAppClient.CreateReplicationAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
Replication replication = new Replication();
string replicationId = "";
// Make the request
Operation<Replication, OperationMetadata> response = await netAppClient.CreateReplicationAsync(parent, replication, replicationId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
Replication replication = new Replication();
string replicationId = "";
// Make the request
Operation<Replication, OperationMetadata> response = await netAppClient.CreateReplicationAsync(parent, replication, replicationId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
Replication replication = new Replication();
string replicationId = "";
// Make the request
Operation<Replication, OperationMetadata> response = await netAppClient.CreateReplicationAsync(parent, replication, replicationId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
Replication replication = new Replication();
string replicationId = "";
// Make the request
Operation<Replication, OperationMetadata> response = await netAppClient.CreateReplicationAsync(parent, replication, replicationId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateSnapshotRequest request = new CreateSnapshotRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    Snapshot = new Snapshot(),
    SnapshotId = "",
};
// Make the request
Operation<Snapshot, OperationMetadata> response = netAppClient.CreateSnapshot(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
Snapshot snapshot = new Snapshot();
string snapshotId = "";
// Make the request
Operation<Snapshot, OperationMetadata> response = netAppClient.CreateSnapshot(parent, snapshot, snapshotId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
Snapshot snapshot = new Snapshot();
string snapshotId = "";
// Make the request
Operation<Snapshot, OperationMetadata> response = netAppClient.CreateSnapshot(parent, snapshot, snapshotId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateSnapshotRequest request = new CreateSnapshotRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    Snapshot = new Snapshot(),
    SnapshotId = "",
};
// Make the request
Operation<Snapshot, OperationMetadata> response = await netAppClient.CreateSnapshotAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateSnapshotRequest request = new CreateSnapshotRequest
{
    ParentAsVolumeName = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]"),
    Snapshot = new Snapshot(),
    SnapshotId = "",
};
// Make the request
Operation<Snapshot, OperationMetadata> response = await netAppClient.CreateSnapshotAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
Snapshot snapshot = new Snapshot();
string snapshotId = "";
// Make the request
Operation<Snapshot, OperationMetadata> response = await netAppClient.CreateSnapshotAsync(parent, snapshot, snapshotId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
VolumeName parent = VolumeName.FromProjectLocationVolume("[PROJECT]", "[LOCATION]", "[VOLUME]");
Snapshot snapshot = new Snapshot();
string snapshotId = "";
// Make the request
Operation<Snapshot, OperationMetadata> response = await netAppClient.CreateSnapshotAsync(parent, snapshot, snapshotId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
Snapshot snapshot = new Snapshot();
string snapshotId = "";
// Make the request
Operation<Snapshot, OperationMetadata> response = await netAppClient.CreateSnapshotAsync(parent, snapshot, snapshotId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/volumes/[VOLUME]";
Snapshot snapshot = new Snapshot();
string snapshotId = "";
// Make the request
Operation<Snapshot, OperationMetadata> response = await netAppClient.CreateSnapshotAsync(parent, snapshot, snapshotId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
StoragePool storagePool = new StoragePool();
string storagePoolId = "";
// Make the request
Operation<StoragePool, OperationMetadata> response = netAppClient.CreateStoragePool(parent, storagePool, storagePoolId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateStoragePoolRequest request = new CreateStoragePoolRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    StoragePoolId = "",
    StoragePool = new StoragePool(),
};
// Make the request
Operation<StoragePool, OperationMetadata> response = netAppClient.CreateStoragePool(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
StoragePool storagePool = new StoragePool();
string storagePoolId = "";
// Make the request
Operation<StoragePool, OperationMetadata> response = netAppClient.CreateStoragePool(parent, storagePool, storagePoolId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
StoragePool storagePool = new StoragePool();
string storagePoolId = "";
// Make the request
Operation<StoragePool, OperationMetadata> response = await netAppClient.CreateStoragePoolAsync(parent, storagePool, storagePoolId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
StoragePool storagePool = new StoragePool();
string storagePoolId = "";
// Make the request
Operation<StoragePool, OperationMetadata> response = await netAppClient.CreateStoragePoolAsync(parent, storagePool, storagePoolId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateStoragePoolRequest request = new CreateStoragePoolRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    StoragePoolId = "",
    StoragePool = new StoragePool(),
};
// Make the request
Operation<StoragePool, OperationMetadata> response = await netAppClient.CreateStoragePoolAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateStoragePoolRequest request = new CreateStoragePoolRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    StoragePoolId = "",
    StoragePool = new StoragePool(),
};
// Make the request
Operation<StoragePool, OperationMetadata> response = await netAppClient.CreateStoragePoolAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
StoragePool storagePool = new StoragePool();
string storagePoolId = "";
// Make the request
Operation<StoragePool, OperationMetadata> response = await netAppClient.CreateStoragePoolAsync(parent, storagePool, storagePoolId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
StoragePool storagePool = new StoragePool();
string storagePoolId = "";
// Make the request
Operation<StoragePool, OperationMetadata> response = await netAppClient.CreateStoragePoolAsync(parent, storagePool, storagePoolId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Volume volume = new Volume();
string volumeId = "";
// Make the request
Operation<Volume, OperationMetadata> response = netAppClient.CreateVolume(parent, volume, volumeId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
CreateVolumeRequest request = new CreateVolumeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    VolumeId = "",
    Volume = new Volume(),
};
// Make the request
Operation<Volume, OperationMetadata> response = netAppClient.CreateVolume(request);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Volume volume = new Volume();
string volumeId = "";
// Make the request
Operation<Volume, OperationMetadata> response = netAppClient.CreateVolume(parent, volume, volumeId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Volume volume = new Volume();
string volumeId = "";
// Make the request
Operation<Volume, OperationMetadata> response = await netAppClient.CreateVolumeAsync(parent, volume, volumeId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Volume volume = new Volume();
string volumeId = "";
// Make the request
Operation<Volume, OperationMetadata> response = await netAppClient.CreateVolumeAsync(parent, volume, volumeId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateVolumeRequest request = new CreateVolumeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    VolumeId = "",
    Volume = new Volume(),
};
// Make the request
Operation<Volume, OperationMetadata> response = await netAppClient.CreateVolumeAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
CreateVolumeRequest request = new CreateVolumeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    VolumeId = "",
    Volume = new Volume(),
};
// Make the request
Operation<Volume, OperationMetadata> response = await netAppClient.CreateVolumeAsync(request);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Volume volume = new Volume();
string volumeId = "";
// Make the request
Operation<Volume, OperationMetadata> response = await netAppClient.CreateVolumeAsync(parent, volume, volumeId);

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

// Create client
NetAppClient netAppClient = await NetAppClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Volume volume = new Volume();
string volumeId = "";
// Make the request
Operation<Volume, OperationMetadata> response = await netAppClient.CreateVolumeAsync(parent, volume, volumeId);

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

// Create client
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
ActiveDirectoryName name = ActiveDirectoryName.FromProjectLocationActiveDirectory("[PROJECT]", "[LOCATION]", "[ACTIVE_DIRECTORY]");
// Make the request
Operation<Empty, OperationMetadata> response = netAppClient.DeleteActiveDirectory(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 = netAppClient.PollOnceDeleteActiveDirectory(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
NetAppClient netAppClient = NetAppClient.Create();
// Initialize request argument(s)
DeleteActiveDirectoryRequest request = new DeleteActiveDirectoryRequest
{
    ActiveDirectoryName = ActiveDirectoryName.FromProjectLocationActiveDirectory("[PROJECT]", "[LOCATION]", "[ACTIVE_DIRECTORY]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = netAppClient.DeleteActiveDirectory(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 = netAppClient.PollOnceDeleteActiveDirectory(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;
}