Cloud Dataplex v1 API - Class DataplexServiceClient (2.13.0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Create client
gcdv::DataplexServiceClient dataplexServiceClient = gcdv::DataplexServiceClient.Create();
// Initialize request argument(s)
gcdv::LakeName name = gcdv::LakeName.FromProjectLocationLake("[PROJECT]", "[LOCATION]", "[LAKE]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = dataplexServiceClient.DeleteLake(name);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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