Database Migration v1 API - Class DataMigrationServiceClient (2.4.0)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ApplyConversionWorkspaceRequest request = new ApplyConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    Filter = "",
    DryRun = false,
    AutoCommit = false,
    ConnectionProfile = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = dataMigrationServiceClient.ApplyConversionWorkspace(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ApplyConversionWorkspaceRequest request = new ApplyConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    Filter = "",
    DryRun = false,
    AutoCommit = false,
    ConnectionProfile = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.ApplyConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ApplyConversionWorkspaceRequest request = new ApplyConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    Filter = "",
    DryRun = false,
    AutoCommit = false,
    ConnectionProfile = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.ApplyConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CommitConversionWorkspaceRequest request = new CommitConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    CommitName = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = dataMigrationServiceClient.CommitConversionWorkspace(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CommitConversionWorkspaceRequest request = new CommitConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    CommitName = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CommitConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CommitConversionWorkspaceRequest request = new CommitConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    CommitName = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CommitConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConvertConversionWorkspaceRequest request = new ConvertConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    AutoCommit = false,
    Filter = "",
    ConvertFullPath = false,
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = dataMigrationServiceClient.ConvertConversionWorkspace(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConvertConversionWorkspaceRequest request = new ConvertConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    AutoCommit = false,
    Filter = "",
    ConvertFullPath = false,
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.ConvertConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConvertConversionWorkspaceRequest request = new ConvertConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    AutoCommit = false,
    Filter = "",
    ConvertFullPath = false,
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.ConvertConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = dataMigrationServiceClient.CreateConnectionProfile(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
    ValidateOnly = false,
    SkipValidation = false,
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = dataMigrationServiceClient.CreateConnectionProfile(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = dataMigrationServiceClient.CreateConnectionProfile(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
    ValidateOnly = false,
    SkipValidation = false,
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.CreateConnectionProfileAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
    ValidateOnly = false,
    SkipValidation = false,
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.CreateConnectionProfileAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConnectionProfile connectionProfile = new ConnectionProfile();
string connectionProfileId = "";
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.CreateConnectionProfileAsync(parent, connectionProfile, connectionProfileId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConversionWorkspace conversionWorkspace = new ConversionWorkspace();
string conversionWorkspaceId = "";
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = dataMigrationServiceClient.CreateConversionWorkspace(parent, conversionWorkspace, conversionWorkspaceId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CreateConversionWorkspaceRequest request = new CreateConversionWorkspaceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConversionWorkspaceId = "",
    ConversionWorkspace = new ConversionWorkspace(),
    RequestId = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = dataMigrationServiceClient.CreateConversionWorkspace(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConversionWorkspace conversionWorkspace = new ConversionWorkspace();
string conversionWorkspaceId = "";
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = dataMigrationServiceClient.CreateConversionWorkspace(parent, conversionWorkspace, conversionWorkspaceId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConversionWorkspace conversionWorkspace = new ConversionWorkspace();
string conversionWorkspaceId = "";
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CreateConversionWorkspaceAsync(parent, conversionWorkspace, conversionWorkspaceId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConversionWorkspace conversionWorkspace = new ConversionWorkspace();
string conversionWorkspaceId = "";
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CreateConversionWorkspaceAsync(parent, conversionWorkspace, conversionWorkspaceId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateConversionWorkspaceRequest request = new CreateConversionWorkspaceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConversionWorkspaceId = "",
    ConversionWorkspace = new ConversionWorkspace(),
    RequestId = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CreateConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateConversionWorkspaceRequest request = new CreateConversionWorkspaceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ConversionWorkspaceId = "",
    ConversionWorkspace = new ConversionWorkspace(),
    RequestId = "",
};
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CreateConversionWorkspaceAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConversionWorkspace conversionWorkspace = new ConversionWorkspace();
string conversionWorkspaceId = "";
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CreateConversionWorkspaceAsync(parent, conversionWorkspace, conversionWorkspaceId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ConversionWorkspace conversionWorkspace = new ConversionWorkspace();
string conversionWorkspaceId = "";
// Make the request
Operation<ConversionWorkspace, OperationMetadata> response = await dataMigrationServiceClient.CreateConversionWorkspaceAsync(parent, conversionWorkspace, conversionWorkspaceId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConversionWorkspaceName parent = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
MappingRule mappingRule = new MappingRule();
string mappingRuleId = "";
// Make the request
MappingRule response = dataMigrationServiceClient.CreateMappingRule(parent, mappingRule, mappingRuleId);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CreateMappingRuleRequest request = new CreateMappingRuleRequest
{
    ParentAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    MappingRuleId = "",
    MappingRule = new MappingRule(),
    RequestId = "",
};
// Make the request
MappingRule response = dataMigrationServiceClient.CreateMappingRule(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
MappingRule mappingRule = new MappingRule();
string mappingRuleId = "";
// Make the request
MappingRule response = dataMigrationServiceClient.CreateMappingRule(parent, mappingRule, mappingRuleId);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConversionWorkspaceName parent = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
MappingRule mappingRule = new MappingRule();
string mappingRuleId = "";
// Make the request
MappingRule response = await dataMigrationServiceClient.CreateMappingRuleAsync(parent, mappingRule, mappingRuleId);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConversionWorkspaceName parent = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
MappingRule mappingRule = new MappingRule();
string mappingRuleId = "";
// Make the request
MappingRule response = await dataMigrationServiceClient.CreateMappingRuleAsync(parent, mappingRule, mappingRuleId);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMappingRuleRequest request = new CreateMappingRuleRequest
{
    ParentAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    MappingRuleId = "",
    MappingRule = new MappingRule(),
    RequestId = "",
};
// Make the request
MappingRule response = await dataMigrationServiceClient.CreateMappingRuleAsync(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMappingRuleRequest request = new CreateMappingRuleRequest
{
    ParentAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    MappingRuleId = "",
    MappingRule = new MappingRule(),
    RequestId = "",
};
// Make the request
MappingRule response = await dataMigrationServiceClient.CreateMappingRuleAsync(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
MappingRule mappingRule = new MappingRule();
string mappingRuleId = "";
// Make the request
MappingRule response = await dataMigrationServiceClient.CreateMappingRuleAsync(parent, mappingRule, mappingRuleId);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
MappingRule mappingRule = new MappingRule();
string mappingRuleId = "";
// Make the request
MappingRule response = await dataMigrationServiceClient.CreateMappingRuleAsync(parent, mappingRule, mappingRuleId);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MigrationJob migrationJob = new MigrationJob();
string migrationJobId = "";
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.CreateMigrationJob(parent, migrationJob, migrationJobId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CreateMigrationJobRequest request = new CreateMigrationJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MigrationJobId = "",
    MigrationJob = new MigrationJob(),
    RequestId = "",
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.CreateMigrationJob(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MigrationJob migrationJob = new MigrationJob();
string migrationJobId = "";
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.CreateMigrationJob(parent, migrationJob, migrationJobId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MigrationJob migrationJob = new MigrationJob();
string migrationJobId = "";
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.CreateMigrationJobAsync(parent, migrationJob, migrationJobId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MigrationJob migrationJob = new MigrationJob();
string migrationJobId = "";
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.CreateMigrationJobAsync(parent, migrationJob, migrationJobId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMigrationJobRequest request = new CreateMigrationJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MigrationJobId = "",
    MigrationJob = new MigrationJob(),
    RequestId = "",
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.CreateMigrationJobAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMigrationJobRequest request = new CreateMigrationJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MigrationJobId = "",
    MigrationJob = new MigrationJob(),
    RequestId = "",
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.CreateMigrationJobAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MigrationJob migrationJob = new MigrationJob();
string migrationJobId = "";
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.CreateMigrationJobAsync(parent, migrationJob, migrationJobId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MigrationJob migrationJob = new MigrationJob();
string migrationJobId = "";
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.CreateMigrationJobAsync(parent, migrationJob, migrationJobId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = dataMigrationServiceClient.CreatePrivateConnection(parent, privateConnection, privateConnectionId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CreatePrivateConnectionRequest request = new CreatePrivateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PrivateConnectionId = "",
    PrivateConnection = new PrivateConnection(),
    RequestId = "",
    SkipValidation = false,
};
// Make the request
Operation<PrivateConnection, OperationMetadata> response = dataMigrationServiceClient.CreatePrivateConnection(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = dataMigrationServiceClient.CreatePrivateConnection(parent, privateConnection, privateConnectionId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await dataMigrationServiceClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await dataMigrationServiceClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreatePrivateConnectionRequest request = new CreatePrivateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PrivateConnectionId = "",
    PrivateConnection = new PrivateConnection(),
    RequestId = "",
    SkipValidation = false,
};
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await dataMigrationServiceClient.CreatePrivateConnectionAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreatePrivateConnectionRequest request = new CreatePrivateConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PrivateConnectionId = "",
    PrivateConnection = new PrivateConnection(),
    RequestId = "",
    SkipValidation = false,
};
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await dataMigrationServiceClient.CreatePrivateConnectionAsync(request);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await dataMigrationServiceClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PrivateConnection privateConnection = new PrivateConnection();
string privateConnectionId = "";
// Make the request
Operation<PrivateConnection, OperationMetadata> response = await dataMigrationServiceClient.CreatePrivateConnectionAsync(parent, privateConnection, privateConnectionId);

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

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

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteConnectionProfile(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 = dataMigrationServiceClient.PollOnceDeleteConnectionProfile(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DeleteConnectionProfileRequest request = new DeleteConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteConnectionProfile(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 = dataMigrationServiceClient.PollOnceDeleteConnectionProfile(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteConnectionProfile(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 = dataMigrationServiceClient.PollOnceDeleteConnectionProfile(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConnectionProfileAsync(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 dataMigrationServiceClient.PollOnceDeleteConnectionProfileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConnectionProfileAsync(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 dataMigrationServiceClient.PollOnceDeleteConnectionProfileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectionProfileRequest request = new DeleteConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConnectionProfileAsync(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 dataMigrationServiceClient.PollOnceDeleteConnectionProfileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteConnectionProfileRequest request = new DeleteConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConnectionProfileAsync(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 dataMigrationServiceClient.PollOnceDeleteConnectionProfileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConnectionProfileAsync(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 dataMigrationServiceClient.PollOnceDeleteConnectionProfileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConnectionProfileAsync(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 dataMigrationServiceClient.PollOnceDeleteConnectionProfileAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConversionWorkspaceName name = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteConversionWorkspace(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 = dataMigrationServiceClient.PollOnceDeleteConversionWorkspace(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DeleteConversionWorkspaceRequest request = new DeleteConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteConversionWorkspace(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 = dataMigrationServiceClient.PollOnceDeleteConversionWorkspace(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteConversionWorkspace(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 = dataMigrationServiceClient.PollOnceDeleteConversionWorkspace(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConversionWorkspaceName name = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConversionWorkspaceAsync(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 dataMigrationServiceClient.PollOnceDeleteConversionWorkspaceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConversionWorkspaceName name = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConversionWorkspaceAsync(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 dataMigrationServiceClient.PollOnceDeleteConversionWorkspaceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteConversionWorkspaceRequest request = new DeleteConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConversionWorkspaceAsync(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 dataMigrationServiceClient.PollOnceDeleteConversionWorkspaceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteConversionWorkspaceRequest request = new DeleteConversionWorkspaceRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConversionWorkspaceAsync(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 dataMigrationServiceClient.PollOnceDeleteConversionWorkspaceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConversionWorkspaceAsync(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 dataMigrationServiceClient.PollOnceDeleteConversionWorkspaceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteConversionWorkspaceAsync(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 dataMigrationServiceClient.PollOnceDeleteConversionWorkspaceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConversionWorkspaceName name = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
// Make the request
dataMigrationServiceClient.DeleteMappingRule(name);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DeleteMappingRuleRequest request = new DeleteMappingRuleRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    RequestId = "",
};
// Make the request
dataMigrationServiceClient.DeleteMappingRule(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
// Make the request
dataMigrationServiceClient.DeleteMappingRule(name);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConversionWorkspaceName name = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
// Make the request
await dataMigrationServiceClient.DeleteMappingRuleAsync(name);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConversionWorkspaceName name = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]");
// Make the request
await dataMigrationServiceClient.DeleteMappingRuleAsync(name);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteMappingRuleRequest request = new DeleteMappingRuleRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    RequestId = "",
};
// Make the request
await dataMigrationServiceClient.DeleteMappingRuleAsync(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteMappingRuleRequest request = new DeleteMappingRuleRequest
{
    ConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    RequestId = "",
};
// Make the request
await dataMigrationServiceClient.DeleteMappingRuleAsync(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
// Make the request
await dataMigrationServiceClient.DeleteMappingRuleAsync(name);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/conversionWorkspaces/[CONVERSION_WORKSPACE]";
// Make the request
await dataMigrationServiceClient.DeleteMappingRuleAsync(name);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DeleteMigrationJobRequest request = new DeleteMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteMigrationJob(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 = dataMigrationServiceClient.PollOnceDeleteMigrationJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
MigrationJobName name = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteMigrationJob(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 = dataMigrationServiceClient.PollOnceDeleteMigrationJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/migrationJobs/[MIGRATION_JOB]";
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeleteMigrationJob(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 = dataMigrationServiceClient.PollOnceDeleteMigrationJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteMigrationJobRequest request = new DeleteMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteMigrationJobAsync(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 dataMigrationServiceClient.PollOnceDeleteMigrationJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteMigrationJobRequest request = new DeleteMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteMigrationJobAsync(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 dataMigrationServiceClient.PollOnceDeleteMigrationJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
MigrationJobName name = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteMigrationJobAsync(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 dataMigrationServiceClient.PollOnceDeleteMigrationJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
MigrationJobName name = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteMigrationJobAsync(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 dataMigrationServiceClient.PollOnceDeleteMigrationJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/migrationJobs/[MIGRATION_JOB]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteMigrationJobAsync(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 dataMigrationServiceClient.PollOnceDeleteMigrationJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/migrationJobs/[MIGRATION_JOB]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeleteMigrationJobAsync(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 dataMigrationServiceClient.PollOnceDeleteMigrationJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DeletePrivateConnectionRequest request = new DeletePrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeletePrivateConnection(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 = dataMigrationServiceClient.PollOnceDeletePrivateConnection(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeletePrivateConnection(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 = dataMigrationServiceClient.PollOnceDeletePrivateConnection(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = dataMigrationServiceClient.DeletePrivateConnection(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 = dataMigrationServiceClient.PollOnceDeletePrivateConnection(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeletePrivateConnectionRequest request = new DeletePrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeletePrivateConnectionAsync(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 dataMigrationServiceClient.PollOnceDeletePrivateConnectionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DeletePrivateConnectionRequest request = new DeletePrivateConnectionRequest
{
    PrivateConnectionName = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeletePrivateConnectionAsync(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 dataMigrationServiceClient.PollOnceDeletePrivateConnectionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeletePrivateConnectionAsync(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 dataMigrationServiceClient.PollOnceDeletePrivateConnectionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
PrivateConnectionName name = PrivateConnectionName.FromProjectLocationPrivateConnection("[PROJECT]", "[LOCATION]", "[PRIVATE_CONNECTION]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeletePrivateConnectionAsync(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 dataMigrationServiceClient.PollOnceDeletePrivateConnectionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeletePrivateConnectionAsync(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 dataMigrationServiceClient.PollOnceDeletePrivateConnectionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/privateConnections/[PRIVATE_CONNECTION]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataMigrationServiceClient.DeletePrivateConnectionAsync(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 dataMigrationServiceClient.PollOnceDeletePrivateConnectionAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DescribeConversionWorkspaceRevisionsRequest request = new DescribeConversionWorkspaceRevisionsRequest
{
    ConversionWorkspaceAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    CommitId = "",
};
// Make the request
DescribeConversionWorkspaceRevisionsResponse response = dataMigrationServiceClient.DescribeConversionWorkspaceRevisions(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DescribeConversionWorkspaceRevisionsRequest request = new DescribeConversionWorkspaceRevisionsRequest
{
    ConversionWorkspaceAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    CommitId = "",
};
// Make the request
DescribeConversionWorkspaceRevisionsResponse response = await dataMigrationServiceClient.DescribeConversionWorkspaceRevisionsAsync(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DescribeConversionWorkspaceRevisionsRequest request = new DescribeConversionWorkspaceRevisionsRequest
{
    ConversionWorkspaceAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    CommitId = "",
};
// Make the request
DescribeConversionWorkspaceRevisionsResponse response = await dataMigrationServiceClient.DescribeConversionWorkspaceRevisionsAsync(request);

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
DescribeDatabaseEntitiesRequest request = new DescribeDatabaseEntitiesRequest
{
    ConversionWorkspaceAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    Tree = DescribeDatabaseEntitiesRequest.Types.DBTreeType.Unspecified,
    Uncommitted = false,
    CommitId = "",
    Filter = "",
    View = DatabaseEntityView.Unspecified,
};
// Make the request
PagedEnumerable<DescribeDatabaseEntitiesResponse, DatabaseEntity> response = dataMigrationServiceClient.DescribeDatabaseEntities(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (DatabaseEntity 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 (DescribeDatabaseEntitiesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (DatabaseEntity 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<DatabaseEntity> 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 (DatabaseEntity item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
DescribeDatabaseEntitiesRequest request = new DescribeDatabaseEntitiesRequest
{
    ConversionWorkspaceAsConversionWorkspaceName = ConversionWorkspaceName.FromProjectLocationConversionWorkspace("[PROJECT]", "[LOCATION]", "[CONVERSION_WORKSPACE]"),
    Tree = DescribeDatabaseEntitiesRequest.Types.DBTreeType.Unspecified,
    Uncommitted = false,
    CommitId = "",
    Filter = "",
    View = DatabaseEntityView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<DescribeDatabaseEntitiesResponse, DatabaseEntity> response = dataMigrationServiceClient.DescribeDatabaseEntitiesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((DatabaseEntity 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((DescribeDatabaseEntitiesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (DatabaseEntity 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<DatabaseEntity> 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 (DatabaseEntity item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName name = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<FetchStaticIpsResponse, string> response = dataMigrationServiceClient.FetchStaticIps(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchStaticIpsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
FetchStaticIpsRequest request = new FetchStaticIpsRequest
{
    LocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<FetchStaticIpsResponse, string> response = dataMigrationServiceClient.FetchStaticIps(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchStaticIpsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<FetchStaticIpsResponse, string> response = dataMigrationServiceClient.FetchStaticIps(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (string 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 (FetchStaticIpsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName name = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<FetchStaticIpsResponse, string> response = dataMigrationServiceClient.FetchStaticIpsAsync(name);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string 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((FetchStaticIpsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (string 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<string> 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 (string 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;