Class DataplexServiceClient (2.1.0)

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);