Cloud AI Platform v1beta1 API - Class FeatureRegistryServiceClient (1.0.0-beta09)

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Feature = new Feature(),
    FeatureId = "",
};
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featureRegistryServiceClient.CreateFeature(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featureRegistryServiceClient.CreateFeature(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featureRegistryServiceClient.CreateFeature(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featureRegistryServiceClient.CreateFeature(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Feature = new Feature(),
    FeatureId = "",
};
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Feature = new Feature(),
    FeatureId = "",
};
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
FeatureGroup featureGroup = new FeatureGroup();
string featureGroupId = "";
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = featureRegistryServiceClient.CreateFeatureGroup(parent, featureGroup, featureGroupId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
CreateFeatureGroupRequest request = new CreateFeatureGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    FeatureGroup = new FeatureGroup(),
    FeatureGroupId = "",
};
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = featureRegistryServiceClient.CreateFeatureGroup(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
FeatureGroup featureGroup = new FeatureGroup();
string featureGroupId = "";
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = featureRegistryServiceClient.CreateFeatureGroup(parent, featureGroup, featureGroupId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
FeatureGroup featureGroup = new FeatureGroup();
string featureGroupId = "";
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureGroupAsync(parent, featureGroup, featureGroupId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
FeatureGroup featureGroup = new FeatureGroup();
string featureGroupId = "";
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureGroupAsync(parent, featureGroup, featureGroupId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureGroupRequest request = new CreateFeatureGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    FeatureGroup = new FeatureGroup(),
    FeatureGroupId = "",
};
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureGroupAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureGroupRequest request = new CreateFeatureGroupRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    FeatureGroup = new FeatureGroup(),
    FeatureGroupId = "",
};
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureGroupAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
FeatureGroup featureGroup = new FeatureGroup();
string featureGroupId = "";
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureGroupAsync(parent, featureGroup, featureGroupId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
FeatureGroup featureGroup = new FeatureGroup();
string featureGroupId = "";
// Make the request
Operation<FeatureGroup, CreateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.CreateFeatureGroupAsync(parent, featureGroup, featureGroupId);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featureRegistryServiceClient.DeleteFeature(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = featureRegistryServiceClient.PollOnceDeleteFeature(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
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featureRegistryServiceClient.DeleteFeature(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = featureRegistryServiceClient.PollOnceDeleteFeature(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
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featureRegistryServiceClient.DeleteFeature(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = featureRegistryServiceClient.PollOnceDeleteFeature(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
DeleteFeatureGroupRequest request = new DeleteFeatureGroupRequest
{
    FeatureGroupName = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featureRegistryServiceClient.DeleteFeatureGroup(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = featureRegistryServiceClient.PollOnceDeleteFeatureGroup(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
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName name = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featureRegistryServiceClient.DeleteFeatureGroup(name, force);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = featureRegistryServiceClient.PollOnceDeleteFeatureGroup(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
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featureGroups/[FEATURE_GROUP]";
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featureRegistryServiceClient.DeleteFeatureGroup(name, force);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = featureRegistryServiceClient.PollOnceDeleteFeatureGroup(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureGroupRequest request = new DeleteFeatureGroupRequest
{
    FeatureGroupName = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureGroupAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureGroupRequest request = new DeleteFeatureGroupRequest
{
    FeatureGroupName = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureGroupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureGroupAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName name = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureGroupAsync(name, force);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureGroupAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName name = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureGroupAsync(name, force);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureGroupAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featureGroups/[FEATURE_GROUP]";
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureGroupAsync(name, force);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureGroupAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featureGroups/[FEATURE_GROUP]";
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featureRegistryServiceClient.DeleteFeatureGroupAsync(name, force);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteOperationMetadata> 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, DeleteOperationMetadata> retrievedResponse = await featureRegistryServiceClient.PollOnceDeleteFeatureGroupAsync(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
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Feature response = featureRegistryServiceClient.GetFeature(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
GetFeatureRequest request = new GetFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Feature response = featureRegistryServiceClient.GetFeature(request);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Feature response = featureRegistryServiceClient.GetFeature(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Feature response = await featureRegistryServiceClient.GetFeatureAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Feature response = await featureRegistryServiceClient.GetFeatureAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
GetFeatureRequest request = new GetFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Feature response = await featureRegistryServiceClient.GetFeatureAsync(request);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
GetFeatureRequest request = new GetFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Feature response = await featureRegistryServiceClient.GetFeatureAsync(request);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Feature response = await featureRegistryServiceClient.GetFeatureAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Feature response = await featureRegistryServiceClient.GetFeatureAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName name = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
// Make the request
FeatureGroup response = featureRegistryServiceClient.GetFeatureGroup(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
GetFeatureGroupRequest request = new GetFeatureGroupRequest
{
    FeatureGroupName = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]"),
};
// Make the request
FeatureGroup response = featureRegistryServiceClient.GetFeatureGroup(request);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featureGroups/[FEATURE_GROUP]";
// Make the request
FeatureGroup response = featureRegistryServiceClient.GetFeatureGroup(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName name = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
// Make the request
FeatureGroup response = await featureRegistryServiceClient.GetFeatureGroupAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName name = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
// Make the request
FeatureGroup response = await featureRegistryServiceClient.GetFeatureGroupAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
GetFeatureGroupRequest request = new GetFeatureGroupRequest
{
    FeatureGroupName = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]"),
};
// Make the request
FeatureGroup response = await featureRegistryServiceClient.GetFeatureGroupAsync(request);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
GetFeatureGroupRequest request = new GetFeatureGroupRequest
{
    FeatureGroupName = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]"),
};
// Make the request
FeatureGroup response = await featureRegistryServiceClient.GetFeatureGroupAsync(request);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featureGroups/[FEATURE_GROUP]";
// Make the request
FeatureGroup response = await featureRegistryServiceClient.GetFeatureGroupAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featureGroups/[FEATURE_GROUP]";
// Make the request
FeatureGroup response = await featureRegistryServiceClient.GetFeatureGroupAsync(name);

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListFeatureGroupsResponse, FeatureGroup> response = featureRegistryServiceClient.ListFeatureGroups(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (FeatureGroup item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeatureGroupsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (FeatureGroup item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<FeatureGroup> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (FeatureGroup item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
ListFeatureGroupsRequest request = new ListFeatureGroupsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListFeatureGroupsResponse, FeatureGroup> response = featureRegistryServiceClient.ListFeatureGroups(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (FeatureGroup item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeatureGroupsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (FeatureGroup item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<FeatureGroup> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (FeatureGroup item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListFeatureGroupsResponse, FeatureGroup> response = featureRegistryServiceClient.ListFeatureGroups(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (FeatureGroup item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeatureGroupsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (FeatureGroup item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<FeatureGroup> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (FeatureGroup item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListFeatureGroupsResponse, FeatureGroup> response = featureRegistryServiceClient.ListFeatureGroupsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((FeatureGroup item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeatureGroupsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (FeatureGroup item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<FeatureGroup> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (FeatureGroup item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
ListFeatureGroupsRequest request = new ListFeatureGroupsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListFeatureGroupsResponse, FeatureGroup> response = featureRegistryServiceClient.ListFeatureGroupsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((FeatureGroup item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeatureGroupsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (FeatureGroup item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<FeatureGroup> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (FeatureGroup item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListFeatureGroupsResponse, FeatureGroup> response = featureRegistryServiceClient.ListFeatureGroupsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((FeatureGroup item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeatureGroupsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (FeatureGroup item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<FeatureGroup> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (FeatureGroup item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
PagedEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeatures(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Feature item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeaturesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
// Make the request
PagedEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeatures(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Feature item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeaturesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
ListFeaturesRequest request = new ListFeaturesRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Filter = "",
    OrderBy = "",
    ReadMask = new FieldMask(),
    LatestStatsCount = 0,
};
// Make the request
PagedEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeatures(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Feature item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeaturesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
PagedEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeatures(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Feature item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListFeaturesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
PagedAsyncEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeaturesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Feature item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeaturesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
// Make the request
PagedAsyncEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeaturesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Feature item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeaturesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
ListFeaturesRequest request = new ListFeaturesRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Filter = "",
    OrderBy = "",
    ReadMask = new FieldMask(),
    LatestStatsCount = 0,
};
// Make the request
PagedAsyncEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeaturesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Feature item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeaturesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
PagedAsyncEnumerable<ListFeaturesResponse, Feature> response = featureRegistryServiceClient.ListFeaturesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Feature item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListFeaturesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Feature item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Feature> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Feature item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
Feature feature = new Feature();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Feature, UpdateFeatureOperationMetadata> response = featureRegistryServiceClient.UpdateFeature(feature, updateMask);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
UpdateFeatureRequest request = new UpdateFeatureRequest
{
    Feature = new Feature(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Feature, UpdateFeatureOperationMetadata> response = featureRegistryServiceClient.UpdateFeature(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
Feature feature = new Feature();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Feature, UpdateFeatureOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureAsync(feature, updateMask);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
Feature feature = new Feature();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Feature, UpdateFeatureOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureAsync(feature, updateMask);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateFeatureRequest request = new UpdateFeatureRequest
{
    Feature = new Feature(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Feature, UpdateFeatureOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateFeatureRequest request = new UpdateFeatureRequest
{
    Feature = new Feature(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Feature, UpdateFeatureOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
FeatureGroup featureGroup = new FeatureGroup();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<FeatureGroup, UpdateFeatureGroupOperationMetadata> response = featureRegistryServiceClient.UpdateFeatureGroup(featureGroup, updateMask);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = FeatureRegistryServiceClient.Create();
// Initialize request argument(s)
UpdateFeatureGroupRequest request = new UpdateFeatureGroupRequest
{
    FeatureGroup = new FeatureGroup(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<FeatureGroup, UpdateFeatureGroupOperationMetadata> response = featureRegistryServiceClient.UpdateFeatureGroup(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroup featureGroup = new FeatureGroup();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<FeatureGroup, UpdateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureGroupAsync(featureGroup, updateMask);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroup featureGroup = new FeatureGroup();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<FeatureGroup, UpdateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureGroupAsync(featureGroup, updateMask);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateFeatureGroupRequest request = new UpdateFeatureGroupRequest
{
    FeatureGroup = new FeatureGroup(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<FeatureGroup, UpdateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureGroupAsync(request);

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

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

// Create client
FeatureRegistryServiceClient featureRegistryServiceClient = await FeatureRegistryServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateFeatureGroupRequest request = new UpdateFeatureGroupRequest
{
    FeatureGroup = new FeatureGroup(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<FeatureGroup, UpdateFeatureGroupOperationMetadata> response = await featureRegistryServiceClient.UpdateFeatureGroupAsync(request);

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

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