Oracle Database@Google Cloud v1 API - Class OracleDatabaseClient (1.0.0-beta01)

public abstract class OracleDatabaseClient

Namespace

Assembly

Google.Cloud.OracleDatabase.V1.dll

Remarks

Properties

CreateAutonomousDatabaseOperationsClient

public virtual OperationsClient CreateAutonomousDatabaseOperationsClient { get; }

CreateCloudExadataInfrastructureOperationsClient

public virtual OperationsClient CreateCloudExadataInfrastructureOperationsClient { get; }

CreateCloudVmClusterOperationsClient

public virtual OperationsClient CreateCloudVmClusterOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteAutonomousDatabaseOperationsClient

public virtual OperationsClient DeleteAutonomousDatabaseOperationsClient { get; }

DeleteCloudExadataInfrastructureOperationsClient

public virtual OperationsClient DeleteCloudExadataInfrastructureOperationsClient { get; }

DeleteCloudVmClusterOperationsClient

public virtual OperationsClient DeleteCloudVmClusterOperationsClient { get; }

GrpcClient

public virtual OracleDatabase.OracleDatabaseClient GrpcClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

RestoreAutonomousDatabaseOperationsClient

public virtual OperationsClient RestoreAutonomousDatabaseOperationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

Methods

Create()

public static OracleDatabaseClient Create()

CreateAsync(CancellationToken)

public static Task<OracleDatabaseClient> CreateAsync(CancellationToken cancellationToken = default)

CreateAutonomousDatabase(LocationName, AutonomousDatabase, string, CallSettings)

public virtual Operation<AutonomousDatabase, OperationMetadata> CreateAutonomousDatabase(LocationName parent, AutonomousDatabase autonomousDatabase, string autonomousDatabaseId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AutonomousDatabase autonomousDatabase = new AutonomousDatabase();
string autonomousDatabaseId = "";
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = oracleDatabaseClient.CreateAutonomousDatabase(parent, autonomousDatabase, autonomousDatabaseId);

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

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

CreateAutonomousDatabase(CreateAutonomousDatabaseRequest, CallSettings)

public virtual Operation<AutonomousDatabase, OperationMetadata> CreateAutonomousDatabase(CreateAutonomousDatabaseRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CreateAutonomousDatabaseRequest request = new CreateAutonomousDatabaseRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AutonomousDatabaseId = "",
    AutonomousDatabase = new AutonomousDatabase(),
    RequestId = "",
};
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = oracleDatabaseClient.CreateAutonomousDatabase(request);

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

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

CreateAutonomousDatabase(string, AutonomousDatabase, string, CallSettings)

public virtual Operation<AutonomousDatabase, OperationMetadata> CreateAutonomousDatabase(string parent, AutonomousDatabase autonomousDatabase, string autonomousDatabaseId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AutonomousDatabase autonomousDatabase = new AutonomousDatabase();
string autonomousDatabaseId = "";
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = oracleDatabaseClient.CreateAutonomousDatabase(parent, autonomousDatabase, autonomousDatabaseId);

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

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

CreateAutonomousDatabaseAsync(LocationName, AutonomousDatabase, string, CallSettings)

public virtual Task<Operation<AutonomousDatabase, OperationMetadata>> CreateAutonomousDatabaseAsync(LocationName parent, AutonomousDatabase autonomousDatabase, string autonomousDatabaseId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AutonomousDatabase autonomousDatabase = new AutonomousDatabase();
string autonomousDatabaseId = "";
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = await oracleDatabaseClient.CreateAutonomousDatabaseAsync(parent, autonomousDatabase, autonomousDatabaseId);

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

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

CreateAutonomousDatabaseAsync(LocationName, AutonomousDatabase, string, CancellationToken)

public virtual Task<Operation<AutonomousDatabase, OperationMetadata>> CreateAutonomousDatabaseAsync(LocationName parent, AutonomousDatabase autonomousDatabase, string autonomousDatabaseId, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AutonomousDatabase autonomousDatabase = new AutonomousDatabase();
string autonomousDatabaseId = "";
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = await oracleDatabaseClient.CreateAutonomousDatabaseAsync(parent, autonomousDatabase, autonomousDatabaseId);

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

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

CreateAutonomousDatabaseAsync(CreateAutonomousDatabaseRequest, CallSettings)

public virtual Task<Operation<AutonomousDatabase, OperationMetadata>> CreateAutonomousDatabaseAsync(CreateAutonomousDatabaseRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CreateAutonomousDatabaseRequest request = new CreateAutonomousDatabaseRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AutonomousDatabaseId = "",
    AutonomousDatabase = new AutonomousDatabase(),
    RequestId = "",
};
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = await oracleDatabaseClient.CreateAutonomousDatabaseAsync(request);

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

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

CreateAutonomousDatabaseAsync(CreateAutonomousDatabaseRequest, CancellationToken)

public virtual Task<Operation<AutonomousDatabase, OperationMetadata>> CreateAutonomousDatabaseAsync(CreateAutonomousDatabaseRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CreateAutonomousDatabaseRequest request = new CreateAutonomousDatabaseRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AutonomousDatabaseId = "",
    AutonomousDatabase = new AutonomousDatabase(),
    RequestId = "",
};
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = await oracleDatabaseClient.CreateAutonomousDatabaseAsync(request);

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

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

CreateAutonomousDatabaseAsync(string, AutonomousDatabase, string, CallSettings)

public virtual Task<Operation<AutonomousDatabase, OperationMetadata>> CreateAutonomousDatabaseAsync(string parent, AutonomousDatabase autonomousDatabase, string autonomousDatabaseId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AutonomousDatabase autonomousDatabase = new AutonomousDatabase();
string autonomousDatabaseId = "";
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = await oracleDatabaseClient.CreateAutonomousDatabaseAsync(parent, autonomousDatabase, autonomousDatabaseId);

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

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

CreateAutonomousDatabaseAsync(string, AutonomousDatabase, string, CancellationToken)

public virtual Task<Operation<AutonomousDatabase, OperationMetadata>> CreateAutonomousDatabaseAsync(string parent, AutonomousDatabase autonomousDatabase, string autonomousDatabaseId, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AutonomousDatabase autonomousDatabase = new AutonomousDatabase();
string autonomousDatabaseId = "";
// Make the request
Operation<AutonomousDatabase, OperationMetadata> response = await oracleDatabaseClient.CreateAutonomousDatabaseAsync(parent, autonomousDatabase, autonomousDatabaseId);

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

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

CreateCloudExadataInfrastructure(LocationName, CloudExadataInfrastructure, string, CallSettings)

public virtual Operation<CloudExadataInfrastructure, OperationMetadata> CreateCloudExadataInfrastructure(LocationName parent, CloudExadataInfrastructure cloudExadataInfrastructure, string cloudExadataInfrastructureId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CloudExadataInfrastructure cloudExadataInfrastructure = new CloudExadataInfrastructure();
string cloudExadataInfrastructureId = "";
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = oracleDatabaseClient.CreateCloudExadataInfrastructure(parent, cloudExadataInfrastructure, cloudExadataInfrastructureId);

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

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

CreateCloudExadataInfrastructure(CreateCloudExadataInfrastructureRequest, CallSettings)

public virtual Operation<CloudExadataInfrastructure, OperationMetadata> CreateCloudExadataInfrastructure(CreateCloudExadataInfrastructureRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CreateCloudExadataInfrastructureRequest request = new CreateCloudExadataInfrastructureRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CloudExadataInfrastructureId = "",
    CloudExadataInfrastructure = new CloudExadataInfrastructure(),
    RequestId = "",
};
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = oracleDatabaseClient.CreateCloudExadataInfrastructure(request);

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

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

CreateCloudExadataInfrastructure(string, CloudExadataInfrastructure, string, CallSettings)

public virtual Operation<CloudExadataInfrastructure, OperationMetadata> CreateCloudExadataInfrastructure(string parent, CloudExadataInfrastructure cloudExadataInfrastructure, string cloudExadataInfrastructureId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CloudExadataInfrastructure cloudExadataInfrastructure = new CloudExadataInfrastructure();
string cloudExadataInfrastructureId = "";
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = oracleDatabaseClient.CreateCloudExadataInfrastructure(parent, cloudExadataInfrastructure, cloudExadataInfrastructureId);

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

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

CreateCloudExadataInfrastructureAsync(LocationName, CloudExadataInfrastructure, string, CallSettings)

public virtual Task<Operation<CloudExadataInfrastructure, OperationMetadata>> CreateCloudExadataInfrastructureAsync(LocationName parent, CloudExadataInfrastructure cloudExadataInfrastructure, string cloudExadataInfrastructureId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CloudExadataInfrastructure cloudExadataInfrastructure = new CloudExadataInfrastructure();
string cloudExadataInfrastructureId = "";
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = await oracleDatabaseClient.CreateCloudExadataInfrastructureAsync(parent, cloudExadataInfrastructure, cloudExadataInfrastructureId);

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

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

CreateCloudExadataInfrastructureAsync(LocationName, CloudExadataInfrastructure, string, CancellationToken)

public virtual Task<Operation<CloudExadataInfrastructure, OperationMetadata>> CreateCloudExadataInfrastructureAsync(LocationName parent, CloudExadataInfrastructure cloudExadataInfrastructure, string cloudExadataInfrastructureId, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CloudExadataInfrastructure cloudExadataInfrastructure = new CloudExadataInfrastructure();
string cloudExadataInfrastructureId = "";
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = await oracleDatabaseClient.CreateCloudExadataInfrastructureAsync(parent, cloudExadataInfrastructure, cloudExadataInfrastructureId);

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

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

CreateCloudExadataInfrastructureAsync(CreateCloudExadataInfrastructureRequest, CallSettings)

public virtual Task<Operation<CloudExadataInfrastructure, OperationMetadata>> CreateCloudExadataInfrastructureAsync(CreateCloudExadataInfrastructureRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CreateCloudExadataInfrastructureRequest request = new CreateCloudExadataInfrastructureRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CloudExadataInfrastructureId = "",
    CloudExadataInfrastructure = new CloudExadataInfrastructure(),
    RequestId = "",
};
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = await oracleDatabaseClient.CreateCloudExadataInfrastructureAsync(request);

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

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

CreateCloudExadataInfrastructureAsync(CreateCloudExadataInfrastructureRequest, CancellationToken)

public virtual Task<Operation<CloudExadataInfrastructure, OperationMetadata>> CreateCloudExadataInfrastructureAsync(CreateCloudExadataInfrastructureRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CreateCloudExadataInfrastructureRequest request = new CreateCloudExadataInfrastructureRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CloudExadataInfrastructureId = "",
    CloudExadataInfrastructure = new CloudExadataInfrastructure(),
    RequestId = "",
};
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = await oracleDatabaseClient.CreateCloudExadataInfrastructureAsync(request);

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

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

CreateCloudExadataInfrastructureAsync(string, CloudExadataInfrastructure, string, CallSettings)

public virtual Task<Operation<CloudExadataInfrastructure, OperationMetadata>> CreateCloudExadataInfrastructureAsync(string parent, CloudExadataInfrastructure cloudExadataInfrastructure, string cloudExadataInfrastructureId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CloudExadataInfrastructure cloudExadataInfrastructure = new CloudExadataInfrastructure();
string cloudExadataInfrastructureId = "";
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = await oracleDatabaseClient.CreateCloudExadataInfrastructureAsync(parent, cloudExadataInfrastructure, cloudExadataInfrastructureId);

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

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

CreateCloudExadataInfrastructureAsync(string, CloudExadataInfrastructure, string, CancellationToken)

public virtual Task<Operation<CloudExadataInfrastructure, OperationMetadata>> CreateCloudExadataInfrastructureAsync(string parent, CloudExadataInfrastructure cloudExadataInfrastructure, string cloudExadataInfrastructureId, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CloudExadataInfrastructure cloudExadataInfrastructure = new CloudExadataInfrastructure();
string cloudExadataInfrastructureId = "";
// Make the request
Operation<CloudExadataInfrastructure, OperationMetadata> response = await oracleDatabaseClient.CreateCloudExadataInfrastructureAsync(parent, cloudExadataInfrastructure, cloudExadataInfrastructureId);

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

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

CreateCloudVmCluster(LocationName, CloudVmCluster, string, CallSettings)

public virtual Operation<CloudVmCluster, OperationMetadata> CreateCloudVmCluster(LocationName parent, CloudVmCluster cloudVmCluster, string cloudVmClusterId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CloudVmCluster cloudVmCluster = new CloudVmCluster();
string cloudVmClusterId = "";
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = oracleDatabaseClient.CreateCloudVmCluster(parent, cloudVmCluster, cloudVmClusterId);

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

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

CreateCloudVmCluster(CreateCloudVmClusterRequest, CallSettings)

public virtual Operation<CloudVmCluster, OperationMetadata> CreateCloudVmCluster(CreateCloudVmClusterRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CreateCloudVmClusterRequest request = new CreateCloudVmClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CloudVmClusterId = "",
    CloudVmCluster = new CloudVmCluster(),
    RequestId = "",
};
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = oracleDatabaseClient.CreateCloudVmCluster(request);

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

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

CreateCloudVmCluster(string, CloudVmCluster, string, CallSettings)

public virtual Operation<CloudVmCluster, OperationMetadata> CreateCloudVmCluster(string parent, CloudVmCluster cloudVmCluster, string cloudVmClusterId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CloudVmCluster cloudVmCluster = new CloudVmCluster();
string cloudVmClusterId = "";
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = oracleDatabaseClient.CreateCloudVmCluster(parent, cloudVmCluster, cloudVmClusterId);

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

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

CreateCloudVmClusterAsync(LocationName, CloudVmCluster, string, CallSettings)

public virtual Task<Operation<CloudVmCluster, OperationMetadata>> CreateCloudVmClusterAsync(LocationName parent, CloudVmCluster cloudVmCluster, string cloudVmClusterId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CloudVmCluster cloudVmCluster = new CloudVmCluster();
string cloudVmClusterId = "";
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = await oracleDatabaseClient.CreateCloudVmClusterAsync(parent, cloudVmCluster, cloudVmClusterId);

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

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

CreateCloudVmClusterAsync(LocationName, CloudVmCluster, string, CancellationToken)

public virtual Task<Operation<CloudVmCluster, OperationMetadata>> CreateCloudVmClusterAsync(LocationName parent, CloudVmCluster cloudVmCluster, string cloudVmClusterId, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
CloudVmCluster cloudVmCluster = new CloudVmCluster();
string cloudVmClusterId = "";
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = await oracleDatabaseClient.CreateCloudVmClusterAsync(parent, cloudVmCluster, cloudVmClusterId);

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

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

CreateCloudVmClusterAsync(CreateCloudVmClusterRequest, CallSettings)

public virtual Task<Operation<CloudVmCluster, OperationMetadata>> CreateCloudVmClusterAsync(CreateCloudVmClusterRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CreateCloudVmClusterRequest request = new CreateCloudVmClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CloudVmClusterId = "",
    CloudVmCluster = new CloudVmCluster(),
    RequestId = "",
};
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = await oracleDatabaseClient.CreateCloudVmClusterAsync(request);

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

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

CreateCloudVmClusterAsync(CreateCloudVmClusterRequest, CancellationToken)

public virtual Task<Operation<CloudVmCluster, OperationMetadata>> CreateCloudVmClusterAsync(CreateCloudVmClusterRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CreateCloudVmClusterRequest request = new CreateCloudVmClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CloudVmClusterId = "",
    CloudVmCluster = new CloudVmCluster(),
    RequestId = "",
};
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = await oracleDatabaseClient.CreateCloudVmClusterAsync(request);

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

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

CreateCloudVmClusterAsync(string, CloudVmCluster, string, CallSettings)

public virtual Task<Operation<CloudVmCluster, OperationMetadata>> CreateCloudVmClusterAsync(string parent, CloudVmCluster cloudVmCluster, string cloudVmClusterId, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CloudVmCluster cloudVmCluster = new CloudVmCluster();
string cloudVmClusterId = "";
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = await oracleDatabaseClient.CreateCloudVmClusterAsync(parent, cloudVmCluster, cloudVmClusterId);

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

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

CreateCloudVmClusterAsync(string, CloudVmCluster, string, CancellationToken)

public virtual Task<Operation<CloudVmCluster, OperationMetadata>> CreateCloudVmClusterAsync(string parent, CloudVmCluster cloudVmCluster, string cloudVmClusterId, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
CloudVmCluster cloudVmCluster = new CloudVmCluster();
string cloudVmClusterId = "";
// Make the request
Operation<CloudVmCluster, OperationMetadata> response = await oracleDatabaseClient.CreateCloudVmClusterAsync(parent, cloudVmCluster, cloudVmClusterId);

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

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

DeleteAutonomousDatabase(AutonomousDatabaseName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAutonomousDatabase(AutonomousDatabaseName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteAutonomousDatabase(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 = oracleDatabaseClient.PollOnceDeleteAutonomousDatabase(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;
}

DeleteAutonomousDatabase(DeleteAutonomousDatabaseRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAutonomousDatabase(DeleteAutonomousDatabaseRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
DeleteAutonomousDatabaseRequest request = new DeleteAutonomousDatabaseRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteAutonomousDatabase(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 = oracleDatabaseClient.PollOnceDeleteAutonomousDatabase(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;
}

DeleteAutonomousDatabase(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAutonomousDatabase(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteAutonomousDatabase(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 = oracleDatabaseClient.PollOnceDeleteAutonomousDatabase(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;
}

DeleteAutonomousDatabaseAsync(AutonomousDatabaseName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAutonomousDatabaseAsync(AutonomousDatabaseName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteAutonomousDatabaseAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteAutonomousDatabaseAsync(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;
}

DeleteAutonomousDatabaseAsync(AutonomousDatabaseName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAutonomousDatabaseAsync(AutonomousDatabaseName name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteAutonomousDatabaseAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteAutonomousDatabaseAsync(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;
}

DeleteAutonomousDatabaseAsync(DeleteAutonomousDatabaseRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAutonomousDatabaseAsync(DeleteAutonomousDatabaseRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
DeleteAutonomousDatabaseRequest request = new DeleteAutonomousDatabaseRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteAutonomousDatabaseAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteAutonomousDatabaseAsync(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;
}

DeleteAutonomousDatabaseAsync(DeleteAutonomousDatabaseRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAutonomousDatabaseAsync(DeleteAutonomousDatabaseRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
DeleteAutonomousDatabaseRequest request = new DeleteAutonomousDatabaseRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteAutonomousDatabaseAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteAutonomousDatabaseAsync(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;
}

DeleteAutonomousDatabaseAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAutonomousDatabaseAsync(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteAutonomousDatabaseAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteAutonomousDatabaseAsync(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;
}

DeleteAutonomousDatabaseAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAutonomousDatabaseAsync(string name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteAutonomousDatabaseAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteAutonomousDatabaseAsync(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;
}

DeleteCloudExadataInfrastructure(CloudExadataInfrastructureName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteCloudExadataInfrastructure(CloudExadataInfrastructureName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CloudExadataInfrastructureName name = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]");
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteCloudExadataInfrastructure(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 = oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructure(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;
}

DeleteCloudExadataInfrastructure(DeleteCloudExadataInfrastructureRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteCloudExadataInfrastructure(DeleteCloudExadataInfrastructureRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
DeleteCloudExadataInfrastructureRequest request = new DeleteCloudExadataInfrastructureRequest
{
    CloudExadataInfrastructureName = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteCloudExadataInfrastructure(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 = oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructure(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;
}

DeleteCloudExadataInfrastructure(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteCloudExadataInfrastructure(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudExadataInfrastructures/[CLOUD_EXADATA_INFRASTRUCTURE]";
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteCloudExadataInfrastructure(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 = oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructure(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;
}

DeleteCloudExadataInfrastructureAsync(CloudExadataInfrastructureName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudExadataInfrastructureAsync(CloudExadataInfrastructureName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudExadataInfrastructureName name = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]");
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudExadataInfrastructureAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructureAsync(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;
}

DeleteCloudExadataInfrastructureAsync(CloudExadataInfrastructureName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudExadataInfrastructureAsync(CloudExadataInfrastructureName name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudExadataInfrastructureName name = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]");
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudExadataInfrastructureAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructureAsync(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;
}

DeleteCloudExadataInfrastructureAsync(DeleteCloudExadataInfrastructureRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudExadataInfrastructureAsync(DeleteCloudExadataInfrastructureRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
DeleteCloudExadataInfrastructureRequest request = new DeleteCloudExadataInfrastructureRequest
{
    CloudExadataInfrastructureName = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudExadataInfrastructureAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructureAsync(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;
}

DeleteCloudExadataInfrastructureAsync(DeleteCloudExadataInfrastructureRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudExadataInfrastructureAsync(DeleteCloudExadataInfrastructureRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
DeleteCloudExadataInfrastructureRequest request = new DeleteCloudExadataInfrastructureRequest
{
    CloudExadataInfrastructureName = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudExadataInfrastructureAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructureAsync(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;
}

DeleteCloudExadataInfrastructureAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudExadataInfrastructureAsync(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudExadataInfrastructures/[CLOUD_EXADATA_INFRASTRUCTURE]";
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudExadataInfrastructureAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructureAsync(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;
}

DeleteCloudExadataInfrastructureAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudExadataInfrastructureAsync(string name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudExadataInfrastructures/[CLOUD_EXADATA_INFRASTRUCTURE]";
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudExadataInfrastructureAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudExadataInfrastructureAsync(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;
}

DeleteCloudVmCluster(CloudVmClusterName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteCloudVmCluster(CloudVmClusterName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CloudVmClusterName name = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteCloudVmCluster(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 = oracleDatabaseClient.PollOnceDeleteCloudVmCluster(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;
}

DeleteCloudVmCluster(DeleteCloudVmClusterRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteCloudVmCluster(DeleteCloudVmClusterRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
DeleteCloudVmClusterRequest request = new DeleteCloudVmClusterRequest
{
    CloudVmClusterName = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteCloudVmCluster(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 = oracleDatabaseClient.PollOnceDeleteCloudVmCluster(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;
}

DeleteCloudVmCluster(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteCloudVmCluster(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudVmClusters/[CLOUD_VM_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = oracleDatabaseClient.DeleteCloudVmCluster(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 = oracleDatabaseClient.PollOnceDeleteCloudVmCluster(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;
}

DeleteCloudVmClusterAsync(CloudVmClusterName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudVmClusterAsync(CloudVmClusterName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudVmClusterName name = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudVmClusterAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudVmClusterAsync(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;
}

DeleteCloudVmClusterAsync(CloudVmClusterName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudVmClusterAsync(CloudVmClusterName name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudVmClusterName name = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudVmClusterAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudVmClusterAsync(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;
}

DeleteCloudVmClusterAsync(DeleteCloudVmClusterRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudVmClusterAsync(DeleteCloudVmClusterRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
DeleteCloudVmClusterRequest request = new DeleteCloudVmClusterRequest
{
    CloudVmClusterName = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudVmClusterAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudVmClusterAsync(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;
}

DeleteCloudVmClusterAsync(DeleteCloudVmClusterRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudVmClusterAsync(DeleteCloudVmClusterRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
DeleteCloudVmClusterRequest request = new DeleteCloudVmClusterRequest
{
    CloudVmClusterName = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudVmClusterAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudVmClusterAsync(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;
}

DeleteCloudVmClusterAsync(string, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudVmClusterAsync(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudVmClusters/[CLOUD_VM_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudVmClusterAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudVmClusterAsync(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;
}

DeleteCloudVmClusterAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteCloudVmClusterAsync(string name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudVmClusters/[CLOUD_VM_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await oracleDatabaseClient.DeleteCloudVmClusterAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await oracleDatabaseClient.PollOnceDeleteCloudVmClusterAsync(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;
}

GenerateAutonomousDatabaseWallet(AutonomousDatabaseName, GenerateType, bool, string, CallSettings)

public virtual GenerateAutonomousDatabaseWalletResponse GenerateAutonomousDatabaseWallet(AutonomousDatabaseName name, GenerateType type, bool isRegional, string password, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
GenerateType type = GenerateType.Unspecified;
bool isRegional = false;
string password = "";
// Make the request
GenerateAutonomousDatabaseWalletResponse response = oracleDatabaseClient.GenerateAutonomousDatabaseWallet(name, type, isRegional, password);

GenerateAutonomousDatabaseWallet(GenerateAutonomousDatabaseWalletRequest, CallSettings)

public virtual GenerateAutonomousDatabaseWalletResponse GenerateAutonomousDatabaseWallet(GenerateAutonomousDatabaseWalletRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
GenerateAutonomousDatabaseWalletRequest request = new GenerateAutonomousDatabaseWalletRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
    Type = GenerateType.Unspecified,
    IsRegional = false,
    Password = "",
};
// Make the request
GenerateAutonomousDatabaseWalletResponse response = oracleDatabaseClient.GenerateAutonomousDatabaseWallet(request);

GenerateAutonomousDatabaseWallet(string, GenerateType, bool, string, CallSettings)

public virtual GenerateAutonomousDatabaseWalletResponse GenerateAutonomousDatabaseWallet(string name, GenerateType type, bool isRegional, string password, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
GenerateType type = GenerateType.Unspecified;
bool isRegional = false;
string password = "";
// Make the request
GenerateAutonomousDatabaseWalletResponse response = oracleDatabaseClient.GenerateAutonomousDatabaseWallet(name, type, isRegional, password);

GenerateAutonomousDatabaseWalletAsync(AutonomousDatabaseName, GenerateType, bool, string, CallSettings)

public virtual Task<GenerateAutonomousDatabaseWalletResponse> GenerateAutonomousDatabaseWalletAsync(AutonomousDatabaseName name, GenerateType type, bool isRegional, string password, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
GenerateType type = GenerateType.Unspecified;
bool isRegional = false;
string password = "";
// Make the request
GenerateAutonomousDatabaseWalletResponse response = await oracleDatabaseClient.GenerateAutonomousDatabaseWalletAsync(name, type, isRegional, password);

GenerateAutonomousDatabaseWalletAsync(AutonomousDatabaseName, GenerateType, bool, string, CancellationToken)

public virtual Task<GenerateAutonomousDatabaseWalletResponse> GenerateAutonomousDatabaseWalletAsync(AutonomousDatabaseName name, GenerateType type, bool isRegional, string password, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
GenerateType type = GenerateType.Unspecified;
bool isRegional = false;
string password = "";
// Make the request
GenerateAutonomousDatabaseWalletResponse response = await oracleDatabaseClient.GenerateAutonomousDatabaseWalletAsync(name, type, isRegional, password);

GenerateAutonomousDatabaseWalletAsync(GenerateAutonomousDatabaseWalletRequest, CallSettings)

public virtual Task<GenerateAutonomousDatabaseWalletResponse> GenerateAutonomousDatabaseWalletAsync(GenerateAutonomousDatabaseWalletRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GenerateAutonomousDatabaseWalletRequest request = new GenerateAutonomousDatabaseWalletRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
    Type = GenerateType.Unspecified,
    IsRegional = false,
    Password = "",
};
// Make the request
GenerateAutonomousDatabaseWalletResponse response = await oracleDatabaseClient.GenerateAutonomousDatabaseWalletAsync(request);

GenerateAutonomousDatabaseWalletAsync(GenerateAutonomousDatabaseWalletRequest, CancellationToken)

public virtual Task<GenerateAutonomousDatabaseWalletResponse> GenerateAutonomousDatabaseWalletAsync(GenerateAutonomousDatabaseWalletRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GenerateAutonomousDatabaseWalletRequest request = new GenerateAutonomousDatabaseWalletRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
    Type = GenerateType.Unspecified,
    IsRegional = false,
    Password = "",
};
// Make the request
GenerateAutonomousDatabaseWalletResponse response = await oracleDatabaseClient.GenerateAutonomousDatabaseWalletAsync(request);

GenerateAutonomousDatabaseWalletAsync(string, GenerateType, bool, string, CallSettings)

public virtual Task<GenerateAutonomousDatabaseWalletResponse> GenerateAutonomousDatabaseWalletAsync(string name, GenerateType type, bool isRegional, string password, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
GenerateType type = GenerateType.Unspecified;
bool isRegional = false;
string password = "";
// Make the request
GenerateAutonomousDatabaseWalletResponse response = await oracleDatabaseClient.GenerateAutonomousDatabaseWalletAsync(name, type, isRegional, password);

GenerateAutonomousDatabaseWalletAsync(string, GenerateType, bool, string, CancellationToken)

public virtual Task<GenerateAutonomousDatabaseWalletResponse> GenerateAutonomousDatabaseWalletAsync(string name, GenerateType type, bool isRegional, string password, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
GenerateType type = GenerateType.Unspecified;
bool isRegional = false;
string password = "";
// Make the request
GenerateAutonomousDatabaseWalletResponse response = await oracleDatabaseClient.GenerateAutonomousDatabaseWalletAsync(name, type, isRegional, password);

GetAutonomousDatabase(AutonomousDatabaseName, CallSettings)

public virtual AutonomousDatabase GetAutonomousDatabase(AutonomousDatabaseName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
// Make the request
AutonomousDatabase response = oracleDatabaseClient.GetAutonomousDatabase(name);

GetAutonomousDatabase(GetAutonomousDatabaseRequest, CallSettings)

public virtual AutonomousDatabase GetAutonomousDatabase(GetAutonomousDatabaseRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
GetAutonomousDatabaseRequest request = new GetAutonomousDatabaseRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
};
// Make the request
AutonomousDatabase response = oracleDatabaseClient.GetAutonomousDatabase(request);

GetAutonomousDatabase(string, CallSettings)

public virtual AutonomousDatabase GetAutonomousDatabase(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
// Make the request
AutonomousDatabase response = oracleDatabaseClient.GetAutonomousDatabase(name);

GetAutonomousDatabaseAsync(AutonomousDatabaseName, CallSettings)

public virtual Task<AutonomousDatabase> GetAutonomousDatabaseAsync(AutonomousDatabaseName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
// Make the request
AutonomousDatabase response = await oracleDatabaseClient.GetAutonomousDatabaseAsync(name);

GetAutonomousDatabaseAsync(AutonomousDatabaseName, CancellationToken)

public virtual Task<AutonomousDatabase> GetAutonomousDatabaseAsync(AutonomousDatabaseName name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
AutonomousDatabaseName name = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]");
// Make the request
AutonomousDatabase response = await oracleDatabaseClient.GetAutonomousDatabaseAsync(name);

GetAutonomousDatabaseAsync(GetAutonomousDatabaseRequest, CallSettings)

public virtual Task<AutonomousDatabase> GetAutonomousDatabaseAsync(GetAutonomousDatabaseRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GetAutonomousDatabaseRequest request = new GetAutonomousDatabaseRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
};
// Make the request
AutonomousDatabase response = await oracleDatabaseClient.GetAutonomousDatabaseAsync(request);

GetAutonomousDatabaseAsync(GetAutonomousDatabaseRequest, CancellationToken)

public virtual Task<AutonomousDatabase> GetAutonomousDatabaseAsync(GetAutonomousDatabaseRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GetAutonomousDatabaseRequest request = new GetAutonomousDatabaseRequest
{
    AutonomousDatabaseName = AutonomousDatabaseName.FromProjectLocationAutonomousDatabase("[PROJECT]", "[LOCATION]", "[AUTONOMOUS_DATABASE]"),
};
// Make the request
AutonomousDatabase response = await oracleDatabaseClient.GetAutonomousDatabaseAsync(request);

GetAutonomousDatabaseAsync(string, CallSettings)

public virtual Task<AutonomousDatabase> GetAutonomousDatabaseAsync(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
// Make the request
AutonomousDatabase response = await oracleDatabaseClient.GetAutonomousDatabaseAsync(name);

GetAutonomousDatabaseAsync(string, CancellationToken)

public virtual Task<AutonomousDatabase> GetAutonomousDatabaseAsync(string name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/autonomousDatabases/[AUTONOMOUS_DATABASE]";
// Make the request
AutonomousDatabase response = await oracleDatabaseClient.GetAutonomousDatabaseAsync(name);

GetCloudExadataInfrastructure(CloudExadataInfrastructureName, CallSettings)

public virtual CloudExadataInfrastructure GetCloudExadataInfrastructure(CloudExadataInfrastructureName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CloudExadataInfrastructureName name = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]");
// Make the request
CloudExadataInfrastructure response = oracleDatabaseClient.GetCloudExadataInfrastructure(name);

GetCloudExadataInfrastructure(GetCloudExadataInfrastructureRequest, CallSettings)

public virtual CloudExadataInfrastructure GetCloudExadataInfrastructure(GetCloudExadataInfrastructureRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
GetCloudExadataInfrastructureRequest request = new GetCloudExadataInfrastructureRequest
{
    CloudExadataInfrastructureName = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]"),
};
// Make the request
CloudExadataInfrastructure response = oracleDatabaseClient.GetCloudExadataInfrastructure(request);

GetCloudExadataInfrastructure(string, CallSettings)

public virtual CloudExadataInfrastructure GetCloudExadataInfrastructure(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudExadataInfrastructures/[CLOUD_EXADATA_INFRASTRUCTURE]";
// Make the request
CloudExadataInfrastructure response = oracleDatabaseClient.GetCloudExadataInfrastructure(name);

GetCloudExadataInfrastructureAsync(CloudExadataInfrastructureName, CallSettings)

public virtual Task<CloudExadataInfrastructure> GetCloudExadataInfrastructureAsync(CloudExadataInfrastructureName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudExadataInfrastructureName name = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]");
// Make the request
CloudExadataInfrastructure response = await oracleDatabaseClient.GetCloudExadataInfrastructureAsync(name);

GetCloudExadataInfrastructureAsync(CloudExadataInfrastructureName, CancellationToken)

public virtual Task<CloudExadataInfrastructure> GetCloudExadataInfrastructureAsync(CloudExadataInfrastructureName name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudExadataInfrastructureName name = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]");
// Make the request
CloudExadataInfrastructure response = await oracleDatabaseClient.GetCloudExadataInfrastructureAsync(name);

GetCloudExadataInfrastructureAsync(GetCloudExadataInfrastructureRequest, CallSettings)

public virtual Task<CloudExadataInfrastructure> GetCloudExadataInfrastructureAsync(GetCloudExadataInfrastructureRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GetCloudExadataInfrastructureRequest request = new GetCloudExadataInfrastructureRequest
{
    CloudExadataInfrastructureName = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]"),
};
// Make the request
CloudExadataInfrastructure response = await oracleDatabaseClient.GetCloudExadataInfrastructureAsync(request);

GetCloudExadataInfrastructureAsync(GetCloudExadataInfrastructureRequest, CancellationToken)

public virtual Task<CloudExadataInfrastructure> GetCloudExadataInfrastructureAsync(GetCloudExadataInfrastructureRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GetCloudExadataInfrastructureRequest request = new GetCloudExadataInfrastructureRequest
{
    CloudExadataInfrastructureName = CloudExadataInfrastructureName.FromProjectLocationCloudExadataInfrastructure("[PROJECT]", "[LOCATION]", "[CLOUD_EXADATA_INFRASTRUCTURE]"),
};
// Make the request
CloudExadataInfrastructure response = await oracleDatabaseClient.GetCloudExadataInfrastructureAsync(request);

GetCloudExadataInfrastructureAsync(string, CallSettings)

public virtual Task<CloudExadataInfrastructure> GetCloudExadataInfrastructureAsync(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudExadataInfrastructures/[CLOUD_EXADATA_INFRASTRUCTURE]";
// Make the request
CloudExadataInfrastructure response = await oracleDatabaseClient.GetCloudExadataInfrastructureAsync(name);

GetCloudExadataInfrastructureAsync(string, CancellationToken)

public virtual Task<CloudExadataInfrastructure> GetCloudExadataInfrastructureAsync(string name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudExadataInfrastructures/[CLOUD_EXADATA_INFRASTRUCTURE]";
// Make the request
CloudExadataInfrastructure response = await oracleDatabaseClient.GetCloudExadataInfrastructureAsync(name);

GetCloudVmCluster(CloudVmClusterName, CallSettings)

public virtual CloudVmCluster GetCloudVmCluster(CloudVmClusterName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
CloudVmClusterName name = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]");
// Make the request
CloudVmCluster response = oracleDatabaseClient.GetCloudVmCluster(name);

GetCloudVmCluster(GetCloudVmClusterRequest, CallSettings)

public virtual CloudVmCluster GetCloudVmCluster(GetCloudVmClusterRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
GetCloudVmClusterRequest request = new GetCloudVmClusterRequest
{
    CloudVmClusterName = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]"),
};
// Make the request
CloudVmCluster response = oracleDatabaseClient.GetCloudVmCluster(request);

GetCloudVmCluster(string, CallSettings)

public virtual CloudVmCluster GetCloudVmCluster(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudVmClusters/[CLOUD_VM_CLUSTER]";
// Make the request
CloudVmCluster response = oracleDatabaseClient.GetCloudVmCluster(name);

GetCloudVmClusterAsync(CloudVmClusterName, CallSettings)

public virtual Task<CloudVmCluster> GetCloudVmClusterAsync(CloudVmClusterName name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudVmClusterName name = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]");
// Make the request
CloudVmCluster response = await oracleDatabaseClient.GetCloudVmClusterAsync(name);

GetCloudVmClusterAsync(CloudVmClusterName, CancellationToken)

public virtual Task<CloudVmCluster> GetCloudVmClusterAsync(CloudVmClusterName name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
CloudVmClusterName name = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]");
// Make the request
CloudVmCluster response = await oracleDatabaseClient.GetCloudVmClusterAsync(name);

GetCloudVmClusterAsync(GetCloudVmClusterRequest, CallSettings)

public virtual Task<CloudVmCluster> GetCloudVmClusterAsync(GetCloudVmClusterRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GetCloudVmClusterRequest request = new GetCloudVmClusterRequest
{
    CloudVmClusterName = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]"),
};
// Make the request
CloudVmCluster response = await oracleDatabaseClient.GetCloudVmClusterAsync(request);

GetCloudVmClusterAsync(GetCloudVmClusterRequest, CancellationToken)

public virtual Task<CloudVmCluster> GetCloudVmClusterAsync(GetCloudVmClusterRequest request, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
GetCloudVmClusterRequest request = new GetCloudVmClusterRequest
{
    CloudVmClusterName = CloudVmClusterName.FromProjectLocationCloudVmCluster("[PROJECT]", "[LOCATION]", "[CLOUD_VM_CLUSTER]"),
};
// Make the request
CloudVmCluster response = await oracleDatabaseClient.GetCloudVmClusterAsync(request);

GetCloudVmClusterAsync(string, CallSettings)

public virtual Task<CloudVmCluster> GetCloudVmClusterAsync(string name, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudVmClusters/[CLOUD_VM_CLUSTER]";
// Make the request
CloudVmCluster response = await oracleDatabaseClient.GetCloudVmClusterAsync(name);

GetCloudVmClusterAsync(string, CancellationToken)

public virtual Task<CloudVmCluster> GetCloudVmClusterAsync(string name, CancellationToken cancellationToken)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/cloudVmClusters/[CLOUD_VM_CLUSTER]";
// Make the request
CloudVmCluster response = await oracleDatabaseClient.GetCloudVmClusterAsync(name);

ListAutonomousDatabaseBackups(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> ListAutonomousDatabaseBackups(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> response = oracleDatabaseClient.ListAutonomousDatabaseBackups(parent);

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

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

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

ListAutonomousDatabaseBackups(ListAutonomousDatabaseBackupsRequest, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> ListAutonomousDatabaseBackups(ListAutonomousDatabaseBackupsRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
ListAutonomousDatabaseBackupsRequest request = new ListAutonomousDatabaseBackupsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> response = oracleDatabaseClient.ListAutonomousDatabaseBackups(request);

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

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

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

ListAutonomousDatabaseBackups(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> ListAutonomousDatabaseBackups(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> response = oracleDatabaseClient.ListAutonomousDatabaseBackups(parent);

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

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

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

ListAutonomousDatabaseBackupsAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> ListAutonomousDatabaseBackupsAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> response = oracleDatabaseClient.ListAutonomousDatabaseBackupsAsync(parent);

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

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

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

ListAutonomousDatabaseBackupsAsync(ListAutonomousDatabaseBackupsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> ListAutonomousDatabaseBackupsAsync(ListAutonomousDatabaseBackupsRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
ListAutonomousDatabaseBackupsRequest request = new ListAutonomousDatabaseBackupsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> response = oracleDatabaseClient.ListAutonomousDatabaseBackupsAsync(request);

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

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

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

ListAutonomousDatabaseBackupsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> ListAutonomousDatabaseBackupsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabaseBackupsResponse, AutonomousDatabaseBackup> response = oracleDatabaseClient.ListAutonomousDatabaseBackupsAsync(parent);

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

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

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

ListAutonomousDatabaseCharacterSets(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> ListAutonomousDatabaseCharacterSets(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> response = oracleDatabaseClient.ListAutonomousDatabaseCharacterSets(parent);

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

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

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

ListAutonomousDatabaseCharacterSets(ListAutonomousDatabaseCharacterSetsRequest, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> ListAutonomousDatabaseCharacterSets(ListAutonomousDatabaseCharacterSetsRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
ListAutonomousDatabaseCharacterSetsRequest request = new ListAutonomousDatabaseCharacterSetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> response = oracleDatabaseClient.ListAutonomousDatabaseCharacterSets(request);

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

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

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

ListAutonomousDatabaseCharacterSets(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> ListAutonomousDatabaseCharacterSets(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> response = oracleDatabaseClient.ListAutonomousDatabaseCharacterSets(parent);

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

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

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

ListAutonomousDatabaseCharacterSetsAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> ListAutonomousDatabaseCharacterSetsAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> response = oracleDatabaseClient.ListAutonomousDatabaseCharacterSetsAsync(parent);

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

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

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

ListAutonomousDatabaseCharacterSetsAsync(ListAutonomousDatabaseCharacterSetsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> ListAutonomousDatabaseCharacterSetsAsync(ListAutonomousDatabaseCharacterSetsRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
ListAutonomousDatabaseCharacterSetsRequest request = new ListAutonomousDatabaseCharacterSetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> response = oracleDatabaseClient.ListAutonomousDatabaseCharacterSetsAsync(request);

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

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

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

ListAutonomousDatabaseCharacterSetsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> ListAutonomousDatabaseCharacterSetsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabaseCharacterSetsResponse, AutonomousDatabaseCharacterSet> response = oracleDatabaseClient.ListAutonomousDatabaseCharacterSetsAsync(parent);

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

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

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

ListAutonomousDatabases(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> ListAutonomousDatabases(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> response = oracleDatabaseClient.ListAutonomousDatabases(parent);

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

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

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

ListAutonomousDatabases(ListAutonomousDatabasesRequest, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> ListAutonomousDatabases(ListAutonomousDatabasesRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
ListAutonomousDatabasesRequest request = new ListAutonomousDatabasesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> response = oracleDatabaseClient.ListAutonomousDatabases(request);

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

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

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

ListAutonomousDatabases(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> ListAutonomousDatabases(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> response = oracleDatabaseClient.ListAutonomousDatabases(parent);

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

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

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

ListAutonomousDatabasesAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> ListAutonomousDatabasesAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> response = oracleDatabaseClient.ListAutonomousDatabasesAsync(parent);

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

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

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

ListAutonomousDatabasesAsync(ListAutonomousDatabasesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> ListAutonomousDatabasesAsync(ListAutonomousDatabasesRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
ListAutonomousDatabasesRequest request = new ListAutonomousDatabasesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> response = oracleDatabaseClient.ListAutonomousDatabasesAsync(request);

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

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

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

ListAutonomousDatabasesAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> ListAutonomousDatabasesAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAutonomousDatabasesResponse, AutonomousDatabase> response = oracleDatabaseClient.ListAutonomousDatabasesAsync(parent);

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

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

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

ListAutonomousDbVersions(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> ListAutonomousDbVersions(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> response = oracleDatabaseClient.ListAutonomousDbVersions(parent);

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

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

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

ListAutonomousDbVersions(ListAutonomousDbVersionsRequest, CallSettings)

public virtual PagedEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> ListAutonomousDbVersions(ListAutonomousDbVersionsRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
ListAutonomousDbVersionsRequest request = new ListAutonomousDbVersionsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> response = oracleDatabaseClient.ListAutonomousDbVersions(request);

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

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

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

ListAutonomousDbVersions(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> ListAutonomousDbVersions(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> response = oracleDatabaseClient.ListAutonomousDbVersions(parent);

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

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

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

ListAutonomousDbVersionsAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> ListAutonomousDbVersionsAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> response = oracleDatabaseClient.ListAutonomousDbVersionsAsync(parent);

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

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

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

ListAutonomousDbVersionsAsync(ListAutonomousDbVersionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> ListAutonomousDbVersionsAsync(ListAutonomousDbVersionsRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
ListAutonomousDbVersionsRequest request = new ListAutonomousDbVersionsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> response = oracleDatabaseClient.ListAutonomousDbVersionsAsync(request);

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

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

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

ListAutonomousDbVersionsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> ListAutonomousDbVersionsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAutonomousDbVersionsResponse, AutonomousDbVersion> response = oracleDatabaseClient.ListAutonomousDbVersionsAsync(parent);

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

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

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

ListCloudExadataInfrastructures(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> ListCloudExadataInfrastructures(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> response = oracleDatabaseClient.ListCloudExadataInfrastructures(parent);

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

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

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

ListCloudExadataInfrastructures(ListCloudExadataInfrastructuresRequest, CallSettings)

public virtual PagedEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> ListCloudExadataInfrastructures(ListCloudExadataInfrastructuresRequest request, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
ListCloudExadataInfrastructuresRequest request = new ListCloudExadataInfrastructuresRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> response = oracleDatabaseClient.ListCloudExadataInfrastructures(request);

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

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

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

ListCloudExadataInfrastructures(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> ListCloudExadataInfrastructures(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = OracleDatabaseClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> response = oracleDatabaseClient.ListCloudExadataInfrastructures(parent);

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

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

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

ListCloudExadataInfrastructuresAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> ListCloudExadataInfrastructuresAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
OracleDatabaseClient oracleDatabaseClient = await OracleDatabaseClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> response = oracleDatabaseClient.ListCloudExadataInfrastructuresAsync(parent);

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

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

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

ListCloudExadataInfrastructuresAsync(ListCloudExadataInfrastructuresRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListCloudExadataInfrastructuresResponse, CloudExadataInfrastructure> ListCloudExadataInfrastructuresAsync(ListCloudExadataInfrastructuresRequest request, CallSettings callSettings = null)