public abstract class DataplexServiceClient
Reference documentation and code samples for the Cloud Dataplex v1 API class DataplexServiceClient.
DataplexService client wrapper, for convenient use.
Derived Types
Namespace
Google.Cloud.Dataplex.V1Assembly
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 |
IReadOnlyList<String> |
The default DataplexService scopes are:
DeleteAssetOperationsClient
public virtual OperationsClient DeleteAssetOperationsClient { get; }
The long-running operations client for DeleteAsset
.
Property Value | |
---|---|
Type | Description |
OperationsClient |
DeleteEnvironmentOperationsClient
public virtual OperationsClient DeleteEnvironmentOperationsClient { get; }
The long-running operations client for DeleteEnvironment
.
Property Value | |
---|---|
Type | Description |
OperationsClient |
DeleteLakeOperationsClient
public virtual OperationsClient DeleteLakeOperationsClient { get; }
The long-running operations client for DeleteLake
.
Property Value | |
---|---|
Type | Description |
OperationsClient |
DeleteTaskOperationsClient
public virtual OperationsClient DeleteTaskOperationsClient { get; }
The long-running operations client for DeleteTask
.
Property Value | |
---|---|
Type | Description |
OperationsClient |
DeleteZoneOperationsClient
public virtual OperationsClient DeleteZoneOperationsClient { get; }
The long-running operations client for DeleteZone
.
Property Value | |
---|---|
Type | Description |
OperationsClient |
GrpcClient
public virtual DataplexService.DataplexServiceClient GrpcClient { get; }
The underlying gRPC DataplexService client
Property Value | |
---|---|
Type | Description |
DataplexService.DataplexServiceClient |
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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
CancelJobRequest request = new CancelJobRequest
{
JobName = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
JobName name = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
// Create client
DataplexServiceClient dataplexServiceClient = 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. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CancelJobRequest request = new CancelJobRequest
{
JobName = 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. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CancelJobRequest request = new CancelJobRequest
{
JobName = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
JobName name = 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
JobName name = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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 |
Operation<Asset, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
CreateAssetRequest request = new CreateAssetRequest
{
ParentAsZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
AssetId = "",
Asset = new Asset(),
ValidateOnly = false,
};
// Make the request
Operation<Asset, OperationMetadata> response = dataplexServiceClient.CreateAsset(request);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Asset, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Asset, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = dataplexServiceClient.CreateAsset(parent, asset, assetId);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Asset, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Asset, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = dataplexServiceClient.CreateAsset(parent, asset, assetId);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Asset, 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
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 |
Task<Operation<Asset, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateAssetRequest request = new CreateAssetRequest
{
ParentAsZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
AssetId = "",
Asset = new Asset(),
ValidateOnly = false,
};
// Make the request
Operation<Asset, OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(request);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Asset, 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
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 |
Task<Operation<Asset, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateAssetRequest request = new CreateAssetRequest
{
ParentAsZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
AssetId = "",
Asset = new Asset(),
ValidateOnly = false,
};
// Make the request
Operation<Asset, OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(request);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Asset, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Asset, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Asset, 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
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:
|
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.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Asset, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
ZoneName parent = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Asset, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Asset, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Asset, 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
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:
|
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.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Asset, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await dataplexServiceClient.CreateAssetAsync(parent, asset, assetId);
// Poll until the returned long-running operation is complete
Operation<Asset, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Asset, 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
Asset retrievedResult = retrievedResponse.Result;
}
CreateAsync(CancellationToken)
public static Task<DataplexServiceClient> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))
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 |
Task<DataplexServiceClient> | 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 |
Operation<Environment, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
CreateEnvironmentRequest request = new CreateEnvironmentRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
EnvironmentId = "",
Environment = new gcdv::Environment(),
ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, OperationMetadata> response = dataplexServiceClient.CreateEnvironment(request);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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:
|
environment | Environment Required. Environment resource. |
environmentId | String Required. Environment identifier.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Environment, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, OperationMetadata> response = dataplexServiceClient.CreateEnvironment(parent, environment, environmentId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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:
|
environment | Environment Required. Environment resource. |
environmentId | String Required. Environment identifier.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Environment, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = 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, OperationMetadata> response = dataplexServiceClient.CreateEnvironment(parent, environment, environmentId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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 |
Task<Operation<Environment, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateEnvironmentRequest request = new CreateEnvironmentRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
EnvironmentId = "",
Environment = new gcdv::Environment(),
ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(request);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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 |
Task<Operation<Environment, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateEnvironmentRequest request = new CreateEnvironmentRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
EnvironmentId = "",
Environment = new gcdv::Environment(),
ValidateOnly = false,
};
// Make the request
Operation<gcdv::Environment, OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(request);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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:
|
environment | Environment Required. Environment resource. |
environmentId | String Required. Environment identifier.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Environment, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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:
|
environment | Environment Required. Environment resource. |
environmentId | String Required. Environment identifier.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Environment, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Environment environment = new gcdv::Environment();
string environmentId = "";
// Make the request
Operation<gcdv::Environment, OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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:
|
environment | Environment Required. Environment resource. |
environmentId | String Required. Environment identifier.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Environment, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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, OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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:
|
environment | Environment Required. Environment resource. |
environmentId | String Required. Environment identifier.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Environment, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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, OperationMetadata> response = await dataplexServiceClient.CreateEnvironmentAsync(parent, environment, environmentId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Environment, 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, 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 |
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Lake, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Lake lake = new Lake();
string lakeId = "";
// Make the request
Operation<Lake, OperationMetadata> response = dataplexServiceClient.CreateLake(parent, lake, lakeId);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Lake, 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
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 |
Operation<Lake, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
CreateLakeRequest request = new CreateLakeRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
LakeId = "",
Lake = new Lake(),
ValidateOnly = false,
};
// Make the request
Operation<Lake, OperationMetadata> response = dataplexServiceClient.CreateLake(request);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Lake, 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
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 |
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Lake, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Lake lake = new Lake();
string lakeId = "";
// Make the request
Operation<Lake, OperationMetadata> response = dataplexServiceClient.CreateLake(parent, lake, lakeId);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Lake, 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
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 |
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Lake, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Lake lake = new Lake();
string lakeId = "";
// Make the request
Operation<Lake, OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Lake, 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
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 |
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.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Lake, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Lake lake = new Lake();
string lakeId = "";
// Make the request
Operation<Lake, OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Lake, 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
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 |
Task<Operation<Lake, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateLakeRequest request = new CreateLakeRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
LakeId = "",
Lake = new Lake(),
ValidateOnly = false,
};
// Make the request
Operation<Lake, OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(request);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Lake, 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
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 |
Task<Operation<Lake, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateLakeRequest request = new CreateLakeRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
LakeId = "",
Lake = new Lake(),
ValidateOnly = false,
};
// Make the request
Operation<Lake, OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(request);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Lake, 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
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 |
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Lake, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Lake lake = new Lake();
string lakeId = "";
// Make the request
Operation<Lake, OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Lake, 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
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 |
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.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Lake, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Lake lake = new Lake();
string lakeId = "";
// Make the request
Operation<Lake, OperationMetadata> response = await dataplexServiceClient.CreateLakeAsync(parent, lake, lakeId);
// Poll until the returned long-running operation is complete
Operation<Lake, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Lake, 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
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 |
Operation<Task, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
CreateTaskRequest request = new CreateTaskRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
TaskId = "",
Task = new gcdv::Task(),
ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, OperationMetadata> response = dataplexServiceClient.CreateTask(request);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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:
|
task | Task Required. Task resource. |
taskId | String Required. Task identifier. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Task, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, OperationMetadata> response = dataplexServiceClient.CreateTask(parent, task, taskId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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:
|
task | Task Required. Task resource. |
taskId | String Required. Task identifier. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Task, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = 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, OperationMetadata> response = dataplexServiceClient.CreateTask(parent, task, taskId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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 |
Task<Operation<Task, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTaskRequest request = new CreateTaskRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
TaskId = "",
Task = new gcdv::Task(),
ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(request);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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 |
Task<Operation<Task, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateTaskRequest request = new CreateTaskRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
TaskId = "",
Task = new gcdv::Task(),
ValidateOnly = false,
};
// Make the request
Operation<gcdv::Task, OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(request);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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:
|
task | Task Required. Task resource. |
taskId | String Required. Task identifier. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Task, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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:
|
task | Task Required. Task resource. |
taskId | String Required. Task identifier. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Task, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
gcdv::Task task = new gcdv::Task();
string taskId = "";
// Make the request
Operation<gcdv::Task, OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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:
|
task | Task Required. Task resource. |
taskId | String Required. Task identifier. |
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Task, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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, OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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:
|
task | Task Required. Task resource. |
taskId | String Required. Task identifier. |
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Task, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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, OperationMetadata> response = await dataplexServiceClient.CreateTaskAsync(parent, task, taskId);
// Poll until the returned long-running operation is complete
Operation<gcdv::Task, 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, 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 |
Operation<Zone, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
CreateZoneRequest request = new CreateZoneRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
ZoneId = "",
Zone = new Zone(),
ValidateOnly = false,
};
// Make the request
Operation<Zone, OperationMetadata> response = dataplexServiceClient.CreateZone(request);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Zone, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Zone, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = dataplexServiceClient.CreateZone(parent, zone, zoneId);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Zone, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Zone, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = dataplexServiceClient.CreateZone(parent, zone, zoneId);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
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<Zone, 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
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 |
Task<Operation<Zone, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateZoneRequest request = new CreateZoneRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
ZoneId = "",
Zone = new Zone(),
ValidateOnly = false,
};
// Make the request
Operation<Zone, OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(request);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Zone, 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
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 |
Task<Operation<Zone, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
CreateZoneRequest request = new CreateZoneRequest
{
ParentAsLakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
ZoneId = "",
Zone = new Zone(),
ValidateOnly = false,
};
// Make the request
Operation<Zone, OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(request);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Zone, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Zone, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Zone, 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
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:
|
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.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Zone, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName parent = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Zone, 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
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:
|
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.
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Zone, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Zone, 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
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:
|
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.
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Zone, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
Zone zone = new Zone();
string zoneId = "";
// Make the request
Operation<Zone, OperationMetadata> response = await dataplexServiceClient.CreateZoneAsync(parent, zone, zoneId);
// Poll until the returned long-running operation is complete
Operation<Zone, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
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<Zone, 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
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteAsset(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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 |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
AssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteAsset(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteAsset(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
AssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
AssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteAssetAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
DeleteEnvironmentRequest request = new DeleteEnvironmentRequest
{
EnvironmentName = EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteEnvironment(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
EnvironmentName name = EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteEnvironment(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteEnvironment(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteEnvironmentRequest request = new DeleteEnvironmentRequest
{
EnvironmentName = EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteEnvironmentRequest request = new DeleteEnvironmentRequest
{
EnvironmentName = EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
EnvironmentName name = EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
EnvironmentName name = EnvironmentName.FromProjectLocationLakeEnvironment("[PROJECT]", "[LOCATION]", "[LAKE]", "[ENVIRONMENT]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/environments/[ENVIRONMENT]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteEnvironmentAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
DeleteLakeRequest request = new DeleteLakeRequest
{
LakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteLake(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
LakeName name = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteLake(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteLake(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteLakeRequest request = new DeleteLakeRequest
{
LakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteLakeRequest request = new DeleteLakeRequest
{
LakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName name = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName name = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteLakeAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
DeleteTaskRequest request = new DeleteTaskRequest
{
TaskName = TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteTask(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
TaskName name = TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteTask(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteTask(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTaskRequest request = new DeleteTaskRequest
{
TaskName = TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteTaskRequest request = new DeleteTaskRequest
{
TaskName = TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
TaskName name = TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
TaskName name = TaskName.FromProjectLocationLakeTask("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteTaskAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
DeleteZoneRequest request = new DeleteZoneRequest
{
ZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteZone(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteZone(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Operation<Empty, OperationMetadata> | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Operation<Empty, OperationMetadata> response = dataplexServiceClient.DeleteZone(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteZoneRequest request = new DeleteZoneRequest
{
ZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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 |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteZoneRequest request = new DeleteZoneRequest
{
ZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(request);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Operation<Empty, OperationMetadata>> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Operation<Empty, OperationMetadata> response = await dataplexServiceClient.DeleteZoneAsync(name);
// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Asset | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
GetAssetRequest request = new GetAssetRequest
{
AssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Asset | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Asset> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Asset> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
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 |
Task<Asset> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetAssetRequest request = new GetAssetRequest
{
AssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
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 |
Task<Asset> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetAssetRequest request = new GetAssetRequest
{
AssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Asset> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Asset> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Environment | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
EnvironmentName name = 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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
GetEnvironmentRequest request = new GetEnvironmentRequest
{
EnvironmentName = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Environment | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Environment> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
EnvironmentName name = 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Environment> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
EnvironmentName name = 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 |
Task<Environment> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetEnvironmentRequest request = new GetEnvironmentRequest
{
EnvironmentName = 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 |
Task<Environment> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetEnvironmentRequest request = new GetEnvironmentRequest
{
EnvironmentName = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Environment> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Environment> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
GetJobRequest request = new GetJobRequest
{
JobName = JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Job | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
JobName name = JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Job | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
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 |
Task<Job> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetJobRequest request = new GetJobRequest
{
JobName = JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
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 |
Task<Job> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetJobRequest request = new GetJobRequest
{
JobName = JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Job> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
JobName name = JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Job> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
JobName name = JobName.FromProjectLocationLakeTaskJob("[PROJECT]", "[LOCATION]", "[LAKE]", "[TASK]", "[JOB]");
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Job> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Job> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/tasks/[TASK]/jobs/[JOB]";
// Make the request
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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
GetLakeRequest request = new GetLakeRequest
{
LakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Lake | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
LakeName name = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Lake | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
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 |
Task<Lake> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetLakeRequest request = new GetLakeRequest
{
LakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
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 |
Task<Lake> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetLakeRequest request = new GetLakeRequest
{
LakeName = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Lake> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName name = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Lake> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
LakeName name = LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Lake> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Lake> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]";
// Make the request
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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
GetTaskRequest request = new GetTaskRequest
{
TaskName = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
TaskName name = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = 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 |
Task<Task> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetTaskRequest request = new GetTaskRequest
{
TaskName = 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 |
Task<Task> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetTaskRequest request = new GetTaskRequest
{
TaskName = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Task> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
TaskName name = 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Task> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
TaskName name = 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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Task> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Task> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await 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. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
GetZoneRequest request = new GetZoneRequest
{
ZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Zone | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Zone | The RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
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 |
Task<Zone> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetZoneRequest request = new GetZoneRequest
{
ZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
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 |
Task<Zone> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
GetZoneRequest request = new GetZoneRequest
{
ZoneName = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]"),
};
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Zone> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Zone> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
ZoneName name = ZoneName.FromProjectLocationLakeZone("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]");
// Make the request
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:
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
Task<Zone> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
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:
|
cancellationToken | CancellationToken A CancellationToken to use for this RPC. |
Returns | |
---|---|
Type | Description |
Task<Zone> | A Task containing the RPC response. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]";
// Make the request
Zone response = await dataplexServiceClient.GetZoneAsync(name);
ListAssetActions(AssetName, String, Nullable<Int32>, 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:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
PagedEnumerable<ListActionsResponse, Action> | A pageable sequence of Action resources. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
AssetName parent = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
PagedEnumerable<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 (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 |
PagedEnumerable<ListActionsResponse, Action> | A pageable sequence of Action resources. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
ListAssetActionsRequest request = new ListAssetActionsRequest
{
ParentAsAssetName = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]"),
};
// Make the request
PagedEnumerable<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 (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, Nullable<Int32>, 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:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
PagedEnumerable<ListActionsResponse, Action> | A pageable sequence of Action resources. |
// Create client
DataplexServiceClient dataplexServiceClient = DataplexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/lakes/[LAKE]/zones/[ZONE]/assets/[ASSET]";
// Make the request
PagedEnumerable<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 (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, Nullable<Int32>, 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:
|
pageToken | String The token returned from the previous request. A value of |
pageSize | Nullable<Int32> The size of page to request. The response will not be larger than this, but may be smaller. A value of
|
callSettings | CallSettings If not null, applies overrides to this RPC call. |
Returns | |
---|---|
Type | Description |
PagedAsyncEnumerable<ListActionsResponse, Action> | A pageable asynchronous sequence of Action resources. |
// Create client
DataplexServiceClient dataplexServiceClient = await DataplexServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName parent = AssetName.FromProjectLocationLakeZoneAsset("[PROJECT]", "[LOCATION]", "[LAKE]", "[ZONE]", "[ASSET]");
// Make the request
PagedAsyncEnumerable<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((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. |
|