Cloud Dataplex v1 API - Class DataplexServiceClient (3.4.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

Inherited Members

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ToString()

Derived Types

DataplexServiceClientImpl

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:

https://www.googleapis.com/auth/cloud-platform

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