Cloud Dataplex v1 API - Class DataScanServiceClient (3.3.0)

public abstract class DataScanServiceClient

Namespace

Assembly

Google.Cloud.Dataplex.V1.dll

Remarks

Properties

CreateDataScanOperationsClient

public virtual OperationsClient CreateDataScanOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteDataScanOperationsClient

public virtual OperationsClient DeleteDataScanOperationsClient { get; }

GrpcClient

public virtual DataScanService.DataScanServiceClient GrpcClient { get; }

IAMPolicyClient

public virtual IAMPolicyClient IAMPolicyClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

UpdateDataScanOperationsClient

public virtual OperationsClient UpdateDataScanOperationsClient { get; }

Methods

Create()

public static DataScanServiceClient Create()

CreateAsync(CancellationToken)

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

CreateDataScan(LocationName, DataScan, string, CallSettings)

public virtual Operation<DataScan, OperationMetadata> CreateDataScan(LocationName parent, DataScan dataScan, string dataScanId, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::DataScan dataScan = new gcdv::DataScan();
string dataScanId = "";
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = dataScanServiceClient.CreateDataScan(parent, dataScan, dataScanId);

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

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

CreateDataScan(CreateDataScanRequest, CallSettings)

public virtual Operation<DataScan, OperationMetadata> CreateDataScan(CreateDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateDataScanRequest request = new gcdv::CreateDataScanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    DataScan = new gcdv::DataScan(),
    DataScanId = "",
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = dataScanServiceClient.CreateDataScan(request);

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

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

CreateDataScan(string, DataScan, string, CallSettings)

public virtual Operation<DataScan, OperationMetadata> CreateDataScan(string parent, DataScan dataScan, string dataScanId, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::DataScan dataScan = new gcdv::DataScan();
string dataScanId = "";
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = dataScanServiceClient.CreateDataScan(parent, dataScan, dataScanId);

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

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

CreateDataScanAsync(LocationName, DataScan, string, CallSettings)

public virtual Task<Operation<DataScan, OperationMetadata>> CreateDataScanAsync(LocationName parent, DataScan dataScan, string dataScanId, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::DataScan dataScan = new gcdv::DataScan();
string dataScanId = "";
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.CreateDataScanAsync(parent, dataScan, dataScanId);

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

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

CreateDataScanAsync(LocationName, DataScan, string, CancellationToken)

public virtual Task<Operation<DataScan, OperationMetadata>> CreateDataScanAsync(LocationName parent, DataScan dataScan, string dataScanId, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::DataScan dataScan = new gcdv::DataScan();
string dataScanId = "";
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.CreateDataScanAsync(parent, dataScan, dataScanId);

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

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

CreateDataScanAsync(CreateDataScanRequest, CallSettings)

public virtual Task<Operation<DataScan, OperationMetadata>> CreateDataScanAsync(CreateDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateDataScanRequest request = new gcdv::CreateDataScanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    DataScan = new gcdv::DataScan(),
    DataScanId = "",
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.CreateDataScanAsync(request);

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

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

CreateDataScanAsync(CreateDataScanRequest, CancellationToken)

public virtual Task<Operation<DataScan, OperationMetadata>> CreateDataScanAsync(CreateDataScanRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateDataScanRequest request = new gcdv::CreateDataScanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    DataScan = new gcdv::DataScan(),
    DataScanId = "",
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.CreateDataScanAsync(request);

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

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

CreateDataScanAsync(string, DataScan, string, CallSettings)

public virtual Task<Operation<DataScan, OperationMetadata>> CreateDataScanAsync(string parent, DataScan dataScan, string dataScanId, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::DataScan dataScan = new gcdv::DataScan();
string dataScanId = "";
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.CreateDataScanAsync(parent, dataScan, dataScanId);

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

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

CreateDataScanAsync(string, DataScan, string, CancellationToken)

public virtual Task<Operation<DataScan, OperationMetadata>> CreateDataScanAsync(string parent, DataScan dataScan, string dataScanId, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::DataScan dataScan = new gcdv::DataScan();
string dataScanId = "";
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.CreateDataScanAsync(parent, dataScan, dataScanId);

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

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

DeleteDataScan(DataScanName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteDataScan(DataScanName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataScanServiceClient.DeleteDataScan(name);

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

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

DeleteDataScan(DeleteDataScanRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteDataScan(DeleteDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteDataScanRequest request = new gcdv::DeleteDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataScanServiceClient.DeleteDataScan(request);

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

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

DeleteDataScan(string, CallSettings)

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

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataScanServiceClient.DeleteDataScan(name);

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

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

DeleteDataScanAsync(DataScanName, CallSettings)

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

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataScanServiceClient.DeleteDataScanAsync(name);

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

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

DeleteDataScanAsync(DataScanName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteDataScanAsync(DataScanName name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataScanServiceClient.DeleteDataScanAsync(name);

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

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

DeleteDataScanAsync(DeleteDataScanRequest, CallSettings)

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

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteDataScanRequest request = new gcdv::DeleteDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataScanServiceClient.DeleteDataScanAsync(request);

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

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

DeleteDataScanAsync(DeleteDataScanRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteDataScanAsync(DeleteDataScanRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteDataScanRequest request = new gcdv::DeleteDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataScanServiceClient.DeleteDataScanAsync(request);

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

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

DeleteDataScanAsync(string, CallSettings)

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

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataScanServiceClient.DeleteDataScanAsync(name);

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

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

DeleteDataScanAsync(string, CancellationToken)

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

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataScanServiceClient.DeleteDataScanAsync(name);

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

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

GenerateDataQualityRules(GenerateDataQualityRulesRequest, CallSettings)

public virtual GenerateDataQualityRulesResponse GenerateDataQualityRules(GenerateDataQualityRulesRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::GenerateDataQualityRulesRequest request = new gcdv::GenerateDataQualityRulesRequest { Name = "", };
// Make the request
gcdv::GenerateDataQualityRulesResponse response = dataScanServiceClient.GenerateDataQualityRules(request);

GenerateDataQualityRules(string, CallSettings)

public virtual GenerateDataQualityRulesResponse GenerateDataQualityRules(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
gcdv::GenerateDataQualityRulesResponse response = dataScanServiceClient.GenerateDataQualityRules(name);

GenerateDataQualityRulesAsync(GenerateDataQualityRulesRequest, CallSettings)

public virtual Task<GenerateDataQualityRulesResponse> GenerateDataQualityRulesAsync(GenerateDataQualityRulesRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GenerateDataQualityRulesRequest request = new gcdv::GenerateDataQualityRulesRequest { Name = "", };
// Make the request
gcdv::GenerateDataQualityRulesResponse response = await dataScanServiceClient.GenerateDataQualityRulesAsync(request);

GenerateDataQualityRulesAsync(GenerateDataQualityRulesRequest, CancellationToken)

public virtual Task<GenerateDataQualityRulesResponse> GenerateDataQualityRulesAsync(GenerateDataQualityRulesRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GenerateDataQualityRulesRequest request = new gcdv::GenerateDataQualityRulesRequest { Name = "", };
// Make the request
gcdv::GenerateDataQualityRulesResponse response = await dataScanServiceClient.GenerateDataQualityRulesAsync(request);

GenerateDataQualityRulesAsync(string, CallSettings)

public virtual Task<GenerateDataQualityRulesResponse> GenerateDataQualityRulesAsync(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
gcdv::GenerateDataQualityRulesResponse response = await dataScanServiceClient.GenerateDataQualityRulesAsync(name);

GenerateDataQualityRulesAsync(string, CancellationToken)

public virtual Task<GenerateDataQualityRulesResponse> GenerateDataQualityRulesAsync(string name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
gcdv::GenerateDataQualityRulesResponse response = await dataScanServiceClient.GenerateDataQualityRulesAsync(name);

GetDataScan(DataScanName, CallSettings)

public virtual DataScan GetDataScan(DataScanName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
gcdv::DataScan response = dataScanServiceClient.GetDataScan(name);

GetDataScan(GetDataScanRequest, CallSettings)

public virtual DataScan GetDataScan(GetDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::GetDataScanRequest request = new gcdv::GetDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
    View = gcdv::GetDataScanRequest.Types.DataScanView.Unspecified,
};
// Make the request
gcdv::DataScan response = dataScanServiceClient.GetDataScan(request);

GetDataScan(string, CallSettings)

public virtual DataScan GetDataScan(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
gcdv::DataScan response = dataScanServiceClient.GetDataScan(name);

GetDataScanAsync(DataScanName, CallSettings)

public virtual Task<DataScan> GetDataScanAsync(DataScanName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
gcdv::DataScan response = await dataScanServiceClient.GetDataScanAsync(name);

GetDataScanAsync(DataScanName, CancellationToken)

public virtual Task<DataScan> GetDataScanAsync(DataScanName name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
gcdv::DataScan response = await dataScanServiceClient.GetDataScanAsync(name);

GetDataScanAsync(GetDataScanRequest, CallSettings)

public virtual Task<DataScan> GetDataScanAsync(GetDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetDataScanRequest request = new gcdv::GetDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
    View = gcdv::GetDataScanRequest.Types.DataScanView.Unspecified,
};
// Make the request
gcdv::DataScan response = await dataScanServiceClient.GetDataScanAsync(request);

GetDataScanAsync(GetDataScanRequest, CancellationToken)

public virtual Task<DataScan> GetDataScanAsync(GetDataScanRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetDataScanRequest request = new gcdv::GetDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
    View = gcdv::GetDataScanRequest.Types.DataScanView.Unspecified,
};
// Make the request
gcdv::DataScan response = await dataScanServiceClient.GetDataScanAsync(request);

GetDataScanAsync(string, CallSettings)

public virtual Task<DataScan> GetDataScanAsync(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
gcdv::DataScan response = await dataScanServiceClient.GetDataScanAsync(name);

GetDataScanAsync(string, CancellationToken)

public virtual Task<DataScan> GetDataScanAsync(string name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
gcdv::DataScan response = await dataScanServiceClient.GetDataScanAsync(name);

GetDataScanJob(DataScanJobName, CallSettings)

public virtual DataScanJob GetDataScanJob(DataScanJobName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DataScanJobName name = gcdv::DataScanJobName.FromProjectLocationDataScanJob("[PROJECT]", "[LOCATION]", "[DATASCAN]", "[JOB]");
// Make the request
gcdv::DataScanJob response = dataScanServiceClient.GetDataScanJob(name);

GetDataScanJob(GetDataScanJobRequest, CallSettings)

public virtual DataScanJob GetDataScanJob(GetDataScanJobRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::GetDataScanJobRequest request = new gcdv::GetDataScanJobRequest
{
    DataScanJobName = gcdv::DataScanJobName.FromProjectLocationDataScanJob("[PROJECT]", "[LOCATION]", "[DATASCAN]", "[JOB]"),
    View = gcdv::GetDataScanJobRequest.Types.DataScanJobView.Unspecified,
};
// Make the request
gcdv::DataScanJob response = dataScanServiceClient.GetDataScanJob(request);

GetDataScanJob(string, CallSettings)

public virtual DataScanJob GetDataScanJob(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]/jobs/[JOB]";
// Make the request
gcdv::DataScanJob response = dataScanServiceClient.GetDataScanJob(name);

GetDataScanJobAsync(DataScanJobName, CallSettings)

public virtual Task<DataScanJob> GetDataScanJobAsync(DataScanJobName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanJobName name = gcdv::DataScanJobName.FromProjectLocationDataScanJob("[PROJECT]", "[LOCATION]", "[DATASCAN]", "[JOB]");
// Make the request
gcdv::DataScanJob response = await dataScanServiceClient.GetDataScanJobAsync(name);

GetDataScanJobAsync(DataScanJobName, CancellationToken)

public virtual Task<DataScanJob> GetDataScanJobAsync(DataScanJobName name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanJobName name = gcdv::DataScanJobName.FromProjectLocationDataScanJob("[PROJECT]", "[LOCATION]", "[DATASCAN]", "[JOB]");
// Make the request
gcdv::DataScanJob response = await dataScanServiceClient.GetDataScanJobAsync(name);

GetDataScanJobAsync(GetDataScanJobRequest, CallSettings)

public virtual Task<DataScanJob> GetDataScanJobAsync(GetDataScanJobRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetDataScanJobRequest request = new gcdv::GetDataScanJobRequest
{
    DataScanJobName = gcdv::DataScanJobName.FromProjectLocationDataScanJob("[PROJECT]", "[LOCATION]", "[DATASCAN]", "[JOB]"),
    View = gcdv::GetDataScanJobRequest.Types.DataScanJobView.Unspecified,
};
// Make the request
gcdv::DataScanJob response = await dataScanServiceClient.GetDataScanJobAsync(request);

GetDataScanJobAsync(GetDataScanJobRequest, CancellationToken)

public virtual Task<DataScanJob> GetDataScanJobAsync(GetDataScanJobRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetDataScanJobRequest request = new gcdv::GetDataScanJobRequest
{
    DataScanJobName = gcdv::DataScanJobName.FromProjectLocationDataScanJob("[PROJECT]", "[LOCATION]", "[DATASCAN]", "[JOB]"),
    View = gcdv::GetDataScanJobRequest.Types.DataScanJobView.Unspecified,
};
// Make the request
gcdv::DataScanJob response = await dataScanServiceClient.GetDataScanJobAsync(request);

GetDataScanJobAsync(string, CallSettings)

public virtual Task<DataScanJob> GetDataScanJobAsync(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]/jobs/[JOB]";
// Make the request
gcdv::DataScanJob response = await dataScanServiceClient.GetDataScanJobAsync(name);

GetDataScanJobAsync(string, CancellationToken)

public virtual Task<DataScanJob> GetDataScanJobAsync(string name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]/jobs/[JOB]";
// Make the request
gcdv::DataScanJob response = await dataScanServiceClient.GetDataScanJobAsync(name);

ListDataScanJobs(DataScanName, string, int?, CallSettings)

public virtual PagedEnumerable<ListDataScanJobsResponse, DataScanJob> ListDataScanJobs(DataScanName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DataScanName parent = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
PagedEnumerable<gcdv::ListDataScanJobsResponse, gcdv::DataScanJob> response = dataScanServiceClient.ListDataScanJobs(parent);

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

ListDataScanJobs(ListDataScanJobsRequest, CallSettings)

public virtual PagedEnumerable<ListDataScanJobsResponse, DataScanJob> ListDataScanJobs(ListDataScanJobsRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::ListDataScanJobsRequest request = new gcdv::ListDataScanJobsRequest
{
    ParentAsDataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
    Filter = "",
};
// Make the request
PagedEnumerable<gcdv::ListDataScanJobsResponse, gcdv::DataScanJob> response = dataScanServiceClient.ListDataScanJobs(request);

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

ListDataScanJobs(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListDataScanJobsResponse, DataScanJob> ListDataScanJobs(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
PagedEnumerable<gcdv::ListDataScanJobsResponse, gcdv::DataScanJob> response = dataScanServiceClient.ListDataScanJobs(parent);

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

ListDataScanJobsAsync(DataScanName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListDataScanJobsResponse, DataScanJob> ListDataScanJobsAsync(DataScanName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName parent = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
PagedAsyncEnumerable<gcdv::ListDataScanJobsResponse, gcdv::DataScanJob> response = dataScanServiceClient.ListDataScanJobsAsync(parent);

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

ListDataScanJobsAsync(ListDataScanJobsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListDataScanJobsResponse, DataScanJob> ListDataScanJobsAsync(ListDataScanJobsRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListDataScanJobsRequest request = new gcdv::ListDataScanJobsRequest
{
    ParentAsDataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListDataScanJobsResponse, gcdv::DataScanJob> response = dataScanServiceClient.ListDataScanJobsAsync(request);

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

ListDataScanJobsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListDataScanJobsResponse, DataScanJob> ListDataScanJobsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
PagedAsyncEnumerable<gcdv::ListDataScanJobsResponse, gcdv::DataScanJob> response = dataScanServiceClient.ListDataScanJobsAsync(parent);

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

ListDataScans(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListDataScansResponse, DataScan> ListDataScans(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<gcdv::ListDataScansResponse, gcdv::DataScan> response = dataScanServiceClient.ListDataScans(parent);

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

ListDataScans(ListDataScansRequest, CallSettings)

public virtual PagedEnumerable<ListDataScansResponse, DataScan> ListDataScans(ListDataScansRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::ListDataScansRequest request = new gcdv::ListDataScansRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListDataScansResponse, gcdv::DataScan> response = dataScanServiceClient.ListDataScans(request);

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

ListDataScans(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListDataScansResponse, DataScan> ListDataScans(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<gcdv::ListDataScansResponse, gcdv::DataScan> response = dataScanServiceClient.ListDataScans(parent);

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

ListDataScansAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListDataScansResponse, DataScan> ListDataScansAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<gcdv::ListDataScansResponse, gcdv::DataScan> response = dataScanServiceClient.ListDataScansAsync(parent);

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

ListDataScansAsync(ListDataScansRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListDataScansResponse, DataScan> ListDataScansAsync(ListDataScansRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListDataScansRequest request = new gcdv::ListDataScansRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListDataScansResponse, gcdv::DataScan> response = dataScanServiceClient.ListDataScansAsync(request);

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

ListDataScansAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListDataScansResponse, DataScan> ListDataScansAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<gcdv::ListDataScansResponse, gcdv::DataScan> response = dataScanServiceClient.ListDataScansAsync(parent);

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

PollOnceCreateDataScan(string, CallSettings)

public virtual Operation<DataScan, OperationMetadata> PollOnceCreateDataScan(string operationName, CallSettings callSettings = null)

PollOnceCreateDataScanAsync(string, CallSettings)

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

PollOnceDeleteDataScan(string, CallSettings)

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

PollOnceDeleteDataScanAsync(string, CallSettings)

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

PollOnceUpdateDataScan(string, CallSettings)

public virtual Operation<DataScan, OperationMetadata> PollOnceUpdateDataScan(string operationName, CallSettings callSettings = null)

PollOnceUpdateDataScanAsync(string, CallSettings)

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

RunDataScan(DataScanName, CallSettings)

public virtual RunDataScanResponse RunDataScan(DataScanName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
gcdv::RunDataScanResponse response = dataScanServiceClient.RunDataScan(name);

RunDataScan(RunDataScanRequest, CallSettings)

public virtual RunDataScanResponse RunDataScan(RunDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::RunDataScanRequest request = new gcdv::RunDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
};
// Make the request
gcdv::RunDataScanResponse response = dataScanServiceClient.RunDataScan(request);

RunDataScan(string, CallSettings)

public virtual RunDataScanResponse RunDataScan(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
gcdv::RunDataScanResponse response = dataScanServiceClient.RunDataScan(name);

RunDataScanAsync(DataScanName, CallSettings)

public virtual Task<RunDataScanResponse> RunDataScanAsync(DataScanName name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
gcdv::RunDataScanResponse response = await dataScanServiceClient.RunDataScanAsync(name);

RunDataScanAsync(DataScanName, CancellationToken)

public virtual Task<RunDataScanResponse> RunDataScanAsync(DataScanName name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScanName name = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]");
// Make the request
gcdv::RunDataScanResponse response = await dataScanServiceClient.RunDataScanAsync(name);

RunDataScanAsync(RunDataScanRequest, CallSettings)

public virtual Task<RunDataScanResponse> RunDataScanAsync(RunDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::RunDataScanRequest request = new gcdv::RunDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
};
// Make the request
gcdv::RunDataScanResponse response = await dataScanServiceClient.RunDataScanAsync(request);

RunDataScanAsync(RunDataScanRequest, CancellationToken)

public virtual Task<RunDataScanResponse> RunDataScanAsync(RunDataScanRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::RunDataScanRequest request = new gcdv::RunDataScanRequest
{
    DataScanName = gcdv::DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
};
// Make the request
gcdv::RunDataScanResponse response = await dataScanServiceClient.RunDataScanAsync(request);

RunDataScanAsync(string, CallSettings)

public virtual Task<RunDataScanResponse> RunDataScanAsync(string name, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
gcdv::RunDataScanResponse response = await dataScanServiceClient.RunDataScanAsync(name);

RunDataScanAsync(string, CancellationToken)

public virtual Task<RunDataScanResponse> RunDataScanAsync(string name, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/dataScans/[DATASCAN]";
// Make the request
gcdv::RunDataScanResponse response = await dataScanServiceClient.RunDataScanAsync(name);

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

UpdateDataScan(DataScan, FieldMask, CallSettings)

public virtual Operation<DataScan, OperationMetadata> UpdateDataScan(DataScan dataScan, FieldMask updateMask, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::DataScan dataScan = new gcdv::DataScan();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = dataScanServiceClient.UpdateDataScan(dataScan, updateMask);

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

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

UpdateDataScan(UpdateDataScanRequest, CallSettings)

public virtual Operation<DataScan, OperationMetadata> UpdateDataScan(UpdateDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = gcdv::DataScanServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateDataScanRequest request = new gcdv::UpdateDataScanRequest
{
    DataScan = new gcdv::DataScan(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = dataScanServiceClient.UpdateDataScan(request);

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

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

UpdateDataScanAsync(DataScan, FieldMask, CallSettings)

public virtual Task<Operation<DataScan, OperationMetadata>> UpdateDataScanAsync(DataScan dataScan, FieldMask updateMask, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScan dataScan = new gcdv::DataScan();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.UpdateDataScanAsync(dataScan, updateMask);

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

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

UpdateDataScanAsync(DataScan, FieldMask, CancellationToken)

public virtual Task<Operation<DataScan, OperationMetadata>> UpdateDataScanAsync(DataScan dataScan, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DataScan dataScan = new gcdv::DataScan();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.UpdateDataScanAsync(dataScan, updateMask);

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

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

UpdateDataScanAsync(UpdateDataScanRequest, CallSettings)

public virtual Task<Operation<DataScan, OperationMetadata>> UpdateDataScanAsync(UpdateDataScanRequest request, CallSettings callSettings = null)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateDataScanRequest request = new gcdv::UpdateDataScanRequest
{
    DataScan = new gcdv::DataScan(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.UpdateDataScanAsync(request);

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

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

UpdateDataScanAsync(UpdateDataScanRequest, CancellationToken)

public virtual Task<Operation<DataScan, OperationMetadata>> UpdateDataScanAsync(UpdateDataScanRequest request, CancellationToken cancellationToken)

// Create client
gcdv::DataScanServiceClient dataScanServiceClient = await gcdv::DataScanServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateDataScanRequest request = new gcdv::UpdateDataScanRequest
{
    DataScan = new gcdv::DataScan(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::DataScan, gcdv::OperationMetadata> response = await dataScanServiceClient.UpdateDataScanAsync(request);

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

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