Rapid Migration Assessment v1 API - Class RapidMigrationAssessmentClient (1.2.0)

public abstract class RapidMigrationAssessmentClient

Namespace

Assembly

Google.Cloud.RapidMigrationAssessment.V1.dll

Remarks

Properties

CreateAnnotationOperationsClient

public virtual OperationsClient CreateAnnotationOperationsClient { get; }

CreateCollectorOperationsClient

public virtual OperationsClient CreateCollectorOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteCollectorOperationsClient

public virtual OperationsClient DeleteCollectorOperationsClient { get; }

GrpcClient

public virtual RapidMigrationAssessment.RapidMigrationAssessmentClient GrpcClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

PauseCollectorOperationsClient

public virtual OperationsClient PauseCollectorOperationsClient { get; }

RegisterCollectorOperationsClient

public virtual OperationsClient RegisterCollectorOperationsClient { get; }

ResumeCollectorOperationsClient

public virtual OperationsClient ResumeCollectorOperationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

UpdateCollectorOperationsClient

public virtual OperationsClient UpdateCollectorOperationsClient { get; }

Methods

Create()

public static RapidMigrationAssessmentClient Create()

CreateAnnotation(LocationName, Annotation, CallSettings)

public virtual Operation<Annotation, OperationMetadata> CreateAnnotation(LocationName parent, Annotation annotation, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Annotation annotation = new Annotation();
// Make the request
Operation<Annotation, OperationMetadata> response = rapidMigrationAssessmentClient.CreateAnnotation(parent, annotation);

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

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

CreateAnnotation(CreateAnnotationRequest, CallSettings)

public virtual Operation<Annotation, OperationMetadata> CreateAnnotation(CreateAnnotationRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CreateAnnotationRequest request = new CreateAnnotationRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Annotation = new Annotation(),
    RequestId = "",
};
// Make the request
Operation<Annotation, OperationMetadata> response = rapidMigrationAssessmentClient.CreateAnnotation(request);

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

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

CreateAnnotation(string, Annotation, CallSettings)

public virtual Operation<Annotation, OperationMetadata> CreateAnnotation(string parent, Annotation annotation, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Annotation annotation = new Annotation();
// Make the request
Operation<Annotation, OperationMetadata> response = rapidMigrationAssessmentClient.CreateAnnotation(parent, annotation);

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

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

CreateAnnotationAsync(LocationName, Annotation, CallSettings)

public virtual Task<Operation<Annotation, OperationMetadata>> CreateAnnotationAsync(LocationName parent, Annotation annotation, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Annotation annotation = new Annotation();
// Make the request
Operation<Annotation, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateAnnotationAsync(parent, annotation);

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

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

CreateAnnotationAsync(LocationName, Annotation, CancellationToken)

public virtual Task<Operation<Annotation, OperationMetadata>> CreateAnnotationAsync(LocationName parent, Annotation annotation, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Annotation annotation = new Annotation();
// Make the request
Operation<Annotation, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateAnnotationAsync(parent, annotation);

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

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

CreateAnnotationAsync(CreateAnnotationRequest, CallSettings)

public virtual Task<Operation<Annotation, OperationMetadata>> CreateAnnotationAsync(CreateAnnotationRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CreateAnnotationRequest request = new CreateAnnotationRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Annotation = new Annotation(),
    RequestId = "",
};
// Make the request
Operation<Annotation, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateAnnotationAsync(request);

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

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

CreateAnnotationAsync(CreateAnnotationRequest, CancellationToken)

public virtual Task<Operation<Annotation, OperationMetadata>> CreateAnnotationAsync(CreateAnnotationRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CreateAnnotationRequest request = new CreateAnnotationRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Annotation = new Annotation(),
    RequestId = "",
};
// Make the request
Operation<Annotation, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateAnnotationAsync(request);

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

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

CreateAnnotationAsync(string, Annotation, CallSettings)

public virtual Task<Operation<Annotation, OperationMetadata>> CreateAnnotationAsync(string parent, Annotation annotation, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Annotation annotation = new Annotation();
// Make the request
Operation<Annotation, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateAnnotationAsync(parent, annotation);

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

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

CreateAnnotationAsync(string, Annotation, CancellationToken)

public virtual Task<Operation<Annotation, OperationMetadata>> CreateAnnotationAsync(string parent, Annotation annotation, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Annotation annotation = new Annotation();
// Make the request
Operation<Annotation, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateAnnotationAsync(parent, annotation);

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

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

CreateAsync(CancellationToken)

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

CreateCollector(LocationName, Collector, string, CallSettings)

public virtual Operation<Collector, OperationMetadata> CreateCollector(LocationName parent, Collector collector, string collectorId, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Collector collector = new Collector();
string collectorId = "";
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.CreateCollector(parent, collector, collectorId);

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

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

CreateCollector(CreateCollectorRequest, CallSettings)

public virtual Operation<Collector, OperationMetadata> CreateCollector(CreateCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CreateCollectorRequest request = new CreateCollectorRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CollectorId = "",
    Collector = new Collector(),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.CreateCollector(request);

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

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

CreateCollector(string, Collector, string, CallSettings)

public virtual Operation<Collector, OperationMetadata> CreateCollector(string parent, Collector collector, string collectorId, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Collector collector = new Collector();
string collectorId = "";
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.CreateCollector(parent, collector, collectorId);

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

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

CreateCollectorAsync(LocationName, Collector, string, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> CreateCollectorAsync(LocationName parent, Collector collector, string collectorId, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Collector collector = new Collector();
string collectorId = "";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateCollectorAsync(parent, collector, collectorId);

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

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

CreateCollectorAsync(LocationName, Collector, string, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> CreateCollectorAsync(LocationName parent, Collector collector, string collectorId, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Collector collector = new Collector();
string collectorId = "";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateCollectorAsync(parent, collector, collectorId);

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

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

CreateCollectorAsync(CreateCollectorRequest, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> CreateCollectorAsync(CreateCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CreateCollectorRequest request = new CreateCollectorRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CollectorId = "",
    Collector = new Collector(),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateCollectorAsync(request);

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

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

CreateCollectorAsync(CreateCollectorRequest, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> CreateCollectorAsync(CreateCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CreateCollectorRequest request = new CreateCollectorRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CollectorId = "",
    Collector = new Collector(),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateCollectorAsync(request);

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

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

CreateCollectorAsync(string, Collector, string, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> CreateCollectorAsync(string parent, Collector collector, string collectorId, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Collector collector = new Collector();
string collectorId = "";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateCollectorAsync(parent, collector, collectorId);

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

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

CreateCollectorAsync(string, Collector, string, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> CreateCollectorAsync(string parent, Collector collector, string collectorId, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Collector collector = new Collector();
string collectorId = "";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.CreateCollectorAsync(parent, collector, collectorId);

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

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

DeleteCollector(CollectorName, CallSettings)

public virtual Operation<Collector, OperationMetadata> DeleteCollector(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.DeleteCollector(name);

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

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

DeleteCollector(DeleteCollectorRequest, CallSettings)

public virtual Operation<Collector, OperationMetadata> DeleteCollector(DeleteCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
DeleteCollectorRequest request = new DeleteCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.DeleteCollector(request);

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

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

DeleteCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> DeleteCollector(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.DeleteCollector(name);

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

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

DeleteCollectorAsync(CollectorName, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> DeleteCollectorAsync(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.DeleteCollectorAsync(name);

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

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

DeleteCollectorAsync(CollectorName, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> DeleteCollectorAsync(CollectorName name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.DeleteCollectorAsync(name);

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

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

DeleteCollectorAsync(DeleteCollectorRequest, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> DeleteCollectorAsync(DeleteCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
DeleteCollectorRequest request = new DeleteCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.DeleteCollectorAsync(request);

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

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

DeleteCollectorAsync(DeleteCollectorRequest, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> DeleteCollectorAsync(DeleteCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
DeleteCollectorRequest request = new DeleteCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.DeleteCollectorAsync(request);

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

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

DeleteCollectorAsync(string, CallSettings)

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

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.DeleteCollectorAsync(name);

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

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

DeleteCollectorAsync(string, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> DeleteCollectorAsync(string name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.DeleteCollectorAsync(name);

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

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

GetAnnotation(AnnotationName, CallSettings)

public virtual Annotation GetAnnotation(AnnotationName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
AnnotationName name = AnnotationName.FromProjectLocationAnnotation("[PROJECT]", "[LOCATION]", "[ANNOTATION]");
// Make the request
Annotation response = rapidMigrationAssessmentClient.GetAnnotation(name);

GetAnnotation(GetAnnotationRequest, CallSettings)

public virtual Annotation GetAnnotation(GetAnnotationRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
GetAnnotationRequest request = new GetAnnotationRequest
{
    AnnotationName = AnnotationName.FromProjectLocationAnnotation("[PROJECT]", "[LOCATION]", "[ANNOTATION]"),
};
// Make the request
Annotation response = rapidMigrationAssessmentClient.GetAnnotation(request);

GetAnnotation(string, CallSettings)

public virtual Annotation GetAnnotation(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/annotations/[ANNOTATION]";
// Make the request
Annotation response = rapidMigrationAssessmentClient.GetAnnotation(name);

GetAnnotationAsync(AnnotationName, CallSettings)

public virtual Task<Annotation> GetAnnotationAsync(AnnotationName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
AnnotationName name = AnnotationName.FromProjectLocationAnnotation("[PROJECT]", "[LOCATION]", "[ANNOTATION]");
// Make the request
Annotation response = await rapidMigrationAssessmentClient.GetAnnotationAsync(name);

GetAnnotationAsync(AnnotationName, CancellationToken)

public virtual Task<Annotation> GetAnnotationAsync(AnnotationName name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
AnnotationName name = AnnotationName.FromProjectLocationAnnotation("[PROJECT]", "[LOCATION]", "[ANNOTATION]");
// Make the request
Annotation response = await rapidMigrationAssessmentClient.GetAnnotationAsync(name);

GetAnnotationAsync(GetAnnotationRequest, CallSettings)

public virtual Task<Annotation> GetAnnotationAsync(GetAnnotationRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
GetAnnotationRequest request = new GetAnnotationRequest
{
    AnnotationName = AnnotationName.FromProjectLocationAnnotation("[PROJECT]", "[LOCATION]", "[ANNOTATION]"),
};
// Make the request
Annotation response = await rapidMigrationAssessmentClient.GetAnnotationAsync(request);

GetAnnotationAsync(GetAnnotationRequest, CancellationToken)

public virtual Task<Annotation> GetAnnotationAsync(GetAnnotationRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
GetAnnotationRequest request = new GetAnnotationRequest
{
    AnnotationName = AnnotationName.FromProjectLocationAnnotation("[PROJECT]", "[LOCATION]", "[ANNOTATION]"),
};
// Make the request
Annotation response = await rapidMigrationAssessmentClient.GetAnnotationAsync(request);

GetAnnotationAsync(string, CallSettings)

public virtual Task<Annotation> GetAnnotationAsync(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/annotations/[ANNOTATION]";
// Make the request
Annotation response = await rapidMigrationAssessmentClient.GetAnnotationAsync(name);

GetAnnotationAsync(string, CancellationToken)

public virtual Task<Annotation> GetAnnotationAsync(string name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/annotations/[ANNOTATION]";
// Make the request
Annotation response = await rapidMigrationAssessmentClient.GetAnnotationAsync(name);

GetCollector(CollectorName, CallSettings)

public virtual Collector GetCollector(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Collector response = rapidMigrationAssessmentClient.GetCollector(name);

GetCollector(GetCollectorRequest, CallSettings)

public virtual Collector GetCollector(GetCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
GetCollectorRequest request = new GetCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
};
// Make the request
Collector response = rapidMigrationAssessmentClient.GetCollector(request);

GetCollector(string, CallSettings)

public virtual Collector GetCollector(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Collector response = rapidMigrationAssessmentClient.GetCollector(name);

GetCollectorAsync(CollectorName, CallSettings)

public virtual Task<Collector> GetCollectorAsync(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Collector response = await rapidMigrationAssessmentClient.GetCollectorAsync(name);

GetCollectorAsync(CollectorName, CancellationToken)

public virtual Task<Collector> GetCollectorAsync(CollectorName name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Collector response = await rapidMigrationAssessmentClient.GetCollectorAsync(name);

GetCollectorAsync(GetCollectorRequest, CallSettings)

public virtual Task<Collector> GetCollectorAsync(GetCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
GetCollectorRequest request = new GetCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
};
// Make the request
Collector response = await rapidMigrationAssessmentClient.GetCollectorAsync(request);

GetCollectorAsync(GetCollectorRequest, CancellationToken)

public virtual Task<Collector> GetCollectorAsync(GetCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
GetCollectorRequest request = new GetCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
};
// Make the request
Collector response = await rapidMigrationAssessmentClient.GetCollectorAsync(request);

GetCollectorAsync(string, CallSettings)

public virtual Task<Collector> GetCollectorAsync(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Collector response = await rapidMigrationAssessmentClient.GetCollectorAsync(name);

GetCollectorAsync(string, CancellationToken)

public virtual Task<Collector> GetCollectorAsync(string name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Collector response = await rapidMigrationAssessmentClient.GetCollectorAsync(name);

ListCollectors(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListCollectorsResponse, Collector> ListCollectors(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListCollectorsResponse, Collector> response = rapidMigrationAssessmentClient.ListCollectors(parent);

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

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

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

ListCollectors(ListCollectorsRequest, CallSettings)

public virtual PagedEnumerable<ListCollectorsResponse, Collector> ListCollectors(ListCollectorsRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
ListCollectorsRequest request = new ListCollectorsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListCollectorsResponse, Collector> response = rapidMigrationAssessmentClient.ListCollectors(request);

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

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

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

ListCollectors(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListCollectorsResponse, Collector> ListCollectors(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListCollectorsResponse, Collector> response = rapidMigrationAssessmentClient.ListCollectors(parent);

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

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

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

ListCollectorsAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListCollectorsResponse, Collector> ListCollectorsAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListCollectorsResponse, Collector> response = rapidMigrationAssessmentClient.ListCollectorsAsync(parent);

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

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

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

ListCollectorsAsync(ListCollectorsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListCollectorsResponse, Collector> ListCollectorsAsync(ListCollectorsRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
ListCollectorsRequest request = new ListCollectorsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListCollectorsResponse, Collector> response = rapidMigrationAssessmentClient.ListCollectorsAsync(request);

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

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

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

ListCollectorsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListCollectorsResponse, Collector> ListCollectorsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListCollectorsResponse, Collector> response = rapidMigrationAssessmentClient.ListCollectorsAsync(parent);

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

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

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

PauseCollector(CollectorName, CallSettings)

public virtual Operation<Collector, OperationMetadata> PauseCollector(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.PauseCollector(name);

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

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

PauseCollector(PauseCollectorRequest, CallSettings)

public virtual Operation<Collector, OperationMetadata> PauseCollector(PauseCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
PauseCollectorRequest request = new PauseCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.PauseCollector(request);

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

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

PauseCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PauseCollector(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.PauseCollector(name);

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

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

PauseCollectorAsync(CollectorName, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> PauseCollectorAsync(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.PauseCollectorAsync(name);

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

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

PauseCollectorAsync(CollectorName, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> PauseCollectorAsync(CollectorName name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.PauseCollectorAsync(name);

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

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

PauseCollectorAsync(PauseCollectorRequest, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> PauseCollectorAsync(PauseCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
PauseCollectorRequest request = new PauseCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.PauseCollectorAsync(request);

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

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

PauseCollectorAsync(PauseCollectorRequest, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> PauseCollectorAsync(PauseCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
PauseCollectorRequest request = new PauseCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.PauseCollectorAsync(request);

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

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

PauseCollectorAsync(string, CallSettings)

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

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.PauseCollectorAsync(name);

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

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

PauseCollectorAsync(string, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> PauseCollectorAsync(string name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.PauseCollectorAsync(name);

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

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

PollOnceCreateAnnotation(string, CallSettings)

public virtual Operation<Annotation, OperationMetadata> PollOnceCreateAnnotation(string operationName, CallSettings callSettings = null)

PollOnceCreateAnnotationAsync(string, CallSettings)

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

PollOnceCreateCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PollOnceCreateCollector(string operationName, CallSettings callSettings = null)

PollOnceCreateCollectorAsync(string, CallSettings)

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

PollOnceDeleteCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PollOnceDeleteCollector(string operationName, CallSettings callSettings = null)

PollOnceDeleteCollectorAsync(string, CallSettings)

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

PollOncePauseCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PollOncePauseCollector(string operationName, CallSettings callSettings = null)

PollOncePauseCollectorAsync(string, CallSettings)

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

PollOnceRegisterCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PollOnceRegisterCollector(string operationName, CallSettings callSettings = null)

PollOnceRegisterCollectorAsync(string, CallSettings)

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

PollOnceResumeCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PollOnceResumeCollector(string operationName, CallSettings callSettings = null)

PollOnceResumeCollectorAsync(string, CallSettings)

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

PollOnceUpdateCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> PollOnceUpdateCollector(string operationName, CallSettings callSettings = null)

PollOnceUpdateCollectorAsync(string, CallSettings)

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

RegisterCollector(CollectorName, CallSettings)

public virtual Operation<Collector, OperationMetadata> RegisterCollector(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.RegisterCollector(name);

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

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

RegisterCollector(RegisterCollectorRequest, CallSettings)

public virtual Operation<Collector, OperationMetadata> RegisterCollector(RegisterCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
RegisterCollectorRequest request = new RegisterCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.RegisterCollector(request);

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

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

RegisterCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> RegisterCollector(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.RegisterCollector(name);

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

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

RegisterCollectorAsync(CollectorName, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> RegisterCollectorAsync(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.RegisterCollectorAsync(name);

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

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

RegisterCollectorAsync(CollectorName, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> RegisterCollectorAsync(CollectorName name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.RegisterCollectorAsync(name);

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

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

RegisterCollectorAsync(RegisterCollectorRequest, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> RegisterCollectorAsync(RegisterCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
RegisterCollectorRequest request = new RegisterCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.RegisterCollectorAsync(request);

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

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

RegisterCollectorAsync(RegisterCollectorRequest, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> RegisterCollectorAsync(RegisterCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
RegisterCollectorRequest request = new RegisterCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.RegisterCollectorAsync(request);

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

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

RegisterCollectorAsync(string, CallSettings)

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

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.RegisterCollectorAsync(name);

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

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

RegisterCollectorAsync(string, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> RegisterCollectorAsync(string name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.RegisterCollectorAsync(name);

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

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

ResumeCollector(CollectorName, CallSettings)

public virtual Operation<Collector, OperationMetadata> ResumeCollector(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.ResumeCollector(name);

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

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

ResumeCollector(ResumeCollectorRequest, CallSettings)

public virtual Operation<Collector, OperationMetadata> ResumeCollector(ResumeCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
ResumeCollectorRequest request = new ResumeCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.ResumeCollector(request);

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

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

ResumeCollector(string, CallSettings)

public virtual Operation<Collector, OperationMetadata> ResumeCollector(string name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.ResumeCollector(name);

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

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

ResumeCollectorAsync(CollectorName, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> ResumeCollectorAsync(CollectorName name, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.ResumeCollectorAsync(name);

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

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

ResumeCollectorAsync(CollectorName, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> ResumeCollectorAsync(CollectorName name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
CollectorName name = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]");
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.ResumeCollectorAsync(name);

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

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

ResumeCollectorAsync(ResumeCollectorRequest, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> ResumeCollectorAsync(ResumeCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
ResumeCollectorRequest request = new ResumeCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.ResumeCollectorAsync(request);

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

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

ResumeCollectorAsync(ResumeCollectorRequest, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> ResumeCollectorAsync(ResumeCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
ResumeCollectorRequest request = new ResumeCollectorRequest
{
    CollectorName = CollectorName.FromProjectLocationCollector("[PROJECT]", "[LOCATION]", "[COLLECTOR]"),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.ResumeCollectorAsync(request);

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

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

ResumeCollectorAsync(string, CallSettings)

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

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.ResumeCollectorAsync(name);

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

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

ResumeCollectorAsync(string, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> ResumeCollectorAsync(string name, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/collectors/[COLLECTOR]";
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.ResumeCollectorAsync(name);

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

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

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

UpdateCollector(Collector, FieldMask, CallSettings)

public virtual Operation<Collector, OperationMetadata> UpdateCollector(Collector collector, FieldMask updateMask, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
Collector collector = new Collector();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.UpdateCollector(collector, updateMask);

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

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

UpdateCollector(UpdateCollectorRequest, CallSettings)

public virtual Operation<Collector, OperationMetadata> UpdateCollector(UpdateCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = RapidMigrationAssessmentClient.Create();
// Initialize request argument(s)
UpdateCollectorRequest request = new UpdateCollectorRequest
{
    UpdateMask = new FieldMask(),
    Collector = new Collector(),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = rapidMigrationAssessmentClient.UpdateCollector(request);

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

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

UpdateCollectorAsync(Collector, FieldMask, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> UpdateCollectorAsync(Collector collector, FieldMask updateMask, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
Collector collector = new Collector();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.UpdateCollectorAsync(collector, updateMask);

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

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

UpdateCollectorAsync(Collector, FieldMask, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> UpdateCollectorAsync(Collector collector, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
Collector collector = new Collector();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.UpdateCollectorAsync(collector, updateMask);

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

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

UpdateCollectorAsync(UpdateCollectorRequest, CallSettings)

public virtual Task<Operation<Collector, OperationMetadata>> UpdateCollectorAsync(UpdateCollectorRequest request, CallSettings callSettings = null)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
UpdateCollectorRequest request = new UpdateCollectorRequest
{
    UpdateMask = new FieldMask(),
    Collector = new Collector(),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.UpdateCollectorAsync(request);

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

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

UpdateCollectorAsync(UpdateCollectorRequest, CancellationToken)

public virtual Task<Operation<Collector, OperationMetadata>> UpdateCollectorAsync(UpdateCollectorRequest request, CancellationToken cancellationToken)

// Create client
RapidMigrationAssessmentClient rapidMigrationAssessmentClient = await RapidMigrationAssessmentClient.CreateAsync();
// Initialize request argument(s)
UpdateCollectorRequest request = new UpdateCollectorRequest
{
    UpdateMask = new FieldMask(),
    Collector = new Collector(),
    RequestId = "",
};
// Make the request
Operation<Collector, OperationMetadata> response = await rapidMigrationAssessmentClient.UpdateCollectorAsync(request);

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

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