Class DataMigrationServiceClient (2.0.0)

public abstract class DataMigrationServiceClient

Namespace

Assembly

Google.Cloud.CloudDms.V1.dll

Remarks

Properties

CreateConnectionProfileOperationsClient

public virtual OperationsClient CreateConnectionProfileOperationsClient { get; }

CreateMigrationJobOperationsClient

public virtual OperationsClient CreateMigrationJobOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteConnectionProfileOperationsClient

public virtual OperationsClient DeleteConnectionProfileOperationsClient { get; }

DeleteMigrationJobOperationsClient

public virtual OperationsClient DeleteMigrationJobOperationsClient { get; }

GrpcClient

public virtual DataMigrationService.DataMigrationServiceClient GrpcClient { get; }

PromoteMigrationJobOperationsClient

public virtual OperationsClient PromoteMigrationJobOperationsClient { get; }

RestartMigrationJobOperationsClient

public virtual OperationsClient RestartMigrationJobOperationsClient { get; }

ResumeMigrationJobOperationsClient

public virtual OperationsClient ResumeMigrationJobOperationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

StartMigrationJobOperationsClient

public virtual OperationsClient StartMigrationJobOperationsClient { get; }

StopMigrationJobOperationsClient

public virtual OperationsClient StopMigrationJobOperationsClient { get; }

UpdateConnectionProfileOperationsClient

public virtual OperationsClient UpdateConnectionProfileOperationsClient { get; }

UpdateMigrationJobOperationsClient

public virtual OperationsClient UpdateMigrationJobOperationsClient { get; }

VerifyMigrationJobOperationsClient

public virtual OperationsClient VerifyMigrationJobOperationsClient { get; }

Methods

Create()

public static DataMigrationServiceClient Create()

CreateAsync(CancellationToken)

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

CreateConnectionProfile(ConnectionProfileName, ConnectionProfile, String, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> CreateConnectionProfile(ConnectionProfileName parent, ConnectionProfile connectionProfile, string connectionProfileId, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConnectionProfileName parent = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
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;
}

CreateConnectionProfile(CreateConnectionProfileRequest, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> CreateConnectionProfile(CreateConnectionProfileRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// 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;
}

CreateConnectionProfile(String, ConnectionProfile, String, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> CreateConnectionProfile(string parent, ConnectionProfile connectionProfile, string connectionProfileId, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
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;
}

CreateConnectionProfileAsync(ConnectionProfileName, ConnectionProfile, String, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> CreateConnectionProfileAsync(ConnectionProfileName parent, ConnectionProfile connectionProfile, string connectionProfileId, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName parent = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
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;
}

CreateConnectionProfileAsync(ConnectionProfileName, ConnectionProfile, String, CancellationToken)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> CreateConnectionProfileAsync(ConnectionProfileName parent, ConnectionProfile connectionProfile, string connectionProfileId, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName parent = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
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;
}

CreateConnectionProfileAsync(CreateConnectionProfileRequest, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> CreateConnectionProfileAsync(CreateConnectionProfileRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// 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;
}

CreateConnectionProfileAsync(CreateConnectionProfileRequest, CancellationToken)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> CreateConnectionProfileAsync(CreateConnectionProfileRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateConnectionProfileRequest request = new CreateConnectionProfileRequest
{
    ParentAsConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
    ConnectionProfileId = "",
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// 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;
}

CreateConnectionProfileAsync(String, ConnectionProfile, String, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> CreateConnectionProfileAsync(string parent, ConnectionProfile connectionProfile, string connectionProfileId, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
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;
}

CreateConnectionProfileAsync(String, ConnectionProfile, String, CancellationToken)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> CreateConnectionProfileAsync(string parent, ConnectionProfile connectionProfile, string connectionProfileId, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
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;
}

CreateMigrationJob(LocationName, MigrationJob, String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> CreateMigrationJob(LocationName parent, MigrationJob migrationJob, string migrationJobId, CallSettings callSettings = null)

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

CreateMigrationJob(CreateMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> CreateMigrationJob(CreateMigrationJobRequest request, CallSettings callSettings = null)

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

CreateMigrationJob(String, MigrationJob, String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> CreateMigrationJob(string parent, MigrationJob migrationJob, string migrationJobId, CallSettings callSettings = null)

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

CreateMigrationJobAsync(LocationName, MigrationJob, String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> CreateMigrationJobAsync(LocationName parent, MigrationJob migrationJob, string migrationJobId, CallSettings callSettings = null)

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

CreateMigrationJobAsync(LocationName, MigrationJob, String, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> CreateMigrationJobAsync(LocationName parent, MigrationJob migrationJob, string migrationJobId, CancellationToken cancellationToken)

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

CreateMigrationJobAsync(CreateMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> CreateMigrationJobAsync(CreateMigrationJobRequest request, CallSettings callSettings = null)

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

CreateMigrationJobAsync(CreateMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> CreateMigrationJobAsync(CreateMigrationJobRequest request, CancellationToken cancellationToken)

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

CreateMigrationJobAsync(String, MigrationJob, String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> CreateMigrationJobAsync(string parent, MigrationJob migrationJob, string migrationJobId, CallSettings callSettings = null)

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

CreateMigrationJobAsync(String, MigrationJob, String, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> CreateMigrationJobAsync(string parent, MigrationJob migrationJob, string migrationJobId, CancellationToken cancellationToken)

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

DeleteConnectionProfile(ConnectionProfileName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteConnectionProfile(ConnectionProfileName name, CallSettings callSettings = null)

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

DeleteConnectionProfile(DeleteConnectionProfileRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteConnectionProfile(DeleteConnectionProfileRequest request, CallSettings callSettings = null)

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

DeleteConnectionProfile(String, CallSettings)

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

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

DeleteConnectionProfileAsync(ConnectionProfileName, CallSettings)

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

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

DeleteConnectionProfileAsync(ConnectionProfileName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteConnectionProfileAsync(ConnectionProfileName name, CancellationToken cancellationToken)

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

DeleteConnectionProfileAsync(DeleteConnectionProfileRequest, CallSettings)

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

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

DeleteConnectionProfileAsync(DeleteConnectionProfileRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteConnectionProfileAsync(DeleteConnectionProfileRequest request, CancellationToken cancellationToken)

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

DeleteConnectionProfileAsync(String, CallSettings)

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

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

DeleteConnectionProfileAsync(String, CancellationToken)

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

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

DeleteMigrationJob(DeleteMigrationJobRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteMigrationJob(DeleteMigrationJobRequest request, CallSettings callSettings = null)

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

DeleteMigrationJob(MigrationJobName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteMigrationJob(MigrationJobName name, CallSettings callSettings = null)

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

DeleteMigrationJob(String, CallSettings)

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

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

DeleteMigrationJobAsync(DeleteMigrationJobRequest, CallSettings)

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

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

DeleteMigrationJobAsync(DeleteMigrationJobRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteMigrationJobAsync(DeleteMigrationJobRequest request, CancellationToken cancellationToken)

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

DeleteMigrationJobAsync(MigrationJobName, CallSettings)

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

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

DeleteMigrationJobAsync(MigrationJobName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteMigrationJobAsync(MigrationJobName name, CancellationToken cancellationToken)

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

DeleteMigrationJobAsync(String, CallSettings)

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

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

DeleteMigrationJobAsync(String, CancellationToken)

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

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

GenerateSshScript(GenerateSshScriptRequest, CallSettings)

public virtual SshScript GenerateSshScript(GenerateSshScriptRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
GenerateSshScriptRequest request = new GenerateSshScriptRequest
{
    MigrationJobAsMigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
    Vm = "",
    VmPort = 0,
    VmCreationConfig = new VmCreationConfig(),
};
// Make the request
SshScript response = dataMigrationServiceClient.GenerateSshScript(request);

GenerateSshScriptAsync(GenerateSshScriptRequest, CallSettings)

public virtual Task<SshScript> GenerateSshScriptAsync(GenerateSshScriptRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
GenerateSshScriptRequest request = new GenerateSshScriptRequest
{
    MigrationJobAsMigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
    Vm = "",
    VmPort = 0,
    VmCreationConfig = new VmCreationConfig(),
};
// Make the request
SshScript response = await dataMigrationServiceClient.GenerateSshScriptAsync(request);

GenerateSshScriptAsync(GenerateSshScriptRequest, CancellationToken)

public virtual Task<SshScript> GenerateSshScriptAsync(GenerateSshScriptRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
GenerateSshScriptRequest request = new GenerateSshScriptRequest
{
    MigrationJobAsMigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
    Vm = "",
    VmPort = 0,
    VmCreationConfig = new VmCreationConfig(),
};
// Make the request
SshScript response = await dataMigrationServiceClient.GenerateSshScriptAsync(request);

GetConnectionProfile(ConnectionProfileName, CallSettings)

public virtual ConnectionProfile GetConnectionProfile(ConnectionProfileName name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
ConnectionProfile response = dataMigrationServiceClient.GetConnectionProfile(name);

GetConnectionProfile(GetConnectionProfileRequest, CallSettings)

public virtual ConnectionProfile GetConnectionProfile(GetConnectionProfileRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
GetConnectionProfileRequest request = new GetConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
};
// Make the request
ConnectionProfile response = dataMigrationServiceClient.GetConnectionProfile(request);

GetConnectionProfile(String, CallSettings)

public virtual ConnectionProfile GetConnectionProfile(string name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
ConnectionProfile response = dataMigrationServiceClient.GetConnectionProfile(name);

GetConnectionProfileAsync(ConnectionProfileName, CallSettings)

public virtual Task<ConnectionProfile> GetConnectionProfileAsync(ConnectionProfileName name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
ConnectionProfile response = await dataMigrationServiceClient.GetConnectionProfileAsync(name);

GetConnectionProfileAsync(ConnectionProfileName, CancellationToken)

public virtual Task<ConnectionProfile> GetConnectionProfileAsync(ConnectionProfileName name, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfileName name = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]");
// Make the request
ConnectionProfile response = await dataMigrationServiceClient.GetConnectionProfileAsync(name);

GetConnectionProfileAsync(GetConnectionProfileRequest, CallSettings)

public virtual Task<ConnectionProfile> GetConnectionProfileAsync(GetConnectionProfileRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
GetConnectionProfileRequest request = new GetConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
};
// Make the request
ConnectionProfile response = await dataMigrationServiceClient.GetConnectionProfileAsync(request);

GetConnectionProfileAsync(GetConnectionProfileRequest, CancellationToken)

public virtual Task<ConnectionProfile> GetConnectionProfileAsync(GetConnectionProfileRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
GetConnectionProfileRequest request = new GetConnectionProfileRequest
{
    ConnectionProfileName = ConnectionProfileName.FromProjectLocationConnectionProfile("[PROJECT]", "[LOCATION]", "[CONNECTION_PROFILE]"),
};
// Make the request
ConnectionProfile response = await dataMigrationServiceClient.GetConnectionProfileAsync(request);

GetConnectionProfileAsync(String, CallSettings)

public virtual Task<ConnectionProfile> GetConnectionProfileAsync(string name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
ConnectionProfile response = await dataMigrationServiceClient.GetConnectionProfileAsync(name);

GetConnectionProfileAsync(String, CancellationToken)

public virtual Task<ConnectionProfile> GetConnectionProfileAsync(string name, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/connectionProfiles/[CONNECTION_PROFILE]";
// Make the request
ConnectionProfile response = await dataMigrationServiceClient.GetConnectionProfileAsync(name);

GetMigrationJob(GetMigrationJobRequest, CallSettings)

public virtual MigrationJob GetMigrationJob(GetMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
GetMigrationJobRequest request = new GetMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
MigrationJob response = dataMigrationServiceClient.GetMigrationJob(request);

GetMigrationJob(MigrationJobName, CallSettings)

public virtual MigrationJob GetMigrationJob(MigrationJobName name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
MigrationJobName name = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
// Make the request
MigrationJob response = dataMigrationServiceClient.GetMigrationJob(name);

GetMigrationJob(String, CallSettings)

public virtual MigrationJob GetMigrationJob(string name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/migrationJobs/[MIGRATION_JOB]";
// Make the request
MigrationJob response = dataMigrationServiceClient.GetMigrationJob(name);

GetMigrationJobAsync(GetMigrationJobRequest, CallSettings)

public virtual Task<MigrationJob> GetMigrationJobAsync(GetMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
GetMigrationJobRequest request = new GetMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
MigrationJob response = await dataMigrationServiceClient.GetMigrationJobAsync(request);

GetMigrationJobAsync(GetMigrationJobRequest, CancellationToken)

public virtual Task<MigrationJob> GetMigrationJobAsync(GetMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
GetMigrationJobRequest request = new GetMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
MigrationJob response = await dataMigrationServiceClient.GetMigrationJobAsync(request);

GetMigrationJobAsync(MigrationJobName, CallSettings)

public virtual Task<MigrationJob> GetMigrationJobAsync(MigrationJobName name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
MigrationJobName name = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
// Make the request
MigrationJob response = await dataMigrationServiceClient.GetMigrationJobAsync(name);

GetMigrationJobAsync(MigrationJobName, CancellationToken)

public virtual Task<MigrationJob> GetMigrationJobAsync(MigrationJobName name, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
MigrationJobName name = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]");
// Make the request
MigrationJob response = await dataMigrationServiceClient.GetMigrationJobAsync(name);

GetMigrationJobAsync(String, CallSettings)

public virtual Task<MigrationJob> GetMigrationJobAsync(string name, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/migrationJobs/[MIGRATION_JOB]";
// Make the request
MigrationJob response = await dataMigrationServiceClient.GetMigrationJobAsync(name);

GetMigrationJobAsync(String, CancellationToken)

public virtual Task<MigrationJob> GetMigrationJobAsync(string name, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/migrationJobs/[MIGRATION_JOB]";
// Make the request
MigrationJob response = await dataMigrationServiceClient.GetMigrationJobAsync(name);

ListConnectionProfiles(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListConnectionProfilesResponse, ConnectionProfile> ListConnectionProfiles(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListConnectionProfilesResponse, ConnectionProfile> response = dataMigrationServiceClient.ListConnectionProfiles(parent);

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

ListConnectionProfiles(ListConnectionProfilesRequest, CallSettings)

public virtual PagedEnumerable<ListConnectionProfilesResponse, ConnectionProfile> ListConnectionProfiles(ListConnectionProfilesRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ListConnectionProfilesRequest request = new ListConnectionProfilesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListConnectionProfilesResponse, ConnectionProfile> response = dataMigrationServiceClient.ListConnectionProfiles(request);

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

ListConnectionProfiles(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListConnectionProfilesResponse, ConnectionProfile> ListConnectionProfiles(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

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

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

ListConnectionProfilesAsync(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListConnectionProfilesResponse, ConnectionProfile> ListConnectionProfilesAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListConnectionProfilesResponse, ConnectionProfile> response = dataMigrationServiceClient.ListConnectionProfilesAsync(parent);

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

ListConnectionProfilesAsync(ListConnectionProfilesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListConnectionProfilesResponse, ConnectionProfile> ListConnectionProfilesAsync(ListConnectionProfilesRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ListConnectionProfilesRequest request = new ListConnectionProfilesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListConnectionProfilesResponse, ConnectionProfile> response = dataMigrationServiceClient.ListConnectionProfilesAsync(request);

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

ListConnectionProfilesAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListConnectionProfilesResponse, ConnectionProfile> ListConnectionProfilesAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListConnectionProfilesResponse, ConnectionProfile> response = dataMigrationServiceClient.ListConnectionProfilesAsync(parent);

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

ListMigrationJobs(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListMigrationJobsResponse, MigrationJob> ListMigrationJobs(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListMigrationJobsResponse, MigrationJob> response = dataMigrationServiceClient.ListMigrationJobs(parent);

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

ListMigrationJobs(ListMigrationJobsRequest, CallSettings)

public virtual PagedEnumerable<ListMigrationJobsResponse, MigrationJob> ListMigrationJobs(ListMigrationJobsRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ListMigrationJobsRequest request = new ListMigrationJobsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListMigrationJobsResponse, MigrationJob> response = dataMigrationServiceClient.ListMigrationJobs(request);

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

ListMigrationJobs(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListMigrationJobsResponse, MigrationJob> ListMigrationJobs(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

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

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

ListMigrationJobsAsync(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListMigrationJobsResponse, MigrationJob> ListMigrationJobsAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListMigrationJobsResponse, MigrationJob> response = dataMigrationServiceClient.ListMigrationJobsAsync(parent);

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

ListMigrationJobsAsync(ListMigrationJobsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListMigrationJobsResponse, MigrationJob> ListMigrationJobsAsync(ListMigrationJobsRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ListMigrationJobsRequest request = new ListMigrationJobsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListMigrationJobsResponse, MigrationJob> response = dataMigrationServiceClient.ListMigrationJobsAsync(request);

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

ListMigrationJobsAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListMigrationJobsResponse, MigrationJob> ListMigrationJobsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListMigrationJobsResponse, MigrationJob> response = dataMigrationServiceClient.ListMigrationJobsAsync(parent);

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

PollOnceCreateConnectionProfile(String, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> PollOnceCreateConnectionProfile(string operationName, CallSettings callSettings = null)

PollOnceCreateConnectionProfileAsync(String, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> PollOnceCreateConnectionProfileAsync(string operationName, CallSettings callSettings = null)

PollOnceCreateMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceCreateMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceCreateMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceCreateMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceDeleteConnectionProfile(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteConnectionProfile(string operationName, CallSettings callSettings = null)

PollOnceDeleteConnectionProfileAsync(String, CallSettings)

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

PollOnceDeleteMigrationJob(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceDeleteMigrationJobAsync(String, CallSettings)

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

PollOncePromoteMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOncePromoteMigrationJob(string operationName, CallSettings callSettings = null)

PollOncePromoteMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOncePromoteMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceRestartMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceRestartMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceRestartMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceRestartMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceResumeMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceResumeMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceResumeMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceResumeMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceStartMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceStartMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceStartMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceStartMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceStopMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceStopMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceStopMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceStopMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateConnectionProfile(String, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> PollOnceUpdateConnectionProfile(string operationName, CallSettings callSettings = null)

PollOnceUpdateConnectionProfileAsync(String, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> PollOnceUpdateConnectionProfileAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceUpdateMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceUpdateMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceUpdateMigrationJobAsync(string operationName, CallSettings callSettings = null)

PollOnceVerifyMigrationJob(String, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PollOnceVerifyMigrationJob(string operationName, CallSettings callSettings = null)

PollOnceVerifyMigrationJobAsync(String, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PollOnceVerifyMigrationJobAsync(string operationName, CallSettings callSettings = null)

PromoteMigrationJob(PromoteMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> PromoteMigrationJob(PromoteMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
PromoteMigrationJobRequest request = new PromoteMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.PromoteMigrationJob(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.PollOncePromoteMigrationJob(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;
}

PromoteMigrationJobAsync(PromoteMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PromoteMigrationJobAsync(PromoteMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
PromoteMigrationJobRequest request = new PromoteMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.PromoteMigrationJobAsync(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.PollOncePromoteMigrationJobAsync(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;
}

PromoteMigrationJobAsync(PromoteMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> PromoteMigrationJobAsync(PromoteMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
PromoteMigrationJobRequest request = new PromoteMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.PromoteMigrationJobAsync(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.PollOncePromoteMigrationJobAsync(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;
}

RestartMigrationJob(RestartMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> RestartMigrationJob(RestartMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
RestartMigrationJobRequest request = new RestartMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.RestartMigrationJob(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.PollOnceRestartMigrationJob(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;
}

RestartMigrationJobAsync(RestartMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> RestartMigrationJobAsync(RestartMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
RestartMigrationJobRequest request = new RestartMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.RestartMigrationJobAsync(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.PollOnceRestartMigrationJobAsync(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;
}

RestartMigrationJobAsync(RestartMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> RestartMigrationJobAsync(RestartMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
RestartMigrationJobRequest request = new RestartMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.RestartMigrationJobAsync(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.PollOnceRestartMigrationJobAsync(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;
}

ResumeMigrationJob(ResumeMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> ResumeMigrationJob(ResumeMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ResumeMigrationJobRequest request = new ResumeMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.ResumeMigrationJob(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.PollOnceResumeMigrationJob(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;
}

ResumeMigrationJobAsync(ResumeMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> ResumeMigrationJobAsync(ResumeMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ResumeMigrationJobRequest request = new ResumeMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.ResumeMigrationJobAsync(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.PollOnceResumeMigrationJobAsync(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;
}

ResumeMigrationJobAsync(ResumeMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> ResumeMigrationJobAsync(ResumeMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ResumeMigrationJobRequest request = new ResumeMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.ResumeMigrationJobAsync(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.PollOnceResumeMigrationJobAsync(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;
}

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

StartMigrationJob(StartMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> StartMigrationJob(StartMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
StartMigrationJobRequest request = new StartMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.StartMigrationJob(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.PollOnceStartMigrationJob(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;
}

StartMigrationJobAsync(StartMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> StartMigrationJobAsync(StartMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
StartMigrationJobRequest request = new StartMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.StartMigrationJobAsync(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.PollOnceStartMigrationJobAsync(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;
}

StartMigrationJobAsync(StartMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> StartMigrationJobAsync(StartMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
StartMigrationJobRequest request = new StartMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.StartMigrationJobAsync(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.PollOnceStartMigrationJobAsync(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;
}

StopMigrationJob(StopMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> StopMigrationJob(StopMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
StopMigrationJobRequest request = new StopMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.StopMigrationJob(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.PollOnceStopMigrationJob(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;
}

StopMigrationJobAsync(StopMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> StopMigrationJobAsync(StopMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
StopMigrationJobRequest request = new StopMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.StopMigrationJobAsync(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.PollOnceStopMigrationJobAsync(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;
}

StopMigrationJobAsync(StopMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> StopMigrationJobAsync(StopMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
StopMigrationJobRequest request = new StopMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.StopMigrationJobAsync(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.PollOnceStopMigrationJobAsync(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;
}

UpdateConnectionProfile(ConnectionProfile, FieldMask, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> UpdateConnectionProfile(ConnectionProfile connectionProfile, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
ConnectionProfile connectionProfile = new ConnectionProfile();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = dataMigrationServiceClient.UpdateConnectionProfile(connectionProfile, updateMask);

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

UpdateConnectionProfile(UpdateConnectionProfileRequest, CallSettings)

public virtual Operation<ConnectionProfile, OperationMetadata> UpdateConnectionProfile(UpdateConnectionProfileRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
UpdateConnectionProfileRequest request = new UpdateConnectionProfileRequest
{
    UpdateMask = new FieldMask(),
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = dataMigrationServiceClient.UpdateConnectionProfile(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.PollOnceUpdateConnectionProfile(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;
}

UpdateConnectionProfileAsync(ConnectionProfile, FieldMask, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> UpdateConnectionProfileAsync(ConnectionProfile connectionProfile, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfile connectionProfile = new ConnectionProfile();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.UpdateConnectionProfileAsync(connectionProfile, updateMask);

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

UpdateConnectionProfileAsync(ConnectionProfile, FieldMask, CancellationToken)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> UpdateConnectionProfileAsync(ConnectionProfile connectionProfile, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
ConnectionProfile connectionProfile = new ConnectionProfile();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.UpdateConnectionProfileAsync(connectionProfile, updateMask);

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

UpdateConnectionProfileAsync(UpdateConnectionProfileRequest, CallSettings)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> UpdateConnectionProfileAsync(UpdateConnectionProfileRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateConnectionProfileRequest request = new UpdateConnectionProfileRequest
{
    UpdateMask = new FieldMask(),
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.UpdateConnectionProfileAsync(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.PollOnceUpdateConnectionProfileAsync(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;
}

UpdateConnectionProfileAsync(UpdateConnectionProfileRequest, CancellationToken)

public virtual Task<Operation<ConnectionProfile, OperationMetadata>> UpdateConnectionProfileAsync(UpdateConnectionProfileRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateConnectionProfileRequest request = new UpdateConnectionProfileRequest
{
    UpdateMask = new FieldMask(),
    ConnectionProfile = new ConnectionProfile(),
    RequestId = "",
};
// Make the request
Operation<ConnectionProfile, OperationMetadata> response = await dataMigrationServiceClient.UpdateConnectionProfileAsync(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.PollOnceUpdateConnectionProfileAsync(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;
}

UpdateMigrationJob(MigrationJob, FieldMask, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> UpdateMigrationJob(MigrationJob migrationJob, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
MigrationJob migrationJob = new MigrationJob();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.UpdateMigrationJob(migrationJob, updateMask);

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

UpdateMigrationJob(UpdateMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> UpdateMigrationJob(UpdateMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
UpdateMigrationJobRequest request = new UpdateMigrationJobRequest
{
    UpdateMask = new FieldMask(),
    MigrationJob = new MigrationJob(),
    RequestId = "",
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.UpdateMigrationJob(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.PollOnceUpdateMigrationJob(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;
}

UpdateMigrationJobAsync(MigrationJob, FieldMask, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> UpdateMigrationJobAsync(MigrationJob migrationJob, FieldMask updateMask, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
MigrationJob migrationJob = new MigrationJob();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.UpdateMigrationJobAsync(migrationJob, updateMask);

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

UpdateMigrationJobAsync(MigrationJob, FieldMask, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> UpdateMigrationJobAsync(MigrationJob migrationJob, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
MigrationJob migrationJob = new MigrationJob();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.UpdateMigrationJobAsync(migrationJob, updateMask);

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

UpdateMigrationJobAsync(UpdateMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> UpdateMigrationJobAsync(UpdateMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateMigrationJobRequest request = new UpdateMigrationJobRequest
{
    UpdateMask = new FieldMask(),
    MigrationJob = new MigrationJob(),
    RequestId = "",
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.UpdateMigrationJobAsync(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.PollOnceUpdateMigrationJobAsync(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;
}

UpdateMigrationJobAsync(UpdateMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> UpdateMigrationJobAsync(UpdateMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateMigrationJobRequest request = new UpdateMigrationJobRequest
{
    UpdateMask = new FieldMask(),
    MigrationJob = new MigrationJob(),
    RequestId = "",
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.UpdateMigrationJobAsync(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.PollOnceUpdateMigrationJobAsync(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;
}

VerifyMigrationJob(VerifyMigrationJobRequest, CallSettings)

public virtual Operation<MigrationJob, OperationMetadata> VerifyMigrationJob(VerifyMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = DataMigrationServiceClient.Create();
// Initialize request argument(s)
VerifyMigrationJobRequest request = new VerifyMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = dataMigrationServiceClient.VerifyMigrationJob(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.PollOnceVerifyMigrationJob(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;
}

VerifyMigrationJobAsync(VerifyMigrationJobRequest, CallSettings)

public virtual Task<Operation<MigrationJob, OperationMetadata>> VerifyMigrationJobAsync(VerifyMigrationJobRequest request, CallSettings callSettings = null)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
VerifyMigrationJobRequest request = new VerifyMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.VerifyMigrationJobAsync(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.PollOnceVerifyMigrationJobAsync(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;
}

VerifyMigrationJobAsync(VerifyMigrationJobRequest, CancellationToken)

public virtual Task<Operation<MigrationJob, OperationMetadata>> VerifyMigrationJobAsync(VerifyMigrationJobRequest request, CancellationToken cancellationToken)

// Create client
DataMigrationServiceClient dataMigrationServiceClient = await DataMigrationServiceClient.CreateAsync();
// Initialize request argument(s)
VerifyMigrationJobRequest request = new VerifyMigrationJobRequest
{
    MigrationJobName = MigrationJobName.FromProjectLocationMigrationJob("[PROJECT]", "[LOCATION]", "[MIGRATION_JOB]"),
};
// Make the request
Operation<MigrationJob, OperationMetadata> response = await dataMigrationServiceClient.VerifyMigrationJobAsync(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.PollOnceVerifyMigrationJobAsync(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;
}