Cloud Dataplex v1 API - Class DataplexServiceClient (3.3.0)

public abstract class DataplexServiceClient

Reference documentation and code samples for the Cloud Dataplex v1 API class DataplexServiceClient.

DataplexService client wrapper, for convenient use.

Inheritance

object > DataplexServiceClient

Namespace

Google.Cloud.Dataplex.V1

Assembly

Google.Cloud.Dataplex.V1.dll

Remarks

Dataplex service provides data lakes as a service. The primary resources offered by this service are Lakes, Zones and Assets which collectively allow a data administrator to organize, manage, secure and catalog data across their organization located across cloud projects in a variety of storage systems including Cloud Storage and BigQuery.

Properties

CreateAssetOperationsClient

public virtual OperationsClient CreateAssetOperationsClient { get; }

The long-running operations client for CreateAsset.

Property Value
Type Description
OperationsClient

CreateEnvironmentOperationsClient

public virtual OperationsClient CreateEnvironmentOperationsClient { get; }

The long-running operations client for CreateEnvironment.

Property Value
Type Description
OperationsClient

CreateLakeOperationsClient

public virtual OperationsClient CreateLakeOperationsClient { get; }

The long-running operations client for CreateLake.

Property Value
Type Description
OperationsClient

CreateTaskOperationsClient

public virtual OperationsClient CreateTaskOperationsClient { get; }

The long-running operations client for CreateTask.

Property Value
Type Description
OperationsClient

CreateZoneOperationsClient

public virtual OperationsClient CreateZoneOperationsClient { get; }

The long-running operations client for CreateZone.

Property Value
Type Description
OperationsClient

DefaultEndpoint

public static string DefaultEndpoint { get; }

The default endpoint for the DataplexService service, which is a host of "dataplex.googleapis.com" and a port of 443.

Property Value
Type Description
string

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

The default DataplexService scopes.

Property Value
Type Description
IReadOnlyListstring
Remarks

The default DataplexService scopes are:

DeleteAssetOperationsClient

public virtual OperationsClient DeleteAssetOperationsClient { get; }

The long-running operations client for DeleteAsset.

Property Value
Type Description
OperationsClient

DeleteEnvironmentOperationsClient

public virtual OperationsClient DeleteEnvironmentOperationsClient { get; }

The long-running operations client for DeleteEnvironment.

Property Value
Type Description
OperationsClient

DeleteLakeOperationsClient

public virtual OperationsClient DeleteLakeOperationsClient { get; }

The long-running operations client for DeleteLake.

Property Value
Type Description
OperationsClient

DeleteTaskOperationsClient

public virtual OperationsClient DeleteTaskOperationsClient { get; }

The long-running operations client for DeleteTask.

Property Value
Type Description
OperationsClient

DeleteZoneOperationsClient

public virtual OperationsClient DeleteZoneOperationsClient { get; }

The long-running operations client for DeleteZone.

Property Value
Type Description
OperationsClient

GrpcClient

public virtual DataplexService.DataplexServiceClient GrpcClient { get; }

The underlying gRPC DataplexService client

Property Value
Type Description
DataplexServiceDataplexServiceClient

IAMPolicyClient

public virtual IAMPolicyClient IAMPolicyClient { get; }

The IAMPolicyClient associated with this client.

Property Value
Type Description
IAMPolicyClient

LocationsClient

public virtual LocationsClient LocationsClient { get; }

The LocationsClient associated with this client.

Property Value
Type Description
LocationsClient

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

The service metadata associated with this client type.

Property Value
Type Description
ServiceMetadata

UpdateAssetOperationsClient

public virtual OperationsClient UpdateAssetOperationsClient { get; }

The long-running operations client for UpdateAsset.

Property Value
Type Description
OperationsClient

UpdateEnvironmentOperationsClient

public virtual OperationsClient UpdateEnvironmentOperationsClient { get; }

The long-running operations client for UpdateEnvironment.

Property Value
Type Description
OperationsClient

UpdateLakeOperationsClient

public virtual OperationsClient UpdateLakeOperationsClient { get; }

The long-running operations client for UpdateLake.

Property Value
Type Description
OperationsClient

UpdateTaskOperationsClient

public virtual OperationsClient UpdateTaskOperationsClient { get; }

The long-running operations client for UpdateTask.

Property Value
Type Description
OperationsClient

UpdateZoneOperationsClient

public virtual OperationsClient UpdateZoneOperationsClient { get; }

The long-running operations client for UpdateZone.

Property Value
Type Description
OperationsClient

Methods

CancelJob(CancelJobRequest, CallSettings)

public virtual void CancelJob(CancelJobRequest request, CallSettings callSettings = null)

Cancel jobs running for the task resource.

Parameters
Name Description
request CancelJobRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::CancelJobRequest request = new gcdv::CancelJobRequest
{
    JobName = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
dataplexServiceClient.CancelJob(request);

CancelJob(JobName, CallSettings)

public virtual void CancelJob(JobName name, CallSettings callSettings = null)

Cancel jobs running for the task resource.

Parameters
Name Description
name JobName

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}/job/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::JobName name = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
dataplexServiceClient.CancelJob(name);

CancelJob(string, CallSettings)

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

Cancel jobs running for the task resource.

Parameters
Name Description
name string

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}/job/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
dataplexServiceClient.CancelJob(name);

CancelJobAsync(CancelJobRequest, CallSettings)

public virtual Task CancelJobAsync(CancelJobRequest request, CallSettings callSettings = null)

Cancel jobs running for the task resource.

Parameters
Name Description
request CancelJobRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Task

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CancelJobRequest request = new gcdv::CancelJobRequest
{
    JobName = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
await dataplexServiceClient.CancelJobAsync(request);

CancelJobAsync(CancelJobRequest, CancellationToken)

public virtual Task CancelJobAsync(CancelJobRequest request, CancellationToken cancellationToken)

Cancel jobs running for the task resource.

Parameters
Name Description
request CancelJobRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
Task

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CancelJobRequest request = new gcdv::CancelJobRequest
{
    JobName = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
await dataplexServiceClient.CancelJobAsync(request);

CancelJobAsync(JobName, CallSettings)

public virtual Task CancelJobAsync(JobName name, CallSettings callSettings = null)

Cancel jobs running for the task resource.

Parameters
Name Description
name JobName

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}/job/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Task

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::JobName name = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
await dataplexServiceClient.CancelJobAsync(name);

CancelJobAsync(JobName, CancellationToken)

public virtual Task CancelJobAsync(JobName name, CancellationToken cancellationToken)

Cancel jobs running for the task resource.

Parameters
Name Description
name JobName

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}/job/{job_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
Task

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::JobName name = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
await dataplexServiceClient.CancelJobAsync(name);

CancelJobAsync(string, CallSettings)

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

Cancel jobs running for the task resource.

Parameters
Name Description
name string

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}/job/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Task

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
await dataplexServiceClient.CancelJobAsync(name);

CancelJobAsync(string, CancellationToken)

public virtual Task CancelJobAsync(string name, CancellationToken cancellationToken)

Cancel jobs running for the task resource.

Parameters
Name Description
name string

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}/job/{job_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
Task

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
await dataplexServiceClient.CancelJobAsync(name);

Create()

public static DataplexServiceClient Create()

Synchronously creates a DataplexServiceClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use DataplexServiceClientBuilder.

Returns
Type Description
DataplexServiceClient

The created DataplexServiceClient.

CreateAsset(CreateAssetRequest, CallSettings)

public virtual Operation<Asset, OperationMetadata> CreateAsset(CreateAssetRequest request, CallSettings callSettings = null)

Creates an asset resource.

Parameters
Name Description
request CreateAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateAssetRequest request = new gcdv::CreateAssetRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
    AssetId = "",
    Asset = new gcdv::Asset(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = dataplexServiceClient.CreateAsset(request);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateAsset(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAsset(ZoneName, Asset, string, CallSettings)

public virtual Operation<Asset, OperationMetadata> CreateAsset(ZoneName parent, Asset asset, string assetId, CallSettings callSettings = null)

Creates an asset resource.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

asset Asset

Required. Asset resource.

assetId string

Required. Asset identifier. This ID will be used to generate names such as table names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the zone.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
gcdv::Asset asset = new gcdv::Asset();
string assetId = "";
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = dataplexServiceClient.CreateAsset(parent, asset, assetId);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateAsset(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAsset(string, Asset, string, CallSettings)

public virtual Operation<Asset, OperationMetadata> CreateAsset(string parent, Asset asset, string assetId, CallSettings callSettings = null)

Creates an asset resource.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

asset Asset

Required. Asset resource.

assetId string

Required. Asset identifier. This ID will be used to generate names such as table names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the zone.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
gcdv::Asset asset = new gcdv::Asset();
string assetId = "";
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = dataplexServiceClient.CreateAsset(parent, asset, assetId);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateAsset(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAssetAsync(CreateAssetRequest, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(CreateAssetRequest request, CallSettings callSettings = null)

Creates an asset resource.

Parameters
Name Description
request CreateAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateAssetRequest request = new gcdv::CreateAssetRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
    AssetId = "",
    Asset = new gcdv::Asset(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(request);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAssetAsync(CreateAssetRequest, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(CreateAssetRequest request, CancellationToken cancellationToken)

Creates an asset resource.

Parameters
Name Description
request CreateAssetRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateAssetRequest request = new gcdv::CreateAssetRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
    AssetId = "",
    Asset = new gcdv::Asset(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(request);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAssetAsync(ZoneName, Asset, string, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(ZoneName parent, Asset asset, string assetId, CallSettings callSettings = null)

Creates an asset resource.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

asset Asset

Required. Asset resource.

assetId string

Required. Asset identifier. This ID will be used to generate names such as table names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the zone.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
gcdv::Asset asset = new gcdv::Asset();
string assetId = "";
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAssetAsync(ZoneName, Asset, string, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(ZoneName parent, Asset asset, string assetId, CancellationToken cancellationToken)

Creates an asset resource.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

asset Asset

Required. Asset resource.

assetId string

Required. Asset identifier. This ID will be used to generate names such as table names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the zone.
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
gcdv::Asset asset = new gcdv::Asset();
string assetId = "";
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAssetAsync(string, Asset, string, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(string parent, Asset asset, string assetId, CallSettings callSettings = null)

Creates an asset resource.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

asset Asset

Required. Asset resource.

assetId string

Required. Asset identifier. This ID will be used to generate names such as table names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the zone.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
gcdv::Asset asset = new gcdv::Asset();
string assetId = "";
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAssetAsync(string, Asset, string, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(string parent, Asset asset, string assetId, CancellationToken cancellationToken)

Creates an asset resource.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

asset Asset

Required. Asset resource.

assetId string

Required. Asset identifier. This ID will be used to generate names such as table names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the zone.
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
gcdv::Asset asset = new gcdv::Asset();
string assetId = "";
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

CreateAsync(CancellationToken)

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

Asynchronously creates a DataplexServiceClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use DataplexServiceClientBuilder.

Parameter
Name Description
cancellationToken CancellationToken

The CancellationToken to use while creating the client.

Returns
Type Description
TaskDataplexServiceClient

The task representing the created DataplexServiceClient.

CreateEnvironment(CreateEnvironmentRequest, CallSettings)

public virtual Operation<Environment, OperationMetadata> CreateEnvironment(CreateEnvironmentRequest request, CallSettings callSettings = null)

Create an environment resource.

Parameters
Name Description
request CreateEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateEnvironmentRequest request = new gcdv::CreateEnvironmentRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    EnvironmentId = "",
    Environment = new gcdv::Environment(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = dataplexServiceClient.CreateEnvironment(request);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateEnvironment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironment(LakeName, Environment, string, CallSettings)

public virtual Operation<Environment, OperationMetadata> CreateEnvironment(LakeName parent, Environment environment, string environmentId, CallSettings callSettings = null)

Create an environment resource.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

environment Environment

Required. Environment resource.

environmentId string

Required. Environment identifier.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must be between 1-63 characters.
  • Must end with a number or a letter.
  • Must be unique within the lake.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = dataplexServiceClient.CreateEnvironment(parent, environment, environmentId);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateEnvironment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironment(string, Environment, string, CallSettings)

public virtual Operation<Environment, OperationMetadata> CreateEnvironment(string parent, Environment environment, string environmentId, CallSettings callSettings = null)

Create an environment resource.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

environment Environment

Required. Environment resource.

environmentId string

Required. Environment identifier.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must be between 1-63 characters.
  • Must end with a number or a letter.
  • Must be unique within the lake.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = dataplexServiceClient.CreateEnvironment(parent, environment, environmentId);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateEnvironment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironmentAsync(CreateEnvironmentRequest, CallSettings)

public virtual Task<Operation<Environment, OperationMetadata>> CreateEnvironmentAsync(CreateEnvironmentRequest request, CallSettings callSettings = null)

Create an environment resource.

Parameters
Name Description
request CreateEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEnvironmentRequest request = new gcdv::CreateEnvironmentRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    EnvironmentId = "",
    Environment = new gcdv::Environment(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(request);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironmentAsync(CreateEnvironmentRequest, CancellationToken)

public virtual Task<Operation<Environment, OperationMetadata>> CreateEnvironmentAsync(CreateEnvironmentRequest request, CancellationToken cancellationToken)

Create an environment resource.

Parameters
Name Description
request CreateEnvironmentRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateEnvironmentRequest request = new gcdv::CreateEnvironmentRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    EnvironmentId = "",
    Environment = new gcdv::Environment(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(request);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironmentAsync(LakeName, Environment, string, CallSettings)

public virtual Task<Operation<Environment, OperationMetadata>> CreateEnvironmentAsync(LakeName parent, Environment environment, string environmentId, CallSettings callSettings = null)

Create an environment resource.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

environment Environment

Required. Environment resource.

environmentId string

Required. Environment identifier.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must be between 1-63 characters.
  • Must end with a number or a letter.
  • Must be unique within the lake.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironmentAsync(LakeName, Environment, string, CancellationToken)

public virtual Task<Operation<Environment, OperationMetadata>> CreateEnvironmentAsync(LakeName parent, Environment environment, string environmentId, CancellationToken cancellationToken)

Create an environment resource.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

environment Environment

Required. Environment resource.

environmentId string

Required. Environment identifier.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must be between 1-63 characters.
  • Must end with a number or a letter.
  • Must be unique within the lake.
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironmentAsync(string, Environment, string, CallSettings)

public virtual Task<Operation<Environment, OperationMetadata>> CreateEnvironmentAsync(string parent, Environment environment, string environmentId, CallSettings callSettings = null)

Create an environment resource.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

environment Environment

Required. Environment resource.

environmentId string

Required. Environment identifier.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must be between 1-63 characters.
  • Must end with a number or a letter.
  • Must be unique within the lake.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateEnvironmentAsync(string, Environment, string, CancellationToken)

public virtual Task<Operation<Environment, OperationMetadata>> CreateEnvironmentAsync(string parent, Environment environment, string environmentId, CancellationToken cancellationToken)

Create an environment resource.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

environment Environment

Required. Environment resource.

environmentId string

Required. Environment identifier.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must be between 1-63 characters.
  • Must end with a number or a letter.
  • Must be unique within the lake.
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

CreateLake(LocationName, Lake, string, CallSettings)

public virtual Operation<Lake, OperationMetadata> CreateLake(LocationName parent, Lake lake, string lakeId, CallSettings callSettings = null)

Creates a lake resource.

Parameters
Name Description
parent LocationName

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

lake Lake

Required. Lake resource

lakeId string

Required. Lake identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the customer project / location.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::Lake lake = new gcdv::Lake();
string lakeId = "";
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = dataplexServiceClient.CreateLake(parent, lake, lakeId);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateLake(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLake(CreateLakeRequest, CallSettings)

public virtual Operation<Lake, OperationMetadata> CreateLake(CreateLakeRequest request, CallSettings callSettings = null)

Creates a lake resource.

Parameters
Name Description
request CreateLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateLakeRequest request = new gcdv::CreateLakeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    LakeId = "",
    Lake = new gcdv::Lake(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = dataplexServiceClient.CreateLake(request);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateLake(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLake(string, Lake, string, CallSettings)

public virtual Operation<Lake, OperationMetadata> CreateLake(string parent, Lake lake, string lakeId, CallSettings callSettings = null)

Creates a lake resource.

Parameters
Name Description
parent string

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

lake Lake

Required. Lake resource

lakeId string

Required. Lake identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the customer project / location.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::Lake lake = new gcdv::Lake();
string lakeId = "";
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = dataplexServiceClient.CreateLake(parent, lake, lakeId);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateLake(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLakeAsync(LocationName, Lake, string, CallSettings)

public virtual Task<Operation<Lake, OperationMetadata>> CreateLakeAsync(LocationName parent, Lake lake, string lakeId, CallSettings callSettings = null)

Creates a lake resource.

Parameters
Name Description
parent LocationName

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

lake Lake

Required. Lake resource

lakeId string

Required. Lake identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the customer project / location.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::Lake lake = new gcdv::Lake();
string lakeId = "";
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLakeAsync(LocationName, Lake, string, CancellationToken)

public virtual Task<Operation<Lake, OperationMetadata>> CreateLakeAsync(LocationName parent, Lake lake, string lakeId, CancellationToken cancellationToken)

Creates a lake resource.

Parameters
Name Description
parent LocationName

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

lake Lake

Required. Lake resource

lakeId string

Required. Lake identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the customer project / location.
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::Lake lake = new gcdv::Lake();
string lakeId = "";
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLakeAsync(CreateLakeRequest, CallSettings)

public virtual Task<Operation<Lake, OperationMetadata>> CreateLakeAsync(CreateLakeRequest request, CallSettings callSettings = null)

Creates a lake resource.

Parameters
Name Description
request CreateLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateLakeRequest request = new gcdv::CreateLakeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    LakeId = "",
    Lake = new gcdv::Lake(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(request);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLakeAsync(CreateLakeRequest, CancellationToken)

public virtual Task<Operation<Lake, OperationMetadata>> CreateLakeAsync(CreateLakeRequest request, CancellationToken cancellationToken)

Creates a lake resource.

Parameters
Name Description
request CreateLakeRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateLakeRequest request = new gcdv::CreateLakeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    LakeId = "",
    Lake = new gcdv::Lake(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(request);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLakeAsync(string, Lake, string, CallSettings)

public virtual Task<Operation<Lake, OperationMetadata>> CreateLakeAsync(string parent, Lake lake, string lakeId, CallSettings callSettings = null)

Creates a lake resource.

Parameters
Name Description
parent string

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

lake Lake

Required. Lake resource

lakeId string

Required. Lake identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the customer project / location.
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::Lake lake = new gcdv::Lake();
string lakeId = "";
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateLakeAsync(string, Lake, string, CancellationToken)

public virtual Task<Operation<Lake, OperationMetadata>> CreateLakeAsync(string parent, Lake lake, string lakeId, CancellationToken cancellationToken)

Creates a lake resource.

Parameters
Name Description
parent string

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

lake Lake

Required. Lake resource

lakeId string

Required. Lake identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique within the customer project / location.
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::Lake lake = new gcdv::Lake();
string lakeId = "";
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

CreateTask(CreateTaskRequest, CallSettings)

public virtual Operation<Task, OperationMetadata> CreateTask(CreateTaskRequest request, CallSettings callSettings = null)

Creates a task resource within a lake.

Parameters
Name Description
request CreateTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateTaskRequest request = new gcdv::CreateTaskRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    TaskId = "",
    Task = new gcdv::Task(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = dataplexServiceClient.CreateTask(request);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateTask(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTask(LakeName, Task, string, CallSettings)

public virtual Operation<Task, OperationMetadata> CreateTask(LakeName parent, Task task, string taskId, CallSettings callSettings = null)

Creates a task resource within a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

task Task

Required. Task resource.

taskId string

Required. Task identifier.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = dataplexServiceClient.CreateTask(parent, task, taskId);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateTask(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTask(string, Task, string, CallSettings)

public virtual Operation<Task, OperationMetadata> CreateTask(string parent, Task task, string taskId, CallSettings callSettings = null)

Creates a task resource within a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

task Task

Required. Task resource.

taskId string

Required. Task identifier.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = dataplexServiceClient.CreateTask(parent, task, taskId);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateTask(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTaskAsync(CreateTaskRequest, CallSettings)

public virtual Task<Operation<Task, OperationMetadata>> CreateTaskAsync(CreateTaskRequest request, CallSettings callSettings = null)

Creates a task resource within a lake.

Parameters
Name Description
request CreateTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateTaskRequest request = new gcdv::CreateTaskRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    TaskId = "",
    Task = new gcdv::Task(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(request);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTaskAsync(CreateTaskRequest, CancellationToken)

public virtual Task<Operation<Task, OperationMetadata>> CreateTaskAsync(CreateTaskRequest request, CancellationToken cancellationToken)

Creates a task resource within a lake.

Parameters
Name Description
request CreateTaskRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateTaskRequest request = new gcdv::CreateTaskRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    TaskId = "",
    Task = new gcdv::Task(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(request);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTaskAsync(LakeName, Task, string, CallSettings)

public virtual Task<Operation<Task, OperationMetadata>> CreateTaskAsync(LakeName parent, Task task, string taskId, CallSettings callSettings = null)

Creates a task resource within a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

task Task

Required. Task resource.

taskId string

Required. Task identifier.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTaskAsync(LakeName, Task, string, CancellationToken)

public virtual Task<Operation<Task, OperationMetadata>> CreateTaskAsync(LakeName parent, Task task, string taskId, CancellationToken cancellationToken)

Creates a task resource within a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

task Task

Required. Task resource.

taskId string

Required. Task identifier.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTaskAsync(string, Task, string, CallSettings)

public virtual Task<Operation<Task, OperationMetadata>> CreateTaskAsync(string parent, Task task, string taskId, CallSettings callSettings = null)

Creates a task resource within a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

task Task

Required. Task resource.

taskId string

Required. Task identifier.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateTaskAsync(string, Task, string, CancellationToken)

public virtual Task<Operation<Task, OperationMetadata>> CreateTaskAsync(string parent, Task task, string taskId, CancellationToken cancellationToken)

Creates a task resource within a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

task Task

Required. Task resource.

taskId string

Required. Task identifier.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

CreateZone(CreateZoneRequest, CallSettings)

public virtual Operation<Zone, OperationMetadata> CreateZone(CreateZoneRequest request, CallSettings callSettings = null)

Creates a zone resource within a lake.

Parameters
Name Description
request CreateZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateZoneRequest request = new gcdv::CreateZoneRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    ZoneId = "",
    Zone = new gcdv::Zone(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = dataplexServiceClient.CreateZone(request);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZone(LakeName, Zone, string, CallSettings)

public virtual Operation<Zone, OperationMetadata> CreateZone(LakeName parent, Zone zone, string zoneId, CallSettings callSettings = null)

Creates a zone resource within a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

zone Zone

Required. Zone resource.

zoneId string

Required. Zone identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique across all lakes from all locations in a project.
  • Must not be one of the reserved IDs (i.e. "default", "global-temp")
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Zone zone = new gcdv::Zone();
string zoneId = "";
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = dataplexServiceClient.CreateZone(parent, zone, zoneId);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZone(string, Zone, string, CallSettings)

public virtual Operation<Zone, OperationMetadata> CreateZone(string parent, Zone zone, string zoneId, CallSettings callSettings = null)

Creates a zone resource within a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

zone Zone

Required. Zone resource.

zoneId string

Required. Zone identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique across all lakes from all locations in a project.
  • Must not be one of the reserved IDs (i.e. "default", "global-temp")
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Zone zone = new gcdv::Zone();
string zoneId = "";
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = dataplexServiceClient.CreateZone(parent, zone, zoneId);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceCreateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(CreateZoneRequest, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(CreateZoneRequest request, CallSettings callSettings = null)

Creates a zone resource within a lake.

Parameters
Name Description
request CreateZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateZoneRequest request = new gcdv::CreateZoneRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    ZoneId = "",
    Zone = new gcdv::Zone(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(request);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(CreateZoneRequest, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(CreateZoneRequest request, CancellationToken cancellationToken)

Creates a zone resource within a lake.

Parameters
Name Description
request CreateZoneRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateZoneRequest request = new gcdv::CreateZoneRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    ZoneId = "",
    Zone = new gcdv::Zone(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(request);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(LakeName, Zone, string, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(LakeName parent, Zone zone, string zoneId, CallSettings callSettings = null)

Creates a zone resource within a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

zone Zone

Required. Zone resource.

zoneId string

Required. Zone identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique across all lakes from all locations in a project.
  • Must not be one of the reserved IDs (i.e. "default", "global-temp")
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Zone zone = new gcdv::Zone();
string zoneId = "";
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(LakeName, Zone, string, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(LakeName parent, Zone zone, string zoneId, CancellationToken cancellationToken)

Creates a zone resource within a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

zone Zone

Required. Zone resource.

zoneId string

Required. Zone identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique across all lakes from all locations in a project.
  • Must not be one of the reserved IDs (i.e. "default", "global-temp")
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Zone zone = new gcdv::Zone();
string zoneId = "";
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(string, Zone, string, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(string parent, Zone zone, string zoneId, CallSettings callSettings = null)

Creates a zone resource within a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

zone Zone

Required. Zone resource.

zoneId string

Required. Zone identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique across all lakes from all locations in a project.
  • Must not be one of the reserved IDs (i.e. "default", "global-temp")
callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Zone zone = new gcdv::Zone();
string zoneId = "";
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

CreateZoneAsync(string, Zone, string, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> CreateZoneAsync(string parent, Zone zone, string zoneId, CancellationToken cancellationToken)

Creates a zone resource within a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

zone Zone

Required. Zone resource.

zoneId string

Required. Zone identifier. This ID will be used to generate names such as database and dataset names when publishing metadata to Hive Metastore and BigQuery.

  • Must contain only lowercase letters, numbers and hyphens.
  • Must start with a letter.
  • Must end with a number or a letter.
  • Must be between 1-63 characters.
  • Must be unique across all lakes from all locations in a project.
  • Must not be one of the reserved IDs (i.e. "default", "global-temp")
cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
gcdv::Zone zone = new gcdv::Zone();
string zoneId = "";
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceCreateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

DeleteAsset(AssetName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAsset(AssetName name, CallSettings callSettings = null)

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
name AssetName

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::AssetName name = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteAsset(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 = dataplexServiceClient.PollOnceDeleteAsset(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;
}

DeleteAsset(DeleteAssetRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAsset(DeleteAssetRequest request, CallSettings callSettings = null)

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
request DeleteAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteAssetRequest request = new gcdv::DeleteAssetRequest
{
    AssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteAsset(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 = dataplexServiceClient.PollOnceDeleteAsset(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;
}

DeleteAsset(string, CallSettings)

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

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
name string

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteAsset(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 = dataplexServiceClient.PollOnceDeleteAsset(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;
}

DeleteAssetAsync(AssetName, CallSettings)

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

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
name AssetName

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AssetName name = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(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 dataplexServiceClient.PollOnceDeleteAssetAsync(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;
}

DeleteAssetAsync(AssetName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(AssetName name, CancellationToken cancellationToken)

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
name AssetName

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AssetName name = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(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 dataplexServiceClient.PollOnceDeleteAssetAsync(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;
}

DeleteAssetAsync(DeleteAssetRequest, CallSettings)

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

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
request DeleteAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteAssetRequest request = new gcdv::DeleteAssetRequest
{
    AssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(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 dataplexServiceClient.PollOnceDeleteAssetAsync(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;
}

DeleteAssetAsync(DeleteAssetRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(DeleteAssetRequest request, CancellationToken cancellationToken)

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
request DeleteAssetRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteAssetRequest request = new gcdv::DeleteAssetRequest
{
    AssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(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 dataplexServiceClient.PollOnceDeleteAssetAsync(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;
}

DeleteAssetAsync(string, CallSettings)

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

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
name string

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(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 dataplexServiceClient.PollOnceDeleteAssetAsync(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;
}

DeleteAssetAsync(string, CancellationToken)

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

Deletes an asset resource. The referenced storage resource is detached (default) or deleted based on the associated Lifecycle policy.

Parameters
Name Description
name string

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(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 dataplexServiceClient.PollOnceDeleteAssetAsync(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;
}

DeleteEnvironment(DeleteEnvironmentRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteEnvironment(DeleteEnvironmentRequest request, CallSettings callSettings = null)

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
request DeleteEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteEnvironmentRequest request = new gcdv::DeleteEnvironmentRequest
{
    EnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteEnvironment(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 = dataplexServiceClient.PollOnceDeleteEnvironment(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;
}

DeleteEnvironment(EnvironmentName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteEnvironment(EnvironmentName name, CallSettings callSettings = null)

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
name EnvironmentName

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::EnvironmentName name = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteEnvironment(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 = dataplexServiceClient.PollOnceDeleteEnvironment(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;
}

DeleteEnvironment(string, CallSettings)

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

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
name string

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteEnvironment(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 = dataplexServiceClient.PollOnceDeleteEnvironment(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;
}

DeleteEnvironmentAsync(DeleteEnvironmentRequest, CallSettings)

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

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
request DeleteEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEnvironmentRequest request = new gcdv::DeleteEnvironmentRequest
{
    EnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(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 dataplexServiceClient.PollOnceDeleteEnvironmentAsync(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;
}

DeleteEnvironmentAsync(DeleteEnvironmentRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteEnvironmentAsync(DeleteEnvironmentRequest request, CancellationToken cancellationToken)

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
request DeleteEnvironmentRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteEnvironmentRequest request = new gcdv::DeleteEnvironmentRequest
{
    EnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(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 dataplexServiceClient.PollOnceDeleteEnvironmentAsync(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;
}

DeleteEnvironmentAsync(EnvironmentName, CallSettings)

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

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
name EnvironmentName

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EnvironmentName name = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(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 dataplexServiceClient.PollOnceDeleteEnvironmentAsync(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;
}

DeleteEnvironmentAsync(EnvironmentName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteEnvironmentAsync(EnvironmentName name, CancellationToken cancellationToken)

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
name EnvironmentName

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EnvironmentName name = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(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 dataplexServiceClient.PollOnceDeleteEnvironmentAsync(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;
}

DeleteEnvironmentAsync(string, CallSettings)

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

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
name string

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(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 dataplexServiceClient.PollOnceDeleteEnvironmentAsync(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;
}

DeleteEnvironmentAsync(string, CancellationToken)

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

Delete the environment resource. All the child resources must have been deleted before environment deletion can be initiated.

Parameters
Name Description
name string

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(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 dataplexServiceClient.PollOnceDeleteEnvironmentAsync(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;
}

DeleteLake(DeleteLakeRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteLake(DeleteLakeRequest request, CallSettings callSettings = null)

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
request DeleteLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteLakeRequest request = new gcdv::DeleteLakeRequest
{
    LakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteLake(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 = dataplexServiceClient.PollOnceDeleteLake(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;
}

DeleteLake(LakeName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteLake(LakeName name, CallSettings callSettings = null)

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
name LakeName

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteLake(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 = dataplexServiceClient.PollOnceDeleteLake(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;
}

DeleteLake(string, CallSettings)

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

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
name string

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteLake(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 = dataplexServiceClient.PollOnceDeleteLake(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;
}

DeleteLakeAsync(DeleteLakeRequest, CallSettings)

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

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
request DeleteLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteLakeRequest request = new gcdv::DeleteLakeRequest
{
    LakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(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 dataplexServiceClient.PollOnceDeleteLakeAsync(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;
}

DeleteLakeAsync(DeleteLakeRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteLakeAsync(DeleteLakeRequest request, CancellationToken cancellationToken)

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
request DeleteLakeRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteLakeRequest request = new gcdv::DeleteLakeRequest
{
    LakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(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 dataplexServiceClient.PollOnceDeleteLakeAsync(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;
}

DeleteLakeAsync(LakeName, CallSettings)

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

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
name LakeName

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(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 dataplexServiceClient.PollOnceDeleteLakeAsync(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;
}

DeleteLakeAsync(LakeName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteLakeAsync(LakeName name, CancellationToken cancellationToken)

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
name LakeName

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(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 dataplexServiceClient.PollOnceDeleteLakeAsync(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;
}

DeleteLakeAsync(string, CallSettings)

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

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
name string

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(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 dataplexServiceClient.PollOnceDeleteLakeAsync(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;
}

DeleteLakeAsync(string, CancellationToken)

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

Deletes a lake resource. All zones within the lake must be deleted before the lake can be deleted.

Parameters
Name Description
name string

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(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 dataplexServiceClient.PollOnceDeleteLakeAsync(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;
}

DeleteTask(DeleteTaskRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteTask(DeleteTaskRequest request, CallSettings callSettings = null)

Delete the task resource.

Parameters
Name Description
request DeleteTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteTaskRequest request = new gcdv::DeleteTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteTask(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 = dataplexServiceClient.PollOnceDeleteTask(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;
}

DeleteTask(TaskName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteTask(TaskName name, CallSettings callSettings = null)

Delete the task resource.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteTask(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 = dataplexServiceClient.PollOnceDeleteTask(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;
}

DeleteTask(string, CallSettings)

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

Delete the task resource.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteTask(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 = dataplexServiceClient.PollOnceDeleteTask(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;
}

DeleteTaskAsync(DeleteTaskRequest, CallSettings)

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

Delete the task resource.

Parameters
Name Description
request DeleteTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteTaskRequest request = new gcdv::DeleteTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(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 dataplexServiceClient.PollOnceDeleteTaskAsync(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;
}

DeleteTaskAsync(DeleteTaskRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteTaskAsync(DeleteTaskRequest request, CancellationToken cancellationToken)

Delete the task resource.

Parameters
Name Description
request DeleteTaskRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteTaskRequest request = new gcdv::DeleteTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(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 dataplexServiceClient.PollOnceDeleteTaskAsync(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;
}

DeleteTaskAsync(TaskName, CallSettings)

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

Delete the task resource.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(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 dataplexServiceClient.PollOnceDeleteTaskAsync(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;
}

DeleteTaskAsync(TaskName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteTaskAsync(TaskName name, CancellationToken cancellationToken)

Delete the task resource.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(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 dataplexServiceClient.PollOnceDeleteTaskAsync(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;
}

DeleteTaskAsync(string, CallSettings)

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

Delete the task resource.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(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 dataplexServiceClient.PollOnceDeleteTaskAsync(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;
}

DeleteTaskAsync(string, CancellationToken)

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

Delete the task resource.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/task/{task_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(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 dataplexServiceClient.PollOnceDeleteTaskAsync(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;
}

DeleteZone(DeleteZoneRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteZone(DeleteZoneRequest request, CallSettings callSettings = null)

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
request DeleteZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteZoneRequest request = new gcdv::DeleteZoneRequest
{
    ZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteZone(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 = dataplexServiceClient.PollOnceDeleteZone(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;
}

DeleteZone(ZoneName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteZone(ZoneName name, CallSettings callSettings = null)

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
name ZoneName

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ZoneName name = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteZone(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 = dataplexServiceClient.PollOnceDeleteZone(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;
}

DeleteZone(string, CallSettings)

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

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
name string

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteZone(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 = dataplexServiceClient.PollOnceDeleteZone(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;
}

DeleteZoneAsync(DeleteZoneRequest, CallSettings)

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

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
request DeleteZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteZoneRequest request = new gcdv::DeleteZoneRequest
{
    ZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(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 dataplexServiceClient.PollOnceDeleteZoneAsync(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;
}

DeleteZoneAsync(DeleteZoneRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(DeleteZoneRequest request, CancellationToken cancellationToken)

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
request DeleteZoneRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteZoneRequest request = new gcdv::DeleteZoneRequest
{
    ZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(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 dataplexServiceClient.PollOnceDeleteZoneAsync(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;
}

DeleteZoneAsync(ZoneName, CallSettings)

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

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
name ZoneName

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName name = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(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 dataplexServiceClient.PollOnceDeleteZoneAsync(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;
}

DeleteZoneAsync(ZoneName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteZoneAsync(ZoneName name, CancellationToken cancellationToken)

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
name ZoneName

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName name = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(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 dataplexServiceClient.PollOnceDeleteZoneAsync(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;
}

DeleteZoneAsync(string, CallSettings)

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

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
name string

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(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 dataplexServiceClient.PollOnceDeleteZoneAsync(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;
}

DeleteZoneAsync(string, CancellationToken)

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

Deletes a zone resource. All assets within a zone must be deleted before the zone can be deleted.

Parameters
Name Description
name string

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(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 dataplexServiceClient.PollOnceDeleteZoneAsync(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;
}

GetAsset(AssetName, CallSettings)

public virtual Asset GetAsset(AssetName name, CallSettings callSettings = null)

Retrieves an asset resource.

Parameters
Name Description
name AssetName

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Asset

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::AssetName name = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
gcdv::Asset response = dataplexServiceClient.GetAsset(name);

GetAsset(GetAssetRequest, CallSettings)

public virtual Asset GetAsset(GetAssetRequest request, CallSettings callSettings = null)

Retrieves an asset resource.

Parameters
Name Description
request GetAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Asset

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::GetAssetRequest request = new gcdv::GetAssetRequest
{
    AssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
gcdv::Asset response = dataplexServiceClient.GetAsset(request);

GetAsset(string, CallSettings)

public virtual Asset GetAsset(string name, CallSettings callSettings = null)

Retrieves an asset resource.

Parameters
Name Description
name string

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Asset

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
gcdv::Asset response = dataplexServiceClient.GetAsset(name);

GetAssetAsync(AssetName, CallSettings)

public virtual Task<Asset> GetAssetAsync(AssetName name, CallSettings callSettings = null)

Retrieves an asset resource.

Parameters
Name Description
name AssetName

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskAsset

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AssetName name = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
gcdv::Asset response = await dataplexServiceClient.GetAssetAsync(name);

GetAssetAsync(AssetName, CancellationToken)

public virtual Task<Asset> GetAssetAsync(AssetName name, CancellationToken cancellationToken)

Retrieves an asset resource.

Parameters
Name Description
name AssetName

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskAsset

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AssetName name = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
gcdv::Asset response = await dataplexServiceClient.GetAssetAsync(name);

GetAssetAsync(GetAssetRequest, CallSettings)

public virtual Task<Asset> GetAssetAsync(GetAssetRequest request, CallSettings callSettings = null)

Retrieves an asset resource.

Parameters
Name Description
request GetAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskAsset

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetAssetRequest request = new gcdv::GetAssetRequest
{
    AssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
gcdv::Asset response = await dataplexServiceClient.GetAssetAsync(request);

GetAssetAsync(GetAssetRequest, CancellationToken)

public virtual Task<Asset> GetAssetAsync(GetAssetRequest request, CancellationToken cancellationToken)

Retrieves an asset resource.

Parameters
Name Description
request GetAssetRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskAsset

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetAssetRequest request = new gcdv::GetAssetRequest
{
    AssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
gcdv::Asset response = await dataplexServiceClient.GetAssetAsync(request);

GetAssetAsync(string, CallSettings)

public virtual Task<Asset> GetAssetAsync(string name, CallSettings callSettings = null)

Retrieves an asset resource.

Parameters
Name Description
name string

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskAsset

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
gcdv::Asset response = await dataplexServiceClient.GetAssetAsync(name);

GetAssetAsync(string, CancellationToken)

public virtual Task<Asset> GetAssetAsync(string name, CancellationToken cancellationToken)

Retrieves an asset resource.

Parameters
Name Description
name string

Required. The resource name of the asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskAsset

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
gcdv::Asset response = await dataplexServiceClient.GetAssetAsync(name);

GetEnvironment(EnvironmentName, CallSettings)

public virtual Environment GetEnvironment(EnvironmentName name, CallSettings callSettings = null)

Get environment resource.

Parameters
Name Description
name EnvironmentName

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Environment

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::EnvironmentName name = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
gcdv::Environment response = dataplexServiceClient.GetEnvironment(name);

GetEnvironment(GetEnvironmentRequest, CallSettings)

public virtual Environment GetEnvironment(GetEnvironmentRequest request, CallSettings callSettings = null)

Get environment resource.

Parameters
Name Description
request GetEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Environment

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::GetEnvironmentRequest request = new gcdv::GetEnvironmentRequest
{
    EnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
gcdv::Environment response = dataplexServiceClient.GetEnvironment(request);

GetEnvironment(string, CallSettings)

public virtual Environment GetEnvironment(string name, CallSettings callSettings = null)

Get environment resource.

Parameters
Name Description
name string

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Environment

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
gcdv::Environment response = dataplexServiceClient.GetEnvironment(name);

GetEnvironmentAsync(EnvironmentName, CallSettings)

public virtual Task<Environment> GetEnvironmentAsync(EnvironmentName name, CallSettings callSettings = null)

Get environment resource.

Parameters
Name Description
name EnvironmentName

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskEnvironment

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EnvironmentName name = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
gcdv::Environment response = await dataplexServiceClient.GetEnvironmentAsync(name);

GetEnvironmentAsync(EnvironmentName, CancellationToken)

public virtual Task<Environment> GetEnvironmentAsync(EnvironmentName name, CancellationToken cancellationToken)

Get environment resource.

Parameters
Name Description
name EnvironmentName

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskEnvironment

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EnvironmentName name = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
gcdv::Environment response = await dataplexServiceClient.GetEnvironmentAsync(name);

GetEnvironmentAsync(GetEnvironmentRequest, CallSettings)

public virtual Task<Environment> GetEnvironmentAsync(GetEnvironmentRequest request, CallSettings callSettings = null)

Get environment resource.

Parameters
Name Description
request GetEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskEnvironment

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetEnvironmentRequest request = new gcdv::GetEnvironmentRequest
{
    EnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
gcdv::Environment response = await dataplexServiceClient.GetEnvironmentAsync(request);

GetEnvironmentAsync(GetEnvironmentRequest, CancellationToken)

public virtual Task<Environment> GetEnvironmentAsync(GetEnvironmentRequest request, CancellationToken cancellationToken)

Get environment resource.

Parameters
Name Description
request GetEnvironmentRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskEnvironment

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetEnvironmentRequest request = new gcdv::GetEnvironmentRequest
{
    EnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
gcdv::Environment response = await dataplexServiceClient.GetEnvironmentAsync(request);

GetEnvironmentAsync(string, CallSettings)

public virtual Task<Environment> GetEnvironmentAsync(string name, CallSettings callSettings = null)

Get environment resource.

Parameters
Name Description
name string

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskEnvironment

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
gcdv::Environment response = await dataplexServiceClient.GetEnvironmentAsync(name);

GetEnvironmentAsync(string, CancellationToken)

public virtual Task<Environment> GetEnvironmentAsync(string name, CancellationToken cancellationToken)

Get environment resource.

Parameters
Name Description
name string

Required. The resource name of the environment: projects/{project_id}/locations/{location_id}/lakes/{lake_id}/environments/{environment_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskEnvironment

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
gcdv::Environment response = await dataplexServiceClient.GetEnvironmentAsync(name);

GetJob(GetJobRequest, CallSettings)

public virtual Job GetJob(GetJobRequest request, CallSettings callSettings = null)

Get job resource.

Parameters
Name Description
request GetJobRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Job

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::GetJobRequest request = new gcdv::GetJobRequest
{
    JobName = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
gcdv::Job response = dataplexServiceClient.GetJob(request);

GetJob(JobName, CallSettings)

public virtual Job GetJob(JobName name, CallSettings callSettings = null)

Get job resource.

Parameters
Name Description
name JobName

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Job

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::JobName name = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
gcdv::Job response = dataplexServiceClient.GetJob(name);

GetJob(string, CallSettings)

public virtual Job GetJob(string name, CallSettings callSettings = null)

Get job resource.

Parameters
Name Description
name string

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Job

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
gcdv::Job response = dataplexServiceClient.GetJob(name);

GetJobAsync(GetJobRequest, CallSettings)

public virtual Task<Job> GetJobAsync(GetJobRequest request, CallSettings callSettings = null)

Get job resource.

Parameters
Name Description
request GetJobRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskJob

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetJobRequest request = new gcdv::GetJobRequest
{
    JobName = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
gcdv::Job response = await dataplexServiceClient.GetJobAsync(request);

GetJobAsync(GetJobRequest, CancellationToken)

public virtual Task<Job> GetJobAsync(GetJobRequest request, CancellationToken cancellationToken)

Get job resource.

Parameters
Name Description
request GetJobRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskJob

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetJobRequest request = new gcdv::GetJobRequest
{
    JobName = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
gcdv::Job response = await dataplexServiceClient.GetJobAsync(request);

GetJobAsync(JobName, CallSettings)

public virtual Task<Job> GetJobAsync(JobName name, CallSettings callSettings = null)

Get job resource.

Parameters
Name Description
name JobName

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskJob

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::JobName name = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
gcdv::Job response = await dataplexServiceClient.GetJobAsync(name);

GetJobAsync(JobName, CancellationToken)

public virtual Task<Job> GetJobAsync(JobName name, CancellationToken cancellationToken)

Get job resource.

Parameters
Name Description
name JobName

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskJob

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::JobName name = gcdv::JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
gcdv::Job response = await dataplexServiceClient.GetJobAsync(name);

GetJobAsync(string, CallSettings)

public virtual Task<Job> GetJobAsync(string name, CallSettings callSettings = null)

Get job resource.

Parameters
Name Description
name string

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskJob

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
gcdv::Job response = await dataplexServiceClient.GetJobAsync(name);

GetJobAsync(string, CancellationToken)

public virtual Task<Job> GetJobAsync(string name, CancellationToken cancellationToken)

Get job resource.

Parameters
Name Description
name string

Required. The resource name of the job: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}/jobs/{job_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskJob

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
gcdv::Job response = await dataplexServiceClient.GetJobAsync(name);

GetLake(GetLakeRequest, CallSettings)

public virtual Lake GetLake(GetLakeRequest request, CallSettings callSettings = null)

Retrieves a lake resource.

Parameters
Name Description
request GetLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Lake

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::GetLakeRequest request = new gcdv::GetLakeRequest
{
    LakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
gcdv::Lake response = dataplexServiceClient.GetLake(request);

GetLake(LakeName, CallSettings)

public virtual Lake GetLake(LakeName name, CallSettings callSettings = null)

Retrieves a lake resource.

Parameters
Name Description
name LakeName

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Lake

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
gcdv::Lake response = dataplexServiceClient.GetLake(name);

GetLake(string, CallSettings)

public virtual Lake GetLake(string name, CallSettings callSettings = null)

Retrieves a lake resource.

Parameters
Name Description
name string

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Lake

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
gcdv::Lake response = dataplexServiceClient.GetLake(name);

GetLakeAsync(GetLakeRequest, CallSettings)

public virtual Task<Lake> GetLakeAsync(GetLakeRequest request, CallSettings callSettings = null)

Retrieves a lake resource.

Parameters
Name Description
request GetLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskLake

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetLakeRequest request = new gcdv::GetLakeRequest
{
    LakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
gcdv::Lake response = await dataplexServiceClient.GetLakeAsync(request);

GetLakeAsync(GetLakeRequest, CancellationToken)

public virtual Task<Lake> GetLakeAsync(GetLakeRequest request, CancellationToken cancellationToken)

Retrieves a lake resource.

Parameters
Name Description
request GetLakeRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskLake

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetLakeRequest request = new gcdv::GetLakeRequest
{
    LakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
gcdv::Lake response = await dataplexServiceClient.GetLakeAsync(request);

GetLakeAsync(LakeName, CallSettings)

public virtual Task<Lake> GetLakeAsync(LakeName name, CallSettings callSettings = null)

Retrieves a lake resource.

Parameters
Name Description
name LakeName

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskLake

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
gcdv::Lake response = await dataplexServiceClient.GetLakeAsync(name);

GetLakeAsync(LakeName, CancellationToken)

public virtual Task<Lake> GetLakeAsync(LakeName name, CancellationToken cancellationToken)

Retrieves a lake resource.

Parameters
Name Description
name LakeName

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskLake

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
gcdv::Lake response = await dataplexServiceClient.GetLakeAsync(name);

GetLakeAsync(string, CallSettings)

public virtual Task<Lake> GetLakeAsync(string name, CallSettings callSettings = null)

Retrieves a lake resource.

Parameters
Name Description
name string

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskLake

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
gcdv::Lake response = await dataplexServiceClient.GetLakeAsync(name);

GetLakeAsync(string, CancellationToken)

public virtual Task<Lake> GetLakeAsync(string name, CancellationToken cancellationToken)

Retrieves a lake resource.

Parameters
Name Description
name string

Required. The resource name of the lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskLake

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
gcdv::Lake response = await dataplexServiceClient.GetLakeAsync(name);

GetTask(GetTaskRequest, CallSettings)

public virtual Task GetTask(GetTaskRequest request, CallSettings callSettings = null)

Get task resource.

Parameters
Name Description
request GetTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Task

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::GetTaskRequest request = new gcdv::GetTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
gcdv::Task response = dataplexServiceClient.GetTask(request);

GetTask(TaskName, CallSettings)

public virtual Task GetTask(TaskName name, CallSettings callSettings = null)

Get task resource.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{tasks_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Task

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
gcdv::Task response = dataplexServiceClient.GetTask(name);

GetTask(string, CallSettings)

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

Get task resource.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{tasks_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Task

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
gcdv::Task response = dataplexServiceClient.GetTask(name);

GetTaskAsync(GetTaskRequest, CallSettings)

public virtual Task<Task> GetTaskAsync(GetTaskRequest request, CallSettings callSettings = null)

Get task resource.

Parameters
Name Description
request GetTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskTask

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetTaskRequest request = new gcdv::GetTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
gcdv::Task response = await dataplexServiceClient.GetTaskAsync(request);

GetTaskAsync(GetTaskRequest, CancellationToken)

public virtual Task<Task> GetTaskAsync(GetTaskRequest request, CancellationToken cancellationToken)

Get task resource.

Parameters
Name Description
request GetTaskRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskTask

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetTaskRequest request = new gcdv::GetTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
gcdv::Task response = await dataplexServiceClient.GetTaskAsync(request);

GetTaskAsync(TaskName, CallSettings)

public virtual Task<Task> GetTaskAsync(TaskName name, CallSettings callSettings = null)

Get task resource.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{tasks_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskTask

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
gcdv::Task response = await dataplexServiceClient.GetTaskAsync(name);

GetTaskAsync(TaskName, CancellationToken)

public virtual Task<Task> GetTaskAsync(TaskName name, CancellationToken cancellationToken)

Get task resource.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{tasks_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskTask

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
gcdv::Task response = await dataplexServiceClient.GetTaskAsync(name);

GetTaskAsync(string, CallSettings)

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

Get task resource.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{tasks_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskTask

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
gcdv::Task response = await dataplexServiceClient.GetTaskAsync(name);

GetTaskAsync(string, CancellationToken)

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

Get task resource.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{tasks_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskTask

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
gcdv::Task response = await dataplexServiceClient.GetTaskAsync(name);

GetZone(GetZoneRequest, CallSettings)

public virtual Zone GetZone(GetZoneRequest request, CallSettings callSettings = null)

Retrieves a zone resource.

Parameters
Name Description
request GetZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Zone

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::GetZoneRequest request = new gcdv::GetZoneRequest
{
    ZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
gcdv::Zone response = dataplexServiceClient.GetZone(request);

GetZone(ZoneName, CallSettings)

public virtual Zone GetZone(ZoneName name, CallSettings callSettings = null)

Retrieves a zone resource.

Parameters
Name Description
name ZoneName

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Zone

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ZoneName name = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
gcdv::Zone response = dataplexServiceClient.GetZone(name);

GetZone(string, CallSettings)

public virtual Zone GetZone(string name, CallSettings callSettings = null)

Retrieves a zone resource.

Parameters
Name Description
name string

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
Zone

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
gcdv::Zone response = dataplexServiceClient.GetZone(name);

GetZoneAsync(GetZoneRequest, CallSettings)

public virtual Task<Zone> GetZoneAsync(GetZoneRequest request, CallSettings callSettings = null)

Retrieves a zone resource.

Parameters
Name Description
request GetZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskZone

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetZoneRequest request = new gcdv::GetZoneRequest
{
    ZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
gcdv::Zone response = await dataplexServiceClient.GetZoneAsync(request);

GetZoneAsync(GetZoneRequest, CancellationToken)

public virtual Task<Zone> GetZoneAsync(GetZoneRequest request, CancellationToken cancellationToken)

Retrieves a zone resource.

Parameters
Name Description
request GetZoneRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskZone

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetZoneRequest request = new gcdv::GetZoneRequest
{
    ZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
gcdv::Zone response = await dataplexServiceClient.GetZoneAsync(request);

GetZoneAsync(ZoneName, CallSettings)

public virtual Task<Zone> GetZoneAsync(ZoneName name, CallSettings callSettings = null)

Retrieves a zone resource.

Parameters
Name Description
name ZoneName

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskZone

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName name = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
gcdv::Zone response = await dataplexServiceClient.GetZoneAsync(name);

GetZoneAsync(ZoneName, CancellationToken)

public virtual Task<Zone> GetZoneAsync(ZoneName name, CancellationToken cancellationToken)

Retrieves a zone resource.

Parameters
Name Description
name ZoneName

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskZone

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName name = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
gcdv::Zone response = await dataplexServiceClient.GetZoneAsync(name);

GetZoneAsync(string, CallSettings)

public virtual Task<Zone> GetZoneAsync(string name, CallSettings callSettings = null)

Retrieves a zone resource.

Parameters
Name Description
name string

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskZone

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
gcdv::Zone response = await dataplexServiceClient.GetZoneAsync(name);

GetZoneAsync(string, CancellationToken)

public virtual Task<Zone> GetZoneAsync(string name, CancellationToken cancellationToken)

Retrieves a zone resource.

Parameters
Name Description
name string

Required. The resource name of the zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskZone

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
gcdv::Zone response = await dataplexServiceClient.GetZoneAsync(name);

ListAssetActions(AssetName, string, int?, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListAssetActions(AssetName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in an asset.

Parameters
Name Description
parent AssetName

Required. The resource name of the parent asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::AssetName parent = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListAssetActions(parent);

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

ListAssetActions(ListAssetActionsRequest, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListAssetActions(ListAssetActionsRequest request, CallSettings callSettings = null)

Lists action resources in an asset.

Parameters
Name Description
request ListAssetActionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListAssetActionsRequest request = new gcdv::ListAssetActionsRequest
{
    ParentAsAssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListAssetActions(request);

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

ListAssetActions(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListAssetActions(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in an asset.

Parameters
Name Description
parent string

Required. The resource name of the parent asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListAssetActions(parent);

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

ListAssetActionsAsync(AssetName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListAssetActionsAsync(AssetName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in an asset.

Parameters
Name Description
parent AssetName

Required. The resource name of the parent asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::AssetName parent = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListAssetActionsAsync(parent);

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

ListAssetActionsAsync(ListAssetActionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListAssetActionsAsync(ListAssetActionsRequest request, CallSettings callSettings = null)

Lists action resources in an asset.

Parameters
Name Description
request ListAssetActionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListAssetActionsRequest request = new gcdv::ListAssetActionsRequest
{
    ParentAsAssetName = gcdv::AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListAssetActionsAsync(request);

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

ListAssetActionsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListAssetActionsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in an asset.

Parameters
Name Description
parent string

Required. The resource name of the parent asset: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}/assets/{asset_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListAssetActionsAsync(parent);

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

ListAssets(ListAssetsRequest, CallSettings)

public virtual PagedEnumerable<ListAssetsResponse, Asset> ListAssets(ListAssetsRequest request, CallSettings callSettings = null)

Lists asset resources in a zone.

Parameters
Name Description
request ListAssetsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListAssetsResponseAsset

A pageable sequence of Asset resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListAssetsRequest request = new gcdv::ListAssetsRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListAssetsResponse, gcdv::Asset> response = dataplexServiceClient.ListAssets(request);

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

ListAssets(ZoneName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAssetsResponse, Asset> ListAssets(ZoneName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists asset resources in a zone.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListAssetsResponseAsset

A pageable sequence of Asset resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
PagedEnumerable<gcdv::ListAssetsResponse, gcdv::Asset> response = dataplexServiceClient.ListAssets(parent);

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

ListAssets(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAssetsResponse, Asset> ListAssets(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists asset resources in a zone.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListAssetsResponseAsset

A pageable sequence of Asset resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
PagedEnumerable<gcdv::ListAssetsResponse, gcdv::Asset> response = dataplexServiceClient.ListAssets(parent);

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

ListAssetsAsync(ListAssetsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAssetsResponse, Asset> ListAssetsAsync(ListAssetsRequest request, CallSettings callSettings = null)

Lists asset resources in a zone.

Parameters
Name Description
request ListAssetsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListAssetsResponseAsset

A pageable asynchronous sequence of Asset resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListAssetsRequest request = new gcdv::ListAssetsRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListAssetsResponse, gcdv::Asset> response = dataplexServiceClient.ListAssetsAsync(request);

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

ListAssetsAsync(ZoneName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAssetsResponse, Asset> ListAssetsAsync(ZoneName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists asset resources in a zone.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListAssetsResponseAsset

A pageable asynchronous sequence of Asset resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
PagedAsyncEnumerable<gcdv::ListAssetsResponse, gcdv::Asset> response = dataplexServiceClient.ListAssetsAsync(parent);

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

ListAssetsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAssetsResponse, Asset> ListAssetsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists asset resources in a zone.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListAssetsResponseAsset

A pageable asynchronous sequence of Asset resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
PagedAsyncEnumerable<gcdv::ListAssetsResponse, gcdv::Asset> response = dataplexServiceClient.ListAssetsAsync(parent);

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

ListEnvironments(LakeName, string, int?, CallSettings)

public virtual PagedEnumerable<ListEnvironmentsResponse, Environment> ListEnvironments(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists environments under the given lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListEnvironmentsResponseEnvironment

A pageable sequence of Environment resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedEnumerable<gcdv::ListEnvironmentsResponse, gcdv::Environment> response = dataplexServiceClient.ListEnvironments(parent);

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

ListEnvironments(ListEnvironmentsRequest, CallSettings)

public virtual PagedEnumerable<ListEnvironmentsResponse, Environment> ListEnvironments(ListEnvironmentsRequest request, CallSettings callSettings = null)

Lists environments under the given lake.

Parameters
Name Description
request ListEnvironmentsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListEnvironmentsResponseEnvironment

A pageable sequence of Environment resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListEnvironmentsRequest request = new gcdv::ListEnvironmentsRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListEnvironmentsResponse, gcdv::Environment> response = dataplexServiceClient.ListEnvironments(request);

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

ListEnvironments(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListEnvironmentsResponse, Environment> ListEnvironments(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists environments under the given lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListEnvironmentsResponseEnvironment

A pageable sequence of Environment resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedEnumerable<gcdv::ListEnvironmentsResponse, gcdv::Environment> response = dataplexServiceClient.ListEnvironments(parent);

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

ListEnvironmentsAsync(LakeName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListEnvironmentsResponse, Environment> ListEnvironmentsAsync(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists environments under the given lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListEnvironmentsResponseEnvironment

A pageable asynchronous sequence of Environment resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedAsyncEnumerable<gcdv::ListEnvironmentsResponse, gcdv::Environment> response = dataplexServiceClient.ListEnvironmentsAsync(parent);

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

ListEnvironmentsAsync(ListEnvironmentsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListEnvironmentsResponse, Environment> ListEnvironmentsAsync(ListEnvironmentsRequest request, CallSettings callSettings = null)

Lists environments under the given lake.

Parameters
Name Description
request ListEnvironmentsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListEnvironmentsResponseEnvironment

A pageable asynchronous sequence of Environment resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListEnvironmentsRequest request = new gcdv::ListEnvironmentsRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListEnvironmentsResponse, gcdv::Environment> response = dataplexServiceClient.ListEnvironmentsAsync(request);

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

ListEnvironmentsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListEnvironmentsResponse, Environment> ListEnvironmentsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists environments under the given lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_id}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListEnvironmentsResponseEnvironment

A pageable asynchronous sequence of Environment resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedAsyncEnumerable<gcdv::ListEnvironmentsResponse, gcdv::Environment> response = dataplexServiceClient.ListEnvironmentsAsync(parent);

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

ListJobs(ListJobsRequest, CallSettings)

public virtual PagedEnumerable<ListJobsResponse, Job> ListJobs(ListJobsRequest request, CallSettings callSettings = null)

Lists Jobs under the given task.

Parameters
Name Description
request ListJobsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListJobsResponseJob

A pageable sequence of Job resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListJobsRequest request = new gcdv::ListJobsRequest
{
    ParentAsTaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
PagedEnumerable<gcdv::ListJobsResponse, gcdv::Job> response = dataplexServiceClient.ListJobs(request);

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

ListJobs(TaskName, string, int?, CallSettings)

public virtual PagedEnumerable<ListJobsResponse, Job> ListJobs(TaskName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Jobs under the given task.

Parameters
Name Description
parent TaskName

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListJobsResponseJob

A pageable sequence of Job resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::TaskName parent = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
PagedEnumerable<gcdv::ListJobsResponse, gcdv::Job> response = dataplexServiceClient.ListJobs(parent);

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

ListJobs(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListJobsResponse, Job> ListJobs(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Jobs under the given task.

Parameters
Name Description
parent string

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListJobsResponseJob

A pageable sequence of Job resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
PagedEnumerable<gcdv::ListJobsResponse, gcdv::Job> response = dataplexServiceClient.ListJobs(parent);

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

ListJobsAsync(ListJobsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListJobsResponse, Job> ListJobsAsync(ListJobsRequest request, CallSettings callSettings = null)

Lists Jobs under the given task.

Parameters
Name Description
request ListJobsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListJobsResponseJob

A pageable asynchronous sequence of Job resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListJobsRequest request = new gcdv::ListJobsRequest
{
    ParentAsTaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
PagedAsyncEnumerable<gcdv::ListJobsResponse, gcdv::Job> response = dataplexServiceClient.ListJobsAsync(request);

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

ListJobsAsync(TaskName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListJobsResponse, Job> ListJobsAsync(TaskName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Jobs under the given task.

Parameters
Name Description
parent TaskName

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListJobsResponseJob

A pageable asynchronous sequence of Job resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName parent = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
PagedAsyncEnumerable<gcdv::ListJobsResponse, gcdv::Job> response = dataplexServiceClient.ListJobsAsync(parent);

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

ListJobsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListJobsResponse, Job> ListJobsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists Jobs under the given task.

Parameters
Name Description
parent string

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListJobsResponseJob

A pageable asynchronous sequence of Job resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
PagedAsyncEnumerable<gcdv::ListJobsResponse, gcdv::Job> response = dataplexServiceClient.ListJobsAsync(parent);

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

ListLakeActions(LakeName, string, int?, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListLakeActions(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListLakeActions(parent);

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

ListLakeActions(ListLakeActionsRequest, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListLakeActions(ListLakeActionsRequest request, CallSettings callSettings = null)

Lists action resources in a lake.

Parameters
Name Description
request ListLakeActionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListLakeActionsRequest request = new gcdv::ListLakeActionsRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListLakeActions(request);

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

ListLakeActions(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListLakeActions(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListLakeActions(parent);

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

ListLakeActionsAsync(LakeName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListLakeActionsAsync(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListLakeActionsAsync(parent);

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

ListLakeActionsAsync(ListLakeActionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListLakeActionsAsync(ListLakeActionsRequest request, CallSettings callSettings = null)

Lists action resources in a lake.

Parameters
Name Description
request ListLakeActionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListLakeActionsRequest request = new gcdv::ListLakeActionsRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListLakeActionsAsync(request);

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

ListLakeActionsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListLakeActionsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListLakeActionsAsync(parent);

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

ListLakes(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListLakesResponse, Lake> ListLakes(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists lake resources in a project and location.

Parameters
Name Description
parent LocationName

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListLakesResponseLake

A pageable sequence of Lake resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<gcdv::ListLakesResponse, gcdv::Lake> response = dataplexServiceClient.ListLakes(parent);

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

ListLakes(ListLakesRequest, CallSettings)

public virtual PagedEnumerable<ListLakesResponse, Lake> ListLakes(ListLakesRequest request, CallSettings callSettings = null)

Lists lake resources in a project and location.

Parameters
Name Description
request ListLakesRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListLakesResponseLake

A pageable sequence of Lake resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListLakesRequest request = new gcdv::ListLakesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListLakesResponse, gcdv::Lake> response = dataplexServiceClient.ListLakes(request);

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

ListLakes(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListLakesResponse, Lake> ListLakes(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists lake resources in a project and location.

Parameters
Name Description
parent string

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListLakesResponseLake

A pageable sequence of Lake resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<gcdv::ListLakesResponse, gcdv::Lake> response = dataplexServiceClient.ListLakes(parent);

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

ListLakesAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListLakesResponse, Lake> ListLakesAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists lake resources in a project and location.

Parameters
Name Description
parent LocationName

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListLakesResponseLake

A pageable asynchronous sequence of Lake resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<gcdv::ListLakesResponse, gcdv::Lake> response = dataplexServiceClient.ListLakesAsync(parent);

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

ListLakesAsync(ListLakesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListLakesResponse, Lake> ListLakesAsync(ListLakesRequest request, CallSettings callSettings = null)

Lists lake resources in a project and location.

Parameters
Name Description
request ListLakesRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListLakesResponseLake

A pageable asynchronous sequence of Lake resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListLakesRequest request = new gcdv::ListLakesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListLakesResponse, gcdv::Lake> response = dataplexServiceClient.ListLakesAsync(request);

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

ListLakesAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListLakesResponse, Lake> ListLakesAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists lake resources in a project and location.

Parameters
Name Description
parent string

Required. The resource name of the lake location, of the form: projects/{project_number}/locations/{location_id} where location_id refers to a GCP region.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListLakesResponseLake

A pageable asynchronous sequence of Lake resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<gcdv::ListLakesResponse, gcdv::Lake> response = dataplexServiceClient.ListLakesAsync(parent);

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

ListSessions(EnvironmentName, string, int?, CallSettings)

public virtual PagedEnumerable<ListSessionsResponse, Session> ListSessions(EnvironmentName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists session resources in an environment.

Parameters
Name Description
parent EnvironmentName

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/environment/{environment_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListSessionsResponseSession

A pageable sequence of Session resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::EnvironmentName parent = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
PagedEnumerable<gcdv::ListSessionsResponse, gcdv::Session> response = dataplexServiceClient.ListSessions(parent);

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

ListSessions(ListSessionsRequest, CallSettings)

public virtual PagedEnumerable<ListSessionsResponse, Session> ListSessions(ListSessionsRequest request, CallSettings callSettings = null)

Lists session resources in an environment.

Parameters
Name Description
request ListSessionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListSessionsResponseSession

A pageable sequence of Session resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListSessionsRequest request = new gcdv::ListSessionsRequest
{
    ParentAsEnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
    Filter = "",
};
// Make the request
PagedEnumerable<gcdv::ListSessionsResponse, gcdv::Session> response = dataplexServiceClient.ListSessions(request);

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

ListSessions(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListSessionsResponse, Session> ListSessions(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists session resources in an environment.

Parameters
Name Description
parent string

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/environment/{environment_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListSessionsResponseSession

A pageable sequence of Session resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
PagedEnumerable<gcdv::ListSessionsResponse, gcdv::Session> response = dataplexServiceClient.ListSessions(parent);

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

ListSessionsAsync(EnvironmentName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListSessionsResponse, Session> ListSessionsAsync(EnvironmentName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists session resources in an environment.

Parameters
Name Description
parent EnvironmentName

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/environment/{environment_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListSessionsResponseSession

A pageable asynchronous sequence of Session resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::EnvironmentName parent = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
PagedAsyncEnumerable<gcdv::ListSessionsResponse, gcdv::Session> response = dataplexServiceClient.ListSessionsAsync(parent);

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

ListSessionsAsync(ListSessionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListSessionsResponse, Session> ListSessionsAsync(ListSessionsRequest request, CallSettings callSettings = null)

Lists session resources in an environment.

Parameters
Name Description
request ListSessionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListSessionsResponseSession

A pageable asynchronous sequence of Session resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListSessionsRequest request = new gcdv::ListSessionsRequest
{
    ParentAsEnvironmentName = gcdv::EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListSessionsResponse, gcdv::Session> response = dataplexServiceClient.ListSessionsAsync(request);

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

ListSessionsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListSessionsResponse, Session> ListSessionsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists session resources in an environment.

Parameters
Name Description
parent string

Required. The resource name of the parent environment: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/environment/{environment_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListSessionsResponseSession

A pageable asynchronous sequence of Session resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
PagedAsyncEnumerable<gcdv::ListSessionsResponse, gcdv::Session> response = dataplexServiceClient.ListSessionsAsync(parent);

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

ListTasks(LakeName, string, int?, CallSettings)

public virtual PagedEnumerable<ListTasksResponse, Task> ListTasks(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists tasks under the given lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListTasksResponseTask

A pageable sequence of Task resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedEnumerable<gcdv::ListTasksResponse, gcdv::Task> response = dataplexServiceClient.ListTasks(parent);

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

ListTasks(ListTasksRequest, CallSettings)

public virtual PagedEnumerable<ListTasksResponse, Task> ListTasks(ListTasksRequest request, CallSettings callSettings = null)

Lists tasks under the given lake.

Parameters
Name Description
request ListTasksRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListTasksResponseTask

A pageable sequence of Task resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListTasksRequest request = new gcdv::ListTasksRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListTasksResponse, gcdv::Task> response = dataplexServiceClient.ListTasks(request);

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

ListTasks(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListTasksResponse, Task> ListTasks(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists tasks under the given lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListTasksResponseTask

A pageable sequence of Task resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedEnumerable<gcdv::ListTasksResponse, gcdv::Task> response = dataplexServiceClient.ListTasks(parent);

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

ListTasksAsync(LakeName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListTasksResponse, Task> ListTasksAsync(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists tasks under the given lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListTasksResponseTask

A pageable asynchronous sequence of Task resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedAsyncEnumerable<gcdv::ListTasksResponse, gcdv::Task> response = dataplexServiceClient.ListTasksAsync(parent);

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

ListTasksAsync(ListTasksRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListTasksResponse, Task> ListTasksAsync(ListTasksRequest request, CallSettings callSettings = null)

Lists tasks under the given lake.

Parameters
Name Description
request ListTasksRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListTasksResponseTask

A pageable asynchronous sequence of Task resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListTasksRequest request = new gcdv::ListTasksRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListTasksResponse, gcdv::Task> response = dataplexServiceClient.ListTasksAsync(request);

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

ListTasksAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListTasksResponse, Task> ListTasksAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists tasks under the given lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListTasksResponseTask

A pageable asynchronous sequence of Task resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedAsyncEnumerable<gcdv::ListTasksResponse, gcdv::Task> response = dataplexServiceClient.ListTasksAsync(parent);

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

ListZoneActions(ListZoneActionsRequest, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListZoneActions(ListZoneActionsRequest request, CallSettings callSettings = null)

Lists action resources in a zone.

Parameters
Name Description
request ListZoneActionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListZoneActionsRequest request = new gcdv::ListZoneActionsRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListZoneActions(request);

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

ListZoneActions(ZoneName, string, int?, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListZoneActions(ZoneName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a zone.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListZoneActions(parent);

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

ListZoneActions(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListActionsResponse, Action> ListZoneActions(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a zone.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListActionsResponseAction

A pageable sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
PagedEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListZoneActions(parent);

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

ListZoneActionsAsync(ListZoneActionsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListZoneActionsAsync(ListZoneActionsRequest request, CallSettings callSettings = null)

Lists action resources in a zone.

Parameters
Name Description
request ListZoneActionsRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListZoneActionsRequest request = new gcdv::ListZoneActionsRequest
{
    ParentAsZoneName = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListZoneActionsAsync(request);

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

ListZoneActionsAsync(ZoneName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListZoneActionsAsync(ZoneName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a zone.

Parameters
Name Description
parent ZoneName

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ZoneName parent = gcdv::ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListZoneActionsAsync(parent);

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

ListZoneActionsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListActionsResponse, Action> ListZoneActionsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists action resources in a zone.

Parameters
Name Description
parent string

Required. The resource name of the parent zone: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/zones/{zone_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListActionsResponseAction

A pageable asynchronous sequence of Action resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
PagedAsyncEnumerable<gcdv::ListActionsResponse, gcdv::Action> response = dataplexServiceClient.ListZoneActionsAsync(parent);

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

ListZones(LakeName, string, int?, CallSettings)

public virtual PagedEnumerable<ListZonesResponse, Zone> ListZones(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists zone resources in a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListZonesResponseZone

A pageable sequence of Zone resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedEnumerable<gcdv::ListZonesResponse, gcdv::Zone> response = dataplexServiceClient.ListZones(parent);

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

ListZones(ListZonesRequest, CallSettings)

public virtual PagedEnumerable<ListZonesResponse, Zone> ListZones(ListZonesRequest request, CallSettings callSettings = null)

Lists zone resources in a lake.

Parameters
Name Description
request ListZonesRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListZonesResponseZone

A pageable sequence of Zone resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::ListZonesRequest request = new gcdv::ListZonesRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListZonesResponse, gcdv::Zone> response = dataplexServiceClient.ListZones(request);

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

ListZones(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListZonesResponse, Zone> ListZones(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists zone resources in a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedEnumerableListZonesResponseZone

A pageable sequence of Zone resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedEnumerable<gcdv::ListZonesResponse, gcdv::Zone> response = dataplexServiceClient.ListZones(parent);

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

ListZonesAsync(LakeName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListZonesResponse, Zone> ListZonesAsync(LakeName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists zone resources in a lake.

Parameters
Name Description
parent LakeName

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListZonesResponseZone

A pageable asynchronous sequence of Zone resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::LakeName parent = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
PagedAsyncEnumerable<gcdv::ListZonesResponse, gcdv::Zone> response = dataplexServiceClient.ListZonesAsync(parent);

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

ListZonesAsync(ListZonesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListZonesResponse, Zone> ListZonesAsync(ListZonesRequest request, CallSettings callSettings = null)

Lists zone resources in a lake.

Parameters
Name Description
request ListZonesRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListZonesResponseZone

A pageable asynchronous sequence of Zone resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListZonesRequest request = new gcdv::ListZonesRequest
{
    ParentAsLakeName = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListZonesResponse, gcdv::Zone> response = dataplexServiceClient.ListZonesAsync(request);

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

ListZonesAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListZonesResponse, Zone> ListZonesAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists zone resources in a lake.

Parameters
Name Description
parent string

Required. The resource name of the parent lake: projects/{project_number}/locations/{location_id}/lakes/{lake_id}.

pageToken string

The token returned from the previous request. A value of null or an empty string retrieves the first page.

pageSize int

The size of page to request. The response will not be larger than this, but may be smaller. A value of null or 0 uses a server-defined page size.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
PagedAsyncEnumerableListZonesResponseZone

A pageable asynchronous sequence of Zone resources.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
PagedAsyncEnumerable<gcdv::ListZonesResponse, gcdv::Zone> response = dataplexServiceClient.ListZonesAsync(parent);

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

PollOnceCreateAsset(string, CallSettings)

public virtual Operation<Asset, OperationMetadata> PollOnceCreateAsset(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateAsset.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The result of polling the operation.

PollOnceCreateAssetAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateAsset.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A task representing the result of polling the operation.

PollOnceCreateEnvironment(string, CallSettings)

public virtual Operation<Environment, OperationMetadata> PollOnceCreateEnvironment(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateEnvironment .

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The result of polling the operation.

PollOnceCreateEnvironmentAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateEnvironment.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A task representing the result of polling the operation.

PollOnceCreateLake(string, CallSettings)

public virtual Operation<Lake, OperationMetadata> PollOnceCreateLake(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateLake.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The result of polling the operation.

PollOnceCreateLakeAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateLake.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A task representing the result of polling the operation.

PollOnceCreateTask(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of CreateTask.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The result of polling the operation.

PollOnceCreateTaskAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateTask.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A task representing the result of polling the operation.

PollOnceCreateZone(string, CallSettings)

public virtual Operation<Zone, OperationMetadata> PollOnceCreateZone(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateZone.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The result of polling the operation.

PollOnceCreateZoneAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateZone.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A task representing the result of polling the operation.

PollOnceDeleteAsset(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of DeleteAsset.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The result of polling the operation.

PollOnceDeleteAssetAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteAsset.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A task representing the result of polling the operation.

PollOnceDeleteEnvironment(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of DeleteEnvironment .

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The result of polling the operation.

PollOnceDeleteEnvironmentAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteEnvironment.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A task representing the result of polling the operation.

PollOnceDeleteLake(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of DeleteLake.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The result of polling the operation.

PollOnceDeleteLakeAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteLake.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A task representing the result of polling the operation.

PollOnceDeleteTask(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of DeleteTask.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The result of polling the operation.

PollOnceDeleteTaskAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteTask.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A task representing the result of polling the operation.

PollOnceDeleteZone(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of DeleteZone.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEmptyOperationMetadata

The result of polling the operation.

PollOnceDeleteZoneAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteZone.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEmptyOperationMetadata

A task representing the result of polling the operation.

PollOnceUpdateAsset(string, CallSettings)

public virtual Operation<Asset, OperationMetadata> PollOnceUpdateAsset(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of UpdateAsset.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The result of polling the operation.

PollOnceUpdateAssetAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of UpdateAsset.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A task representing the result of polling the operation.

PollOnceUpdateEnvironment(string, CallSettings)

public virtual Operation<Environment, OperationMetadata> PollOnceUpdateEnvironment(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of UpdateEnvironment .

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The result of polling the operation.

PollOnceUpdateEnvironmentAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of UpdateEnvironment.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A task representing the result of polling the operation.

PollOnceUpdateLake(string, CallSettings)

public virtual Operation<Lake, OperationMetadata> PollOnceUpdateLake(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of UpdateLake.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The result of polling the operation.

PollOnceUpdateLakeAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of UpdateLake.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A task representing the result of polling the operation.

PollOnceUpdateTask(string, CallSettings)

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

Poll an operation once, using an operationName from a previous invocation of UpdateTask.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The result of polling the operation.

PollOnceUpdateTaskAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of UpdateTask.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A task representing the result of polling the operation.

PollOnceUpdateZone(string, CallSettings)

public virtual Operation<Zone, OperationMetadata> PollOnceUpdateZone(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of UpdateZone.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The result of polling the operation.

PollOnceUpdateZoneAsync(string, CallSettings)

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

Asynchronously poll an operation once, using an operationName from a previous invocation of UpdateZone.

Parameters
Name Description
operationName string

The name of a previously invoked operation. Must not be null or empty.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A task representing the result of polling the operation.

RunTask(RunTaskRequest, CallSettings)

public virtual RunTaskResponse RunTask(RunTaskRequest request, CallSettings callSettings = null)

Run an on demand execution of a Task.

Parameters
Name Description
request RunTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
RunTaskResponse

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::RunTaskRequest request = new gcdv::RunTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
    Labels = { { "", "" }, },
    Args = { { "", "" }, },
};
// Make the request
gcdv::RunTaskResponse response = dataplexServiceClient.RunTask(request);

RunTask(TaskName, CallSettings)

public virtual RunTaskResponse RunTask(TaskName name, CallSettings callSettings = null)

Run an on demand execution of a Task.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
RunTaskResponse

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
gcdv::RunTaskResponse response = dataplexServiceClient.RunTask(name);

RunTask(string, CallSettings)

public virtual RunTaskResponse RunTask(string name, CallSettings callSettings = null)

Run an on demand execution of a Task.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
RunTaskResponse

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
gcdv::RunTaskResponse response = dataplexServiceClient.RunTask(name);

RunTaskAsync(RunTaskRequest, CallSettings)

public virtual Task<RunTaskResponse> RunTaskAsync(RunTaskRequest request, CallSettings callSettings = null)

Run an on demand execution of a Task.

Parameters
Name Description
request RunTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskRunTaskResponse

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::RunTaskRequest request = new gcdv::RunTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
    Labels = { { "", "" }, },
    Args = { { "", "" }, },
};
// Make the request
gcdv::RunTaskResponse response = await dataplexServiceClient.RunTaskAsync(request);

RunTaskAsync(RunTaskRequest, CancellationToken)

public virtual Task<RunTaskResponse> RunTaskAsync(RunTaskRequest request, CancellationToken cancellationToken)

Run an on demand execution of a Task.

Parameters
Name Description
request RunTaskRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskRunTaskResponse

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::RunTaskRequest request = new gcdv::RunTaskRequest
{
    TaskName = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
    Labels = { { "", "" }, },
    Args = { { "", "" }, },
};
// Make the request
gcdv::RunTaskResponse response = await dataplexServiceClient.RunTaskAsync(request);

RunTaskAsync(TaskName, CallSettings)

public virtual Task<RunTaskResponse> RunTaskAsync(TaskName name, CallSettings callSettings = null)

Run an on demand execution of a Task.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskRunTaskResponse

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
gcdv::RunTaskResponse response = await dataplexServiceClient.RunTaskAsync(name);

RunTaskAsync(TaskName, CancellationToken)

public virtual Task<RunTaskResponse> RunTaskAsync(TaskName name, CancellationToken cancellationToken)

Run an on demand execution of a Task.

Parameters
Name Description
name TaskName

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskRunTaskResponse

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::TaskName name = gcdv::TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
gcdv::RunTaskResponse response = await dataplexServiceClient.RunTaskAsync(name);

RunTaskAsync(string, CallSettings)

public virtual Task<RunTaskResponse> RunTaskAsync(string name, CallSettings callSettings = null)

Run an on demand execution of a Task.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskRunTaskResponse

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
gcdv::RunTaskResponse response = await dataplexServiceClient.RunTaskAsync(name);

RunTaskAsync(string, CancellationToken)

public virtual Task<RunTaskResponse> RunTaskAsync(string name, CancellationToken cancellationToken)

Run an on demand execution of a Task.

Parameters
Name Description
name string

Required. The resource name of the task: projects/{project_number}/locations/{location_id}/lakes/{lake_id}/tasks/{task_id}.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskRunTaskResponse

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
gcdv::RunTaskResponse response = await dataplexServiceClient.RunTaskAsync(name);

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

Shuts down any channels automatically created by Create() and CreateAsync(CancellationToken). Channels which weren't automatically created are not affected.

Returns
Type Description
Task

A task representing the asynchronous shutdown operation.

Remarks

After calling this method, further calls to Create() and CreateAsync(CancellationToken) will create new channels, which could in turn be shut down by another call to this method.

UpdateAsset(Asset, FieldMask, CallSettings)

public virtual Operation<Asset, OperationMetadata> UpdateAsset(Asset asset, FieldMask updateMask, CallSettings callSettings = null)

Updates an asset resource.

Parameters
Name Description
asset Asset

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::Asset asset = new gcdv::Asset();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateAsset(asset, updateMask);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateAsset(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

UpdateAsset(UpdateAssetRequest, CallSettings)

public virtual Operation<Asset, OperationMetadata> UpdateAsset(UpdateAssetRequest request, CallSettings callSettings = null)

Updates an asset resource.

Parameters
Name Description
request UpdateAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationAssetOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateAssetRequest request = new gcdv::UpdateAssetRequest
{
    UpdateMask = new FieldMask(),
    Asset = new gcdv::Asset(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateAsset(request);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateAsset(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

UpdateAssetAsync(Asset, FieldMask, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> UpdateAssetAsync(Asset asset, FieldMask updateMask, CallSettings callSettings = null)

Updates an asset resource.

Parameters
Name Description
asset Asset

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Asset asset = new gcdv::Asset();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateAssetAsync(asset, updateMask);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

UpdateAssetAsync(Asset, FieldMask, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> UpdateAssetAsync(Asset asset, FieldMask updateMask, CancellationToken cancellationToken)

Updates an asset resource.

Parameters
Name Description
asset Asset

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Asset asset = new gcdv::Asset();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateAssetAsync(asset, updateMask);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

UpdateAssetAsync(UpdateAssetRequest, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> UpdateAssetAsync(UpdateAssetRequest request, CallSettings callSettings = null)

Updates an asset resource.

Parameters
Name Description
request UpdateAssetRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateAssetRequest request = new gcdv::UpdateAssetRequest
{
    UpdateMask = new FieldMask(),
    Asset = new gcdv::Asset(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateAssetAsync(request);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

UpdateAssetAsync(UpdateAssetRequest, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> UpdateAssetAsync(UpdateAssetRequest request, CancellationToken cancellationToken)

Updates an asset resource.

Parameters
Name Description
request UpdateAssetRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationAssetOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateAssetRequest request = new gcdv::UpdateAssetRequest
{
    UpdateMask = new FieldMask(),
    Asset = new gcdv::Asset(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Asset, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateAssetAsync(request);

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

// Or get 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::Asset, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateAssetAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Asset retrievedResult = retrievedResponse.Result;
}

UpdateEnvironment(Environment, FieldMask, CallSettings)

public virtual Operation<Environment, OperationMetadata> UpdateEnvironment(Environment environment, FieldMask updateMask, CallSettings callSettings = null)

Update the environment resource.

Parameters
Name Description
environment Environment

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::Environment environment = new gcdv::Environment();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateEnvironment(environment, updateMask);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateEnvironment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

UpdateEnvironment(UpdateEnvironmentRequest, CallSettings)

public virtual Operation<Environment, OperationMetadata> UpdateEnvironment(UpdateEnvironmentRequest request, CallSettings callSettings = null)

Update the environment resource.

Parameters
Name Description
request UpdateEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationEnvironmentOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateEnvironmentRequest request = new gcdv::UpdateEnvironmentRequest
{
    UpdateMask = new FieldMask(),
    Environment = new gcdv::Environment(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateEnvironment(request);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateEnvironment(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

UpdateEnvironmentAsync(Environment, FieldMask, CallSettings)

public virtual Task<Operation<Environment, OperationMetadata>> UpdateEnvironmentAsync(Environment environment, FieldMask updateMask, CallSettings callSettings = null)

Update the environment resource.

Parameters
Name Description
environment Environment

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Environment environment = new gcdv::Environment();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateEnvironmentAsync(environment, updateMask);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

UpdateEnvironmentAsync(Environment, FieldMask, CancellationToken)

public virtual Task<Operation<Environment, OperationMetadata>> UpdateEnvironmentAsync(Environment environment, FieldMask updateMask, CancellationToken cancellationToken)

Update the environment resource.

Parameters
Name Description
environment Environment

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Environment environment = new gcdv::Environment();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateEnvironmentAsync(environment, updateMask);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

UpdateEnvironmentAsync(UpdateEnvironmentRequest, CallSettings)

public virtual Task<Operation<Environment, OperationMetadata>> UpdateEnvironmentAsync(UpdateEnvironmentRequest request, CallSettings callSettings = null)

Update the environment resource.

Parameters
Name Description
request UpdateEnvironmentRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateEnvironmentRequest request = new gcdv::UpdateEnvironmentRequest
{
    UpdateMask = new FieldMask(),
    Environment = new gcdv::Environment(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateEnvironmentAsync(request);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

UpdateEnvironmentAsync(UpdateEnvironmentRequest, CancellationToken)

public virtual Task<Operation<Environment, OperationMetadata>> UpdateEnvironmentAsync(UpdateEnvironmentRequest request, CancellationToken cancellationToken)

Update the environment resource.

Parameters
Name Description
request UpdateEnvironmentRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationEnvironmentOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateEnvironmentRequest request = new gcdv::UpdateEnvironmentRequest
{
    UpdateMask = new FieldMask(),
    Environment = new gcdv::Environment(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateEnvironmentAsync(request);

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

// Or get 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::Environment, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateEnvironmentAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Environment retrievedResult = retrievedResponse.Result;
}

UpdateLake(Lake, FieldMask, CallSettings)

public virtual Operation<Lake, OperationMetadata> UpdateLake(Lake lake, FieldMask updateMask, CallSettings callSettings = null)

Updates a lake resource.

Parameters
Name Description
lake Lake

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::Lake lake = new gcdv::Lake();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateLake(lake, updateMask);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateLake(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

UpdateLake(UpdateLakeRequest, CallSettings)

public virtual Operation<Lake, OperationMetadata> UpdateLake(UpdateLakeRequest request, CallSettings callSettings = null)

Updates a lake resource.

Parameters
Name Description
request UpdateLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationLakeOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateLakeRequest request = new gcdv::UpdateLakeRequest
{
    UpdateMask = new FieldMask(),
    Lake = new gcdv::Lake(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateLake(request);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateLake(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

UpdateLakeAsync(Lake, FieldMask, CallSettings)

public virtual Task<Operation<Lake, OperationMetadata>> UpdateLakeAsync(Lake lake, FieldMask updateMask, CallSettings callSettings = null)

Updates a lake resource.

Parameters
Name Description
lake Lake

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Lake lake = new gcdv::Lake();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateLakeAsync(lake, updateMask);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

UpdateLakeAsync(Lake, FieldMask, CancellationToken)

public virtual Task<Operation<Lake, OperationMetadata>> UpdateLakeAsync(Lake lake, FieldMask updateMask, CancellationToken cancellationToken)

Updates a lake resource.

Parameters
Name Description
lake Lake

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Lake lake = new gcdv::Lake();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateLakeAsync(lake, updateMask);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

UpdateLakeAsync(UpdateLakeRequest, CallSettings)

public virtual Task<Operation<Lake, OperationMetadata>> UpdateLakeAsync(UpdateLakeRequest request, CallSettings callSettings = null)

Updates a lake resource.

Parameters
Name Description
request UpdateLakeRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateLakeRequest request = new gcdv::UpdateLakeRequest
{
    UpdateMask = new FieldMask(),
    Lake = new gcdv::Lake(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateLakeAsync(request);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

UpdateLakeAsync(UpdateLakeRequest, CancellationToken)

public virtual Task<Operation<Lake, OperationMetadata>> UpdateLakeAsync(UpdateLakeRequest request, CancellationToken cancellationToken)

Updates a lake resource.

Parameters
Name Description
request UpdateLakeRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationLakeOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateLakeRequest request = new gcdv::UpdateLakeRequest
{
    UpdateMask = new FieldMask(),
    Lake = new gcdv::Lake(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Lake, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateLakeAsync(request);

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

// Or get 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::Lake, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateLakeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Lake retrievedResult = retrievedResponse.Result;
}

UpdateTask(Task, FieldMask, CallSettings)

public virtual Operation<Task, OperationMetadata> UpdateTask(Task task, FieldMask updateMask, CallSettings callSettings = null)

Update the task resource.

Parameters
Name Description
task Task

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::Task task = new gcdv::Task();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateTask(task, updateMask);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateTask(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

UpdateTask(UpdateTaskRequest, CallSettings)

public virtual Operation<Task, OperationMetadata> UpdateTask(UpdateTaskRequest request, CallSettings callSettings = null)

Update the task resource.

Parameters
Name Description
request UpdateTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationTaskOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateTaskRequest request = new gcdv::UpdateTaskRequest
{
    UpdateMask = new FieldMask(),
    Task = new gcdv::Task(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateTask(request);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateTask(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

UpdateTaskAsync(Task, FieldMask, CallSettings)

public virtual Task<Operation<Task, OperationMetadata>> UpdateTaskAsync(Task task, FieldMask updateMask, CallSettings callSettings = null)

Update the task resource.

Parameters
Name Description
task Task

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Task task = new gcdv::Task();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateTaskAsync(task, updateMask);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

UpdateTaskAsync(Task, FieldMask, CancellationToken)

public virtual Task<Operation<Task, OperationMetadata>> UpdateTaskAsync(Task task, FieldMask updateMask, CancellationToken cancellationToken)

Update the task resource.

Parameters
Name Description
task Task

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Task task = new gcdv::Task();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateTaskAsync(task, updateMask);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

UpdateTaskAsync(UpdateTaskRequest, CallSettings)

public virtual Task<Operation<Task, OperationMetadata>> UpdateTaskAsync(UpdateTaskRequest request, CallSettings callSettings = null)

Update the task resource.

Parameters
Name Description
request UpdateTaskRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateTaskRequest request = new gcdv::UpdateTaskRequest
{
    UpdateMask = new FieldMask(),
    Task = new gcdv::Task(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateTaskAsync(request);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

UpdateTaskAsync(UpdateTaskRequest, CancellationToken)

public virtual Task<Operation<Task, OperationMetadata>> UpdateTaskAsync(UpdateTaskRequest request, CancellationToken cancellationToken)

Update the task resource.

Parameters
Name Description
request UpdateTaskRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationTaskOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateTaskRequest request = new gcdv::UpdateTaskRequest
{
    UpdateMask = new FieldMask(),
    Task = new gcdv::Task(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateTaskAsync(request);

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

// Or get 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::Task, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateTaskAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Task retrievedResult = retrievedResponse.Result;
}

UpdateZone(UpdateZoneRequest, CallSettings)

public virtual Operation<Zone, OperationMetadata> UpdateZone(UpdateZoneRequest request, CallSettings callSettings = null)

Updates a zone resource.

Parameters
Name Description
request UpdateZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateZoneRequest request = new gcdv::UpdateZoneRequest
{
    UpdateMask = new FieldMask(),
    Zone = new gcdv::Zone(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateZone(request);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

UpdateZone(Zone, FieldMask, CallSettings)

public virtual Operation<Zone, OperationMetadata> UpdateZone(Zone zone, FieldMask updateMask, CallSettings callSettings = null)

Updates a zone resource.

Parameters
Name Description
zone Zone

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
OperationZoneOperationMetadata

The RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::Zone zone = new gcdv::Zone();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = dataplexServiceClient.UpdateZone(zone, updateMask);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = dataplexServiceClient.PollOnceUpdateZone(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

UpdateZoneAsync(UpdateZoneRequest, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> UpdateZoneAsync(UpdateZoneRequest request, CallSettings callSettings = null)

Updates a zone resource.

Parameters
Name Description
request UpdateZoneRequest

The request object containing all of the parameters for the API call.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateZoneRequest request = new gcdv::UpdateZoneRequest
{
    UpdateMask = new FieldMask(),
    Zone = new gcdv::Zone(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateZoneAsync(request);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

UpdateZoneAsync(UpdateZoneRequest, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> UpdateZoneAsync(UpdateZoneRequest request, CancellationToken cancellationToken)

Updates a zone resource.

Parameters
Name Description
request UpdateZoneRequest

The request object containing all of the parameters for the API call.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateZoneRequest request = new gcdv::UpdateZoneRequest
{
    UpdateMask = new FieldMask(),
    Zone = new gcdv::Zone(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateZoneAsync(request);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

UpdateZoneAsync(Zone, FieldMask, CallSettings)

public virtual Task<Operation<Zone, OperationMetadata>> UpdateZoneAsync(Zone zone, FieldMask updateMask, CallSettings callSettings = null)

Updates a zone resource.

Parameters
Name Description
zone Zone

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

callSettings CallSettings

If not null, applies overrides to this RPC call.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Zone zone = new gcdv::Zone();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateZoneAsync(zone, updateMask);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}

UpdateZoneAsync(Zone, FieldMask, CancellationToken)

public virtual Task<Operation<Zone, OperationMetadata>> UpdateZoneAsync(Zone zone, FieldMask updateMask, CancellationToken cancellationToken)

Updates a zone resource.

Parameters
Name Description
zone Zone

Required. Update description. Only fields specified in update_mask are updated.

updateMask FieldMask

Required. Mask of fields to update.

cancellationToken CancellationToken

A CancellationToken to use for this RPC.

Returns
Type Description
TaskOperationZoneOperationMetadata

A Task containing the RPC response.

Example
// Create client
gcdv::DataplexServiceClient dataplexServiceClient = await gcdv::DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Zone zone = new gcdv::Zone();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Zone, gcdv::OperationMetadata> response = await dataplexServiceClient.UpdateZoneAsync(zone, updateMask);

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

// Or get 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::Zone, gcdv::OperationMetadata> retrievedResponse = await dataplexServiceClient.PollOnceUpdateZoneAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Zone retrievedResult = retrievedResponse.Result;
}