Migration Center v1 API - Class MigrationCenterClient (1.3.0)

public abstract class MigrationCenterClient

Namespace

Assembly

Google.Cloud.MigrationCenter.V1.dll

Remarks

Properties

AddAssetsToGroupOperationsClient

public virtual OperationsClient AddAssetsToGroupOperationsClient { get; }

CreateGroupOperationsClient

public virtual OperationsClient CreateGroupOperationsClient { get; }

CreateImportDataFileOperationsClient

public virtual OperationsClient CreateImportDataFileOperationsClient { get; }

CreateImportJobOperationsClient

public virtual OperationsClient CreateImportJobOperationsClient { get; }

CreatePreferenceSetOperationsClient

public virtual OperationsClient CreatePreferenceSetOperationsClient { get; }

CreateReportConfigOperationsClient

public virtual OperationsClient CreateReportConfigOperationsClient { get; }

CreateReportOperationsClient

public virtual OperationsClient CreateReportOperationsClient { get; }

CreateSourceOperationsClient

public virtual OperationsClient CreateSourceOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteGroupOperationsClient

public virtual OperationsClient DeleteGroupOperationsClient { get; }

DeleteImportDataFileOperationsClient

public virtual OperationsClient DeleteImportDataFileOperationsClient { get; }

DeleteImportJobOperationsClient

public virtual OperationsClient DeleteImportJobOperationsClient { get; }

DeletePreferenceSetOperationsClient

public virtual OperationsClient DeletePreferenceSetOperationsClient { get; }

DeleteReportConfigOperationsClient

public virtual OperationsClient DeleteReportConfigOperationsClient { get; }

DeleteReportOperationsClient

public virtual OperationsClient DeleteReportOperationsClient { get; }

DeleteSourceOperationsClient

public virtual OperationsClient DeleteSourceOperationsClient { get; }

GrpcClient

public virtual MigrationCenter.MigrationCenterClient GrpcClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

RemoveAssetsFromGroupOperationsClient

public virtual OperationsClient RemoveAssetsFromGroupOperationsClient { get; }

RunImportJobOperationsClient

public virtual OperationsClient RunImportJobOperationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

UpdateGroupOperationsClient

public virtual OperationsClient UpdateGroupOperationsClient { get; }

UpdateImportJobOperationsClient

public virtual OperationsClient UpdateImportJobOperationsClient { get; }

UpdatePreferenceSetOperationsClient

public virtual OperationsClient UpdatePreferenceSetOperationsClient { get; }

UpdateSettingsOperationsClient

public virtual OperationsClient UpdateSettingsOperationsClient { get; }

UpdateSourceOperationsClient

public virtual OperationsClient UpdateSourceOperationsClient { get; }

ValidateImportJobOperationsClient

public virtual OperationsClient ValidateImportJobOperationsClient { get; }

Methods

AddAssetsToGroup(AddAssetsToGroupRequest, CallSettings)

public virtual Operation<Group, OperationMetadata> AddAssetsToGroup(AddAssetsToGroupRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
AddAssetsToGroupRequest request = new AddAssetsToGroupRequest
{
    GroupAsGroupName = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]"),
    RequestId = "",
    Assets = new AssetList(),
    AllowExisting = false,
};
// Make the request
Operation<Group, OperationMetadata> response = migrationCenterClient.AddAssetsToGroup(request);

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

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

AddAssetsToGroup(GroupName, CallSettings)

public virtual Operation<Group, OperationMetadata> AddAssetsToGroup(GroupName group, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
GroupName group = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]");
// Make the request
Operation<Group, OperationMetadata> response = migrationCenterClient.AddAssetsToGroup(group);

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

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

AddAssetsToGroup(string, CallSettings)

public virtual Operation<Group, OperationMetadata> AddAssetsToGroup(string group, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string group = "projects/[PROJECT]/locations/[LOCATION]/groups/[GROUP]";
// Make the request
Operation<Group, OperationMetadata> response = migrationCenterClient.AddAssetsToGroup(group);

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

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

AddAssetsToGroupAsync(AddAssetsToGroupRequest, CallSettings)

public virtual Task<Operation<Group, OperationMetadata>> AddAssetsToGroupAsync(AddAssetsToGroupRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
AddAssetsToGroupRequest request = new AddAssetsToGroupRequest
{
    GroupAsGroupName = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]"),
    RequestId = "",
    Assets = new AssetList(),
    AllowExisting = false,
};
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.AddAssetsToGroupAsync(request);

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

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

AddAssetsToGroupAsync(AddAssetsToGroupRequest, CancellationToken)

public virtual Task<Operation<Group, OperationMetadata>> AddAssetsToGroupAsync(AddAssetsToGroupRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
AddAssetsToGroupRequest request = new AddAssetsToGroupRequest
{
    GroupAsGroupName = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]"),
    RequestId = "",
    Assets = new AssetList(),
    AllowExisting = false,
};
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.AddAssetsToGroupAsync(request);

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

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

AddAssetsToGroupAsync(GroupName, CallSettings)

public virtual Task<Operation<Group, OperationMetadata>> AddAssetsToGroupAsync(GroupName group, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
GroupName group = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]");
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.AddAssetsToGroupAsync(group);

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

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

AddAssetsToGroupAsync(GroupName, CancellationToken)

public virtual Task<Operation<Group, OperationMetadata>> AddAssetsToGroupAsync(GroupName group, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
GroupName group = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]");
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.AddAssetsToGroupAsync(group);

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

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

AddAssetsToGroupAsync(string, CallSettings)

public virtual Task<Operation<Group, OperationMetadata>> AddAssetsToGroupAsync(string group, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string group = "projects/[PROJECT]/locations/[LOCATION]/groups/[GROUP]";
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.AddAssetsToGroupAsync(group);

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

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

AddAssetsToGroupAsync(string, CancellationToken)

public virtual Task<Operation<Group, OperationMetadata>> AddAssetsToGroupAsync(string group, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string group = "projects/[PROJECT]/locations/[LOCATION]/groups/[GROUP]";
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.AddAssetsToGroupAsync(group);

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

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

AggregateAssetsValues(AggregateAssetsValuesRequest, CallSettings)

public virtual AggregateAssetsValuesResponse AggregateAssetsValues(AggregateAssetsValuesRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
AggregateAssetsValuesRequest request = new AggregateAssetsValuesRequest
{
    Parent = "",
    Aggregations = { new Aggregation(), },
    Filter = "",
};
// Make the request
AggregateAssetsValuesResponse response = migrationCenterClient.AggregateAssetsValues(request);

AggregateAssetsValuesAsync(AggregateAssetsValuesRequest, CallSettings)

public virtual Task<AggregateAssetsValuesResponse> AggregateAssetsValuesAsync(AggregateAssetsValuesRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
AggregateAssetsValuesRequest request = new AggregateAssetsValuesRequest
{
    Parent = "",
    Aggregations = { new Aggregation(), },
    Filter = "",
};
// Make the request
AggregateAssetsValuesResponse response = await migrationCenterClient.AggregateAssetsValuesAsync(request);

AggregateAssetsValuesAsync(AggregateAssetsValuesRequest, CancellationToken)

public virtual Task<AggregateAssetsValuesResponse> AggregateAssetsValuesAsync(AggregateAssetsValuesRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
AggregateAssetsValuesRequest request = new AggregateAssetsValuesRequest
{
    Parent = "",
    Aggregations = { new Aggregation(), },
    Filter = "",
};
// Make the request
AggregateAssetsValuesResponse response = await migrationCenterClient.AggregateAssetsValuesAsync(request);

BatchDeleteAssets(LocationName, IEnumerable<AssetName>, CallSettings)

public virtual void BatchDeleteAssets(LocationName parent, IEnumerable<AssetName> names, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IEnumerable<AssetName> names = new AssetName[]
{
    AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
};
// Make the request
migrationCenterClient.BatchDeleteAssets(parent, names);

BatchDeleteAssets(BatchDeleteAssetsRequest, CallSettings)

public virtual void BatchDeleteAssets(BatchDeleteAssetsRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
BatchDeleteAssetsRequest request = new BatchDeleteAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AssetNames =
    {
        AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    },
    AllowMissing = false,
};
// Make the request
migrationCenterClient.BatchDeleteAssets(request);

BatchDeleteAssets(string, IEnumerable<string>, CallSettings)

public virtual void BatchDeleteAssets(string parent, IEnumerable<string> names, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IEnumerable<string> names = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]",
};
// Make the request
migrationCenterClient.BatchDeleteAssets(parent, names);

BatchDeleteAssetsAsync(LocationName, IEnumerable<AssetName>, CallSettings)

public virtual Task BatchDeleteAssetsAsync(LocationName parent, IEnumerable<AssetName> names, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IEnumerable<AssetName> names = new AssetName[]
{
    AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
};
// Make the request
await migrationCenterClient.BatchDeleteAssetsAsync(parent, names);

BatchDeleteAssetsAsync(LocationName, IEnumerable<AssetName>, CancellationToken)

public virtual Task BatchDeleteAssetsAsync(LocationName parent, IEnumerable<AssetName> names, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IEnumerable<AssetName> names = new AssetName[]
{
    AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
};
// Make the request
await migrationCenterClient.BatchDeleteAssetsAsync(parent, names);

BatchDeleteAssetsAsync(BatchDeleteAssetsRequest, CallSettings)

public virtual Task BatchDeleteAssetsAsync(BatchDeleteAssetsRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
BatchDeleteAssetsRequest request = new BatchDeleteAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AssetNames =
    {
        AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    },
    AllowMissing = false,
};
// Make the request
await migrationCenterClient.BatchDeleteAssetsAsync(request);

BatchDeleteAssetsAsync(BatchDeleteAssetsRequest, CancellationToken)

public virtual Task BatchDeleteAssetsAsync(BatchDeleteAssetsRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
BatchDeleteAssetsRequest request = new BatchDeleteAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AssetNames =
    {
        AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    },
    AllowMissing = false,
};
// Make the request
await migrationCenterClient.BatchDeleteAssetsAsync(request);

BatchDeleteAssetsAsync(string, IEnumerable<string>, CallSettings)

public virtual Task BatchDeleteAssetsAsync(string parent, IEnumerable<string> names, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IEnumerable<string> names = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]",
};
// Make the request
await migrationCenterClient.BatchDeleteAssetsAsync(parent, names);

BatchDeleteAssetsAsync(string, IEnumerable<string>, CancellationToken)

public virtual Task BatchDeleteAssetsAsync(string parent, IEnumerable<string> names, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IEnumerable<string> names = new string[]
{
    "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]",
};
// Make the request
await migrationCenterClient.BatchDeleteAssetsAsync(parent, names);

BatchUpdateAssets(LocationName, IEnumerable<UpdateAssetRequest>, CallSettings)

public virtual BatchUpdateAssetsResponse BatchUpdateAssets(LocationName parent, IEnumerable<UpdateAssetRequest> requests, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IEnumerable<UpdateAssetRequest> requests = new UpdateAssetRequest[]
{
    new UpdateAssetRequest(),
};
// Make the request
BatchUpdateAssetsResponse response = migrationCenterClient.BatchUpdateAssets(parent, requests);

BatchUpdateAssets(BatchUpdateAssetsRequest, CallSettings)

public virtual BatchUpdateAssetsResponse BatchUpdateAssets(BatchUpdateAssetsRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
BatchUpdateAssetsRequest request = new BatchUpdateAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Requests =
    {
        new UpdateAssetRequest(),
    },
};
// Make the request
BatchUpdateAssetsResponse response = migrationCenterClient.BatchUpdateAssets(request);

BatchUpdateAssets(string, IEnumerable<UpdateAssetRequest>, CallSettings)

public virtual BatchUpdateAssetsResponse BatchUpdateAssets(string parent, IEnumerable<UpdateAssetRequest> requests, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IEnumerable<UpdateAssetRequest> requests = new UpdateAssetRequest[]
{
    new UpdateAssetRequest(),
};
// Make the request
BatchUpdateAssetsResponse response = migrationCenterClient.BatchUpdateAssets(parent, requests);

BatchUpdateAssetsAsync(LocationName, IEnumerable<UpdateAssetRequest>, CallSettings)

public virtual Task<BatchUpdateAssetsResponse> BatchUpdateAssetsAsync(LocationName parent, IEnumerable<UpdateAssetRequest> requests, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IEnumerable<UpdateAssetRequest> requests = new UpdateAssetRequest[]
{
    new UpdateAssetRequest(),
};
// Make the request
BatchUpdateAssetsResponse response = await migrationCenterClient.BatchUpdateAssetsAsync(parent, requests);

BatchUpdateAssetsAsync(LocationName, IEnumerable<UpdateAssetRequest>, CancellationToken)

public virtual Task<BatchUpdateAssetsResponse> BatchUpdateAssetsAsync(LocationName parent, IEnumerable<UpdateAssetRequest> requests, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IEnumerable<UpdateAssetRequest> requests = new UpdateAssetRequest[]
{
    new UpdateAssetRequest(),
};
// Make the request
BatchUpdateAssetsResponse response = await migrationCenterClient.BatchUpdateAssetsAsync(parent, requests);

BatchUpdateAssetsAsync(BatchUpdateAssetsRequest, CallSettings)

public virtual Task<BatchUpdateAssetsResponse> BatchUpdateAssetsAsync(BatchUpdateAssetsRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
BatchUpdateAssetsRequest request = new BatchUpdateAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Requests =
    {
        new UpdateAssetRequest(),
    },
};
// Make the request
BatchUpdateAssetsResponse response = await migrationCenterClient.BatchUpdateAssetsAsync(request);

BatchUpdateAssetsAsync(BatchUpdateAssetsRequest, CancellationToken)

public virtual Task<BatchUpdateAssetsResponse> BatchUpdateAssetsAsync(BatchUpdateAssetsRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
BatchUpdateAssetsRequest request = new BatchUpdateAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Requests =
    {
        new UpdateAssetRequest(),
    },
};
// Make the request
BatchUpdateAssetsResponse response = await migrationCenterClient.BatchUpdateAssetsAsync(request);

BatchUpdateAssetsAsync(string, IEnumerable<UpdateAssetRequest>, CallSettings)

public virtual Task<BatchUpdateAssetsResponse> BatchUpdateAssetsAsync(string parent, IEnumerable<UpdateAssetRequest> requests, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IEnumerable<UpdateAssetRequest> requests = new UpdateAssetRequest[]
{
    new UpdateAssetRequest(),
};
// Make the request
BatchUpdateAssetsResponse response = await migrationCenterClient.BatchUpdateAssetsAsync(parent, requests);

BatchUpdateAssetsAsync(string, IEnumerable<UpdateAssetRequest>, CancellationToken)

public virtual Task<BatchUpdateAssetsResponse> BatchUpdateAssetsAsync(string parent, IEnumerable<UpdateAssetRequest> requests, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IEnumerable<UpdateAssetRequest> requests = new UpdateAssetRequest[]
{
    new UpdateAssetRequest(),
};
// Make the request
BatchUpdateAssetsResponse response = await migrationCenterClient.BatchUpdateAssetsAsync(parent, requests);

Create()

public static MigrationCenterClient Create()

CreateAsync(CancellationToken)

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

CreateGroup(LocationName, Group, string, CallSettings)

public virtual Operation<Group, OperationMetadata> CreateGroup(LocationName parent, Group group, string groupId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Group group = new Group();
string groupId = "";
// Make the request
Operation<Group, OperationMetadata> response = migrationCenterClient.CreateGroup(parent, group, groupId);

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

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

CreateGroup(CreateGroupRequest, CallSettings)

public virtual Operation<Group, OperationMetadata> CreateGroup(CreateGroupRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreateGroupRequest request = new CreateGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GroupId = "",
    Group = new Group(),
    RequestId = "",
};
// Make the request
Operation<Group, OperationMetadata> response = migrationCenterClient.CreateGroup(request);

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

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

CreateGroup(string, Group, string, CallSettings)

public virtual Operation<Group, OperationMetadata> CreateGroup(string parent, Group group, string groupId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Group group = new Group();
string groupId = "";
// Make the request
Operation<Group, OperationMetadata> response = migrationCenterClient.CreateGroup(parent, group, groupId);

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

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

CreateGroupAsync(LocationName, Group, string, CallSettings)

public virtual Task<Operation<Group, OperationMetadata>> CreateGroupAsync(LocationName parent, Group group, string groupId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Group group = new Group();
string groupId = "";
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.CreateGroupAsync(parent, group, groupId);

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

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

CreateGroupAsync(LocationName, Group, string, CancellationToken)

public virtual Task<Operation<Group, OperationMetadata>> CreateGroupAsync(LocationName parent, Group group, string groupId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Group group = new Group();
string groupId = "";
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.CreateGroupAsync(parent, group, groupId);

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

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

CreateGroupAsync(CreateGroupRequest, CallSettings)

public virtual Task<Operation<Group, OperationMetadata>> CreateGroupAsync(CreateGroupRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateGroupRequest request = new CreateGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GroupId = "",
    Group = new Group(),
    RequestId = "",
};
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.CreateGroupAsync(request);

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

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

CreateGroupAsync(CreateGroupRequest, CancellationToken)

public virtual Task<Operation<Group, OperationMetadata>> CreateGroupAsync(CreateGroupRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateGroupRequest request = new CreateGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GroupId = "",
    Group = new Group(),
    RequestId = "",
};
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.CreateGroupAsync(request);

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

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

CreateGroupAsync(string, Group, string, CallSettings)

public virtual Task<Operation<Group, OperationMetadata>> CreateGroupAsync(string parent, Group group, string groupId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Group group = new Group();
string groupId = "";
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.CreateGroupAsync(parent, group, groupId);

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

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

CreateGroupAsync(string, Group, string, CancellationToken)

public virtual Task<Operation<Group, OperationMetadata>> CreateGroupAsync(string parent, Group group, string groupId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Group group = new Group();
string groupId = "";
// Make the request
Operation<Group, OperationMetadata> response = await migrationCenterClient.CreateGroupAsync(parent, group, groupId);

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

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

CreateImportDataFile(CreateImportDataFileRequest, CallSettings)

public virtual Operation<ImportDataFile, OperationMetadata> CreateImportDataFile(CreateImportDataFileRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreateImportDataFileRequest request = new CreateImportDataFileRequest
{
    ParentAsImportJobName = ImportJobName.FromProjectLocationImportJob("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]"),
    ImportDataFileId = "",
    ImportDataFile = new ImportDataFile(),
    RequestId = "",
};
// Make the request
Operation<ImportDataFile, OperationMetadata> response = migrationCenterClient.CreateImportDataFile(request);

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

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

CreateImportDataFile(ImportJobName, ImportDataFile, string, CallSettings)

public virtual Operation<ImportDataFile, OperationMetadata> CreateImportDataFile(ImportJobName parent, ImportDataFile importDataFile, string importDataFileId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
ImportJobName parent = ImportJobName.FromProjectLocationImportJob("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]");
ImportDataFile importDataFile = new ImportDataFile();
string importDataFileId = "";
// Make the request
Operation<ImportDataFile, OperationMetadata> response = migrationCenterClient.CreateImportDataFile(parent, importDataFile, importDataFileId);

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

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

CreateImportDataFile(string, ImportDataFile, string, CallSettings)

public virtual Operation<ImportDataFile, OperationMetadata> CreateImportDataFile(string parent, ImportDataFile importDataFile, string importDataFileId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/importJobs/[IMPORT_JOB]";
ImportDataFile importDataFile = new ImportDataFile();
string importDataFileId = "";
// Make the request
Operation<ImportDataFile, OperationMetadata> response = migrationCenterClient.CreateImportDataFile(parent, importDataFile, importDataFileId);

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

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

CreateImportDataFileAsync(CreateImportDataFileRequest, CallSettings)

public virtual Task<Operation<ImportDataFile, OperationMetadata>> CreateImportDataFileAsync(CreateImportDataFileRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateImportDataFileRequest request = new CreateImportDataFileRequest
{
    ParentAsImportJobName = ImportJobName.FromProjectLocationImportJob("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]"),
    ImportDataFileId = "",
    ImportDataFile = new ImportDataFile(),
    RequestId = "",
};
// Make the request
Operation<ImportDataFile, OperationMetadata> response = await migrationCenterClient.CreateImportDataFileAsync(request);

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

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

CreateImportDataFileAsync(CreateImportDataFileRequest, CancellationToken)

public virtual Task<Operation<ImportDataFile, OperationMetadata>> CreateImportDataFileAsync(CreateImportDataFileRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateImportDataFileRequest request = new CreateImportDataFileRequest
{
    ParentAsImportJobName = ImportJobName.FromProjectLocationImportJob("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]"),
    ImportDataFileId = "",
    ImportDataFile = new ImportDataFile(),
    RequestId = "",
};
// Make the request
Operation<ImportDataFile, OperationMetadata> response = await migrationCenterClient.CreateImportDataFileAsync(request);

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

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

CreateImportDataFileAsync(ImportJobName, ImportDataFile, string, CallSettings)

public virtual Task<Operation<ImportDataFile, OperationMetadata>> CreateImportDataFileAsync(ImportJobName parent, ImportDataFile importDataFile, string importDataFileId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
ImportJobName parent = ImportJobName.FromProjectLocationImportJob("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]");
ImportDataFile importDataFile = new ImportDataFile();
string importDataFileId = "";
// Make the request
Operation<ImportDataFile, OperationMetadata> response = await migrationCenterClient.CreateImportDataFileAsync(parent, importDataFile, importDataFileId);

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

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

CreateImportDataFileAsync(ImportJobName, ImportDataFile, string, CancellationToken)

public virtual Task<Operation<ImportDataFile, OperationMetadata>> CreateImportDataFileAsync(ImportJobName parent, ImportDataFile importDataFile, string importDataFileId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
ImportJobName parent = ImportJobName.FromProjectLocationImportJob("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]");
ImportDataFile importDataFile = new ImportDataFile();
string importDataFileId = "";
// Make the request
Operation<ImportDataFile, OperationMetadata> response = await migrationCenterClient.CreateImportDataFileAsync(parent, importDataFile, importDataFileId);

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

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

CreateImportDataFileAsync(string, ImportDataFile, string, CallSettings)

public virtual Task<Operation<ImportDataFile, OperationMetadata>> CreateImportDataFileAsync(string parent, ImportDataFile importDataFile, string importDataFileId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/importJobs/[IMPORT_JOB]";
ImportDataFile importDataFile = new ImportDataFile();
string importDataFileId = "";
// Make the request
Operation<ImportDataFile, OperationMetadata> response = await migrationCenterClient.CreateImportDataFileAsync(parent, importDataFile, importDataFileId);

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

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

CreateImportDataFileAsync(string, ImportDataFile, string, CancellationToken)

public virtual Task<Operation<ImportDataFile, OperationMetadata>> CreateImportDataFileAsync(string parent, ImportDataFile importDataFile, string importDataFileId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/importJobs/[IMPORT_JOB]";
ImportDataFile importDataFile = new ImportDataFile();
string importDataFileId = "";
// Make the request
Operation<ImportDataFile, OperationMetadata> response = await migrationCenterClient.CreateImportDataFileAsync(parent, importDataFile, importDataFileId);

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

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

CreateImportJob(LocationName, ImportJob, string, CallSettings)

public virtual Operation<ImportJob, OperationMetadata> CreateImportJob(LocationName parent, ImportJob importJob, string importJobId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ImportJob importJob = new ImportJob();
string importJobId = "";
// Make the request
Operation<ImportJob, OperationMetadata> response = migrationCenterClient.CreateImportJob(parent, importJob, importJobId);

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

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

CreateImportJob(CreateImportJobRequest, CallSettings)

public virtual Operation<ImportJob, OperationMetadata> CreateImportJob(CreateImportJobRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreateImportJobRequest request = new CreateImportJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ImportJobId = "",
    ImportJob = new ImportJob(),
    RequestId = "",
};
// Make the request
Operation<ImportJob, OperationMetadata> response = migrationCenterClient.CreateImportJob(request);

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

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

CreateImportJob(string, ImportJob, string, CallSettings)

public virtual Operation<ImportJob, OperationMetadata> CreateImportJob(string parent, ImportJob importJob, string importJobId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ImportJob importJob = new ImportJob();
string importJobId = "";
// Make the request
Operation<ImportJob, OperationMetadata> response = migrationCenterClient.CreateImportJob(parent, importJob, importJobId);

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

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

CreateImportJobAsync(LocationName, ImportJob, string, CallSettings)

public virtual Task<Operation<ImportJob, OperationMetadata>> CreateImportJobAsync(LocationName parent, ImportJob importJob, string importJobId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ImportJob importJob = new ImportJob();
string importJobId = "";
// Make the request
Operation<ImportJob, OperationMetadata> response = await migrationCenterClient.CreateImportJobAsync(parent, importJob, importJobId);

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

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

CreateImportJobAsync(LocationName, ImportJob, string, CancellationToken)

public virtual Task<Operation<ImportJob, OperationMetadata>> CreateImportJobAsync(LocationName parent, ImportJob importJob, string importJobId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ImportJob importJob = new ImportJob();
string importJobId = "";
// Make the request
Operation<ImportJob, OperationMetadata> response = await migrationCenterClient.CreateImportJobAsync(parent, importJob, importJobId);

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

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

CreateImportJobAsync(CreateImportJobRequest, CallSettings)

public virtual Task<Operation<ImportJob, OperationMetadata>> CreateImportJobAsync(CreateImportJobRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateImportJobRequest request = new CreateImportJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ImportJobId = "",
    ImportJob = new ImportJob(),
    RequestId = "",
};
// Make the request
Operation<ImportJob, OperationMetadata> response = await migrationCenterClient.CreateImportJobAsync(request);

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

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

CreateImportJobAsync(CreateImportJobRequest, CancellationToken)

public virtual Task<Operation<ImportJob, OperationMetadata>> CreateImportJobAsync(CreateImportJobRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateImportJobRequest request = new CreateImportJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ImportJobId = "",
    ImportJob = new ImportJob(),
    RequestId = "",
};
// Make the request
Operation<ImportJob, OperationMetadata> response = await migrationCenterClient.CreateImportJobAsync(request);

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

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

CreateImportJobAsync(string, ImportJob, string, CallSettings)

public virtual Task<Operation<ImportJob, OperationMetadata>> CreateImportJobAsync(string parent, ImportJob importJob, string importJobId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ImportJob importJob = new ImportJob();
string importJobId = "";
// Make the request
Operation<ImportJob, OperationMetadata> response = await migrationCenterClient.CreateImportJobAsync(parent, importJob, importJobId);

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

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

CreateImportJobAsync(string, ImportJob, string, CancellationToken)

public virtual Task<Operation<ImportJob, OperationMetadata>> CreateImportJobAsync(string parent, ImportJob importJob, string importJobId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ImportJob importJob = new ImportJob();
string importJobId = "";
// Make the request
Operation<ImportJob, OperationMetadata> response = await migrationCenterClient.CreateImportJobAsync(parent, importJob, importJobId);

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

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

CreatePreferenceSet(LocationName, PreferenceSet, string, CallSettings)

public virtual Operation<PreferenceSet, OperationMetadata> CreatePreferenceSet(LocationName parent, PreferenceSet preferenceSet, string preferenceSetId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PreferenceSet preferenceSet = new PreferenceSet();
string preferenceSetId = "";
// Make the request
Operation<PreferenceSet, OperationMetadata> response = migrationCenterClient.CreatePreferenceSet(parent, preferenceSet, preferenceSetId);

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

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

CreatePreferenceSet(CreatePreferenceSetRequest, CallSettings)

public virtual Operation<PreferenceSet, OperationMetadata> CreatePreferenceSet(CreatePreferenceSetRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreatePreferenceSetRequest request = new CreatePreferenceSetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PreferenceSetId = "",
    PreferenceSet = new PreferenceSet(),
    RequestId = "",
};
// Make the request
Operation<PreferenceSet, OperationMetadata> response = migrationCenterClient.CreatePreferenceSet(request);

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

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

CreatePreferenceSet(string, PreferenceSet, string, CallSettings)

public virtual Operation<PreferenceSet, OperationMetadata> CreatePreferenceSet(string parent, PreferenceSet preferenceSet, string preferenceSetId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PreferenceSet preferenceSet = new PreferenceSet();
string preferenceSetId = "";
// Make the request
Operation<PreferenceSet, OperationMetadata> response = migrationCenterClient.CreatePreferenceSet(parent, preferenceSet, preferenceSetId);

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

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

CreatePreferenceSetAsync(LocationName, PreferenceSet, string, CallSettings)

public virtual Task<Operation<PreferenceSet, OperationMetadata>> CreatePreferenceSetAsync(LocationName parent, PreferenceSet preferenceSet, string preferenceSetId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PreferenceSet preferenceSet = new PreferenceSet();
string preferenceSetId = "";
// Make the request
Operation<PreferenceSet, OperationMetadata> response = await migrationCenterClient.CreatePreferenceSetAsync(parent, preferenceSet, preferenceSetId);

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

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

CreatePreferenceSetAsync(LocationName, PreferenceSet, string, CancellationToken)

public virtual Task<Operation<PreferenceSet, OperationMetadata>> CreatePreferenceSetAsync(LocationName parent, PreferenceSet preferenceSet, string preferenceSetId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
PreferenceSet preferenceSet = new PreferenceSet();
string preferenceSetId = "";
// Make the request
Operation<PreferenceSet, OperationMetadata> response = await migrationCenterClient.CreatePreferenceSetAsync(parent, preferenceSet, preferenceSetId);

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

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

CreatePreferenceSetAsync(CreatePreferenceSetRequest, CallSettings)

public virtual Task<Operation<PreferenceSet, OperationMetadata>> CreatePreferenceSetAsync(CreatePreferenceSetRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreatePreferenceSetRequest request = new CreatePreferenceSetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PreferenceSetId = "",
    PreferenceSet = new PreferenceSet(),
    RequestId = "",
};
// Make the request
Operation<PreferenceSet, OperationMetadata> response = await migrationCenterClient.CreatePreferenceSetAsync(request);

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

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

CreatePreferenceSetAsync(CreatePreferenceSetRequest, CancellationToken)

public virtual Task<Operation<PreferenceSet, OperationMetadata>> CreatePreferenceSetAsync(CreatePreferenceSetRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreatePreferenceSetRequest request = new CreatePreferenceSetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    PreferenceSetId = "",
    PreferenceSet = new PreferenceSet(),
    RequestId = "",
};
// Make the request
Operation<PreferenceSet, OperationMetadata> response = await migrationCenterClient.CreatePreferenceSetAsync(request);

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

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

CreatePreferenceSetAsync(string, PreferenceSet, string, CallSettings)

public virtual Task<Operation<PreferenceSet, OperationMetadata>> CreatePreferenceSetAsync(string parent, PreferenceSet preferenceSet, string preferenceSetId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PreferenceSet preferenceSet = new PreferenceSet();
string preferenceSetId = "";
// Make the request
Operation<PreferenceSet, OperationMetadata> response = await migrationCenterClient.CreatePreferenceSetAsync(parent, preferenceSet, preferenceSetId);

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

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

CreatePreferenceSetAsync(string, PreferenceSet, string, CancellationToken)

public virtual Task<Operation<PreferenceSet, OperationMetadata>> CreatePreferenceSetAsync(string parent, PreferenceSet preferenceSet, string preferenceSetId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
PreferenceSet preferenceSet = new PreferenceSet();
string preferenceSetId = "";
// Make the request
Operation<PreferenceSet, OperationMetadata> response = await migrationCenterClient.CreatePreferenceSetAsync(parent, preferenceSet, preferenceSetId);

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

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

CreateReport(CreateReportRequest, CallSettings)

public virtual Operation<Report, OperationMetadata> CreateReport(CreateReportRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreateReportRequest request = new CreateReportRequest
{
    ParentAsReportConfigName = ReportConfigName.FromProjectLocationReportConfig("[PROJECT]", "[LOCATION]", "[REPORT_CONFIG]"),
    ReportId = "",
    Report = new Report(),
    RequestId = "",
};
// Make the request
Operation<Report, OperationMetadata> response = migrationCenterClient.CreateReport(request);

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

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

CreateReport(ReportConfigName, Report, string, CallSettings)

public virtual Operation<Report, OperationMetadata> CreateReport(ReportConfigName parent, Report report, string reportId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
ReportConfigName parent = ReportConfigName.FromProjectLocationReportConfig("[PROJECT]", "[LOCATION]", "[REPORT_CONFIG]");
Report report = new Report();
string reportId = "";
// Make the request
Operation<Report, OperationMetadata> response = migrationCenterClient.CreateReport(parent, report, reportId);

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

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

CreateReport(string, Report, string, CallSettings)

public virtual Operation<Report, OperationMetadata> CreateReport(string parent, Report report, string reportId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/reportConfigs/[REPORT_CONFIG]";
Report report = new Report();
string reportId = "";
// Make the request
Operation<Report, OperationMetadata> response = migrationCenterClient.CreateReport(parent, report, reportId);

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

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

CreateReportAsync(CreateReportRequest, CallSettings)

public virtual Task<Operation<Report, OperationMetadata>> CreateReportAsync(CreateReportRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateReportRequest request = new CreateReportRequest
{
    ParentAsReportConfigName = ReportConfigName.FromProjectLocationReportConfig("[PROJECT]", "[LOCATION]", "[REPORT_CONFIG]"),
    ReportId = "",
    Report = new Report(),
    RequestId = "",
};
// Make the request
Operation<Report, OperationMetadata> response = await migrationCenterClient.CreateReportAsync(request);

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

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

CreateReportAsync(CreateReportRequest, CancellationToken)

public virtual Task<Operation<Report, OperationMetadata>> CreateReportAsync(CreateReportRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateReportRequest request = new CreateReportRequest
{
    ParentAsReportConfigName = ReportConfigName.FromProjectLocationReportConfig("[PROJECT]", "[LOCATION]", "[REPORT_CONFIG]"),
    ReportId = "",
    Report = new Report(),
    RequestId = "",
};
// Make the request
Operation<Report, OperationMetadata> response = await migrationCenterClient.CreateReportAsync(request);

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

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

CreateReportAsync(ReportConfigName, Report, string, CallSettings)

public virtual Task<Operation<Report, OperationMetadata>> CreateReportAsync(ReportConfigName parent, Report report, string reportId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
ReportConfigName parent = ReportConfigName.FromProjectLocationReportConfig("[PROJECT]", "[LOCATION]", "[REPORT_CONFIG]");
Report report = new Report();
string reportId = "";
// Make the request
Operation<Report, OperationMetadata> response = await migrationCenterClient.CreateReportAsync(parent, report, reportId);

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

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

CreateReportAsync(ReportConfigName, Report, string, CancellationToken)

public virtual Task<Operation<Report, OperationMetadata>> CreateReportAsync(ReportConfigName parent, Report report, string reportId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
ReportConfigName parent = ReportConfigName.FromProjectLocationReportConfig("[PROJECT]", "[LOCATION]", "[REPORT_CONFIG]");
Report report = new Report();
string reportId = "";
// Make the request
Operation<Report, OperationMetadata> response = await migrationCenterClient.CreateReportAsync(parent, report, reportId);

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

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

CreateReportAsync(string, Report, string, CallSettings)

public virtual Task<Operation<Report, OperationMetadata>> CreateReportAsync(string parent, Report report, string reportId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/reportConfigs/[REPORT_CONFIG]";
Report report = new Report();
string reportId = "";
// Make the request
Operation<Report, OperationMetadata> response = await migrationCenterClient.CreateReportAsync(parent, report, reportId);

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

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

CreateReportAsync(string, Report, string, CancellationToken)

public virtual Task<Operation<Report, OperationMetadata>> CreateReportAsync(string parent, Report report, string reportId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/reportConfigs/[REPORT_CONFIG]";
Report report = new Report();
string reportId = "";
// Make the request
Operation<Report, OperationMetadata> response = await migrationCenterClient.CreateReportAsync(parent, report, reportId);

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

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

CreateReportConfig(LocationName, ReportConfig, string, CallSettings)

public virtual Operation<ReportConfig, OperationMetadata> CreateReportConfig(LocationName parent, ReportConfig reportConfig, string reportConfigId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ReportConfig reportConfig = new ReportConfig();
string reportConfigId = "";
// Make the request
Operation<ReportConfig, OperationMetadata> response = migrationCenterClient.CreateReportConfig(parent, reportConfig, reportConfigId);

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

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

CreateReportConfig(CreateReportConfigRequest, CallSettings)

public virtual Operation<ReportConfig, OperationMetadata> CreateReportConfig(CreateReportConfigRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreateReportConfigRequest request = new CreateReportConfigRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ReportConfigId = "",
    ReportConfig = new ReportConfig(),
    RequestId = "",
};
// Make the request
Operation<ReportConfig, OperationMetadata> response = migrationCenterClient.CreateReportConfig(request);

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

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

CreateReportConfig(string, ReportConfig, string, CallSettings)

public virtual Operation<ReportConfig, OperationMetadata> CreateReportConfig(string parent, ReportConfig reportConfig, string reportConfigId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ReportConfig reportConfig = new ReportConfig();
string reportConfigId = "";
// Make the request
Operation<ReportConfig, OperationMetadata> response = migrationCenterClient.CreateReportConfig(parent, reportConfig, reportConfigId);

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

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

CreateReportConfigAsync(LocationName, ReportConfig, string, CallSettings)

public virtual Task<Operation<ReportConfig, OperationMetadata>> CreateReportConfigAsync(LocationName parent, ReportConfig reportConfig, string reportConfigId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ReportConfig reportConfig = new ReportConfig();
string reportConfigId = "";
// Make the request
Operation<ReportConfig, OperationMetadata> response = await migrationCenterClient.CreateReportConfigAsync(parent, reportConfig, reportConfigId);

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

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

CreateReportConfigAsync(LocationName, ReportConfig, string, CancellationToken)

public virtual Task<Operation<ReportConfig, OperationMetadata>> CreateReportConfigAsync(LocationName parent, ReportConfig reportConfig, string reportConfigId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ReportConfig reportConfig = new ReportConfig();
string reportConfigId = "";
// Make the request
Operation<ReportConfig, OperationMetadata> response = await migrationCenterClient.CreateReportConfigAsync(parent, reportConfig, reportConfigId);

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

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

CreateReportConfigAsync(CreateReportConfigRequest, CallSettings)

public virtual Task<Operation<ReportConfig, OperationMetadata>> CreateReportConfigAsync(CreateReportConfigRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateReportConfigRequest request = new CreateReportConfigRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ReportConfigId = "",
    ReportConfig = new ReportConfig(),
    RequestId = "",
};
// Make the request
Operation<ReportConfig, OperationMetadata> response = await migrationCenterClient.CreateReportConfigAsync(request);

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

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

CreateReportConfigAsync(CreateReportConfigRequest, CancellationToken)

public virtual Task<Operation<ReportConfig, OperationMetadata>> CreateReportConfigAsync(CreateReportConfigRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateReportConfigRequest request = new CreateReportConfigRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ReportConfigId = "",
    ReportConfig = new ReportConfig(),
    RequestId = "",
};
// Make the request
Operation<ReportConfig, OperationMetadata> response = await migrationCenterClient.CreateReportConfigAsync(request);

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

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

CreateReportConfigAsync(string, ReportConfig, string, CallSettings)

public virtual Task<Operation<ReportConfig, OperationMetadata>> CreateReportConfigAsync(string parent, ReportConfig reportConfig, string reportConfigId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ReportConfig reportConfig = new ReportConfig();
string reportConfigId = "";
// Make the request
Operation<ReportConfig, OperationMetadata> response = await migrationCenterClient.CreateReportConfigAsync(parent, reportConfig, reportConfigId);

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

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

CreateReportConfigAsync(string, ReportConfig, string, CancellationToken)

public virtual Task<Operation<ReportConfig, OperationMetadata>> CreateReportConfigAsync(string parent, ReportConfig reportConfig, string reportConfigId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ReportConfig reportConfig = new ReportConfig();
string reportConfigId = "";
// Make the request
Operation<ReportConfig, OperationMetadata> response = await migrationCenterClient.CreateReportConfigAsync(parent, reportConfig, reportConfigId);

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

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

CreateSource(LocationName, Source, string, CallSettings)

public virtual Operation<Source, OperationMetadata> CreateSource(LocationName parent, Source source, string sourceId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Source source = new Source();
string sourceId = "";
// Make the request
Operation<Source, OperationMetadata> response = migrationCenterClient.CreateSource(parent, source, sourceId);

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

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

CreateSource(CreateSourceRequest, CallSettings)

public virtual Operation<Source, OperationMetadata> CreateSource(CreateSourceRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
CreateSourceRequest request = new CreateSourceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    SourceId = "",
    Source = new Source(),
    RequestId = "",
};
// Make the request
Operation<Source, OperationMetadata> response = migrationCenterClient.CreateSource(request);

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

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

CreateSource(string, Source, string, CallSettings)

public virtual Operation<Source, OperationMetadata> CreateSource(string parent, Source source, string sourceId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Source source = new Source();
string sourceId = "";
// Make the request
Operation<Source, OperationMetadata> response = migrationCenterClient.CreateSource(parent, source, sourceId);

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

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

CreateSourceAsync(LocationName, Source, string, CallSettings)

public virtual Task<Operation<Source, OperationMetadata>> CreateSourceAsync(LocationName parent, Source source, string sourceId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Source source = new Source();
string sourceId = "";
// Make the request
Operation<Source, OperationMetadata> response = await migrationCenterClient.CreateSourceAsync(parent, source, sourceId);

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

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

CreateSourceAsync(LocationName, Source, string, CancellationToken)

public virtual Task<Operation<Source, OperationMetadata>> CreateSourceAsync(LocationName parent, Source source, string sourceId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Source source = new Source();
string sourceId = "";
// Make the request
Operation<Source, OperationMetadata> response = await migrationCenterClient.CreateSourceAsync(parent, source, sourceId);

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

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

CreateSourceAsync(CreateSourceRequest, CallSettings)

public virtual Task<Operation<Source, OperationMetadata>> CreateSourceAsync(CreateSourceRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateSourceRequest request = new CreateSourceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    SourceId = "",
    Source = new Source(),
    RequestId = "",
};
// Make the request
Operation<Source, OperationMetadata> response = await migrationCenterClient.CreateSourceAsync(request);

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

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

CreateSourceAsync(CreateSourceRequest, CancellationToken)

public virtual Task<Operation<Source, OperationMetadata>> CreateSourceAsync(CreateSourceRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
CreateSourceRequest request = new CreateSourceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    SourceId = "",
    Source = new Source(),
    RequestId = "",
};
// Make the request
Operation<Source, OperationMetadata> response = await migrationCenterClient.CreateSourceAsync(request);

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

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

CreateSourceAsync(string, Source, string, CallSettings)

public virtual Task<Operation<Source, OperationMetadata>> CreateSourceAsync(string parent, Source source, string sourceId, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Source source = new Source();
string sourceId = "";
// Make the request
Operation<Source, OperationMetadata> response = await migrationCenterClient.CreateSourceAsync(parent, source, sourceId);

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

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

CreateSourceAsync(string, Source, string, CancellationToken)

public virtual Task<Operation<Source, OperationMetadata>> CreateSourceAsync(string parent, Source source, string sourceId, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Source source = new Source();
string sourceId = "";
// Make the request
Operation<Source, OperationMetadata> response = await migrationCenterClient.CreateSourceAsync(parent, source, sourceId);

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

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

DeleteAsset(AssetName, CallSettings)

public virtual void DeleteAsset(AssetName name, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
migrationCenterClient.DeleteAsset(name);

DeleteAsset(DeleteAssetRequest, CallSettings)

public virtual void DeleteAsset(DeleteAssetRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    RequestId = "",
};
// Make the request
migrationCenterClient.DeleteAsset(request);

DeleteAsset(string, CallSettings)

public virtual void DeleteAsset(string name, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
migrationCenterClient.DeleteAsset(name);

DeleteAssetAsync(AssetName, CallSettings)

public virtual Task DeleteAssetAsync(AssetName name, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
await migrationCenterClient.DeleteAssetAsync(name);

DeleteAssetAsync(AssetName, CancellationToken)

public virtual Task DeleteAssetAsync(AssetName name, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
await migrationCenterClient.DeleteAssetAsync(name);

DeleteAssetAsync(DeleteAssetRequest, CallSettings)

public virtual Task DeleteAssetAsync(DeleteAssetRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    RequestId = "",
};
// Make the request
await migrationCenterClient.DeleteAssetAsync(request);

DeleteAssetAsync(DeleteAssetRequest, CancellationToken)

public virtual Task DeleteAssetAsync(DeleteAssetRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    RequestId = "",
};
// Make the request
await migrationCenterClient.DeleteAssetAsync(request);

DeleteAssetAsync(string, CallSettings)

public virtual Task DeleteAssetAsync(string name, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
await migrationCenterClient.DeleteAssetAsync(name);

DeleteAssetAsync(string, CancellationToken)

public virtual Task DeleteAssetAsync(string name, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
await migrationCenterClient.DeleteAssetAsync(name);

DeleteGroup(DeleteGroupRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteGroup(DeleteGroupRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
DeleteGroupRequest request = new DeleteGroupRequest
{
    GroupName = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = migrationCenterClient.DeleteGroup(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 = migrationCenterClient.PollOnceDeleteGroup(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;
}

DeleteGroup(GroupName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteGroup(GroupName name, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
GroupName name = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]");
// Make the request
Operation<Empty, OperationMetadata> response = migrationCenterClient.DeleteGroup(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 = migrationCenterClient.PollOnceDeleteGroup(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;
}

DeleteGroup(string, CallSettings)

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

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/groups/[GROUP]";
// Make the request
Operation<Empty, OperationMetadata> response = migrationCenterClient.DeleteGroup(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 = migrationCenterClient.PollOnceDeleteGroup(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;
}

DeleteGroupAsync(DeleteGroupRequest, CallSettings)

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

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
DeleteGroupRequest request = new DeleteGroupRequest
{
    GroupName = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await migrationCenterClient.DeleteGroupAsync(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 migrationCenterClient.PollOnceDeleteGroupAsync(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;
}

DeleteGroupAsync(DeleteGroupRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteGroupAsync(DeleteGroupRequest request, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
DeleteGroupRequest request = new DeleteGroupRequest
{
    GroupName = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await migrationCenterClient.DeleteGroupAsync(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 migrationCenterClient.PollOnceDeleteGroupAsync(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;
}

DeleteGroupAsync(GroupName, CallSettings)

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

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
GroupName name = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await migrationCenterClient.DeleteGroupAsync(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 migrationCenterClient.PollOnceDeleteGroupAsync(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;
}

DeleteGroupAsync(GroupName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteGroupAsync(GroupName name, CancellationToken cancellationToken)

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
GroupName name = GroupName.FromProjectLocationGroup("[PROJECT]", "[LOCATION]", "[GROUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await migrationCenterClient.DeleteGroupAsync(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 migrationCenterClient.PollOnceDeleteGroupAsync(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;
}

DeleteGroupAsync(string, CallSettings)

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

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/groups/[GROUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await migrationCenterClient.DeleteGroupAsync(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 migrationCenterClient.PollOnceDeleteGroupAsync(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;
}

DeleteGroupAsync(string, CancellationToken)

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

// Create client
MigrationCenterClient migrationCenterClient = await MigrationCenterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/groups/[GROUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await migrationCenterClient.DeleteGroupAsync(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 migrationCenterClient.PollOnceDeleteGroupAsync(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;
}

DeleteImportDataFile(DeleteImportDataFileRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteImportDataFile(DeleteImportDataFileRequest request, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
DeleteImportDataFileRequest request = new DeleteImportDataFileRequest
{
    ImportDataFileName = ImportDataFileName.FromProjectLocationImportJobImportDataFile("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]", "[IMPORT_DATA_FILE]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = migrationCenterClient.DeleteImportDataFile(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 = migrationCenterClient.PollOnceDeleteImportDataFile(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;
}

DeleteImportDataFile(ImportDataFileName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteImportDataFile(ImportDataFileName name, CallSettings callSettings = null)

// Create client
MigrationCenterClient migrationCenterClient = MigrationCenterClient.Create();
// Initialize request argument(s)
ImportDataFileName name = ImportDataFileName.FromProjectLocationImportJobImportDataFile("[PROJECT]", "[LOCATION]", "[IMPORT_JOB]", "[IMPORT_DATA_FILE]");
// Make the request
Operation<Empty, OperationMetadata> response = migrationCenterClient.DeleteImportDataFile(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 = migrationCenterClient.PollOnceDeleteImportDataFile(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;
}

DeleteImportDataFile(string, CallSettings)

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