Cloud Dataplex v1 API - Class BusinessGlossaryServiceClient (3.10.0)

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::Glossary glossary = new gcdv::Glossary();
string glossaryId = "";
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = businessGlossaryServiceClient.CreateGlossary(parent, glossary, glossaryId);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = businessGlossaryServiceClient.PollOnceCreateGlossary(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateGlossaryRequest request = new gcdv::CreateGlossaryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GlossaryId = "",
    Glossary = new gcdv::Glossary(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = businessGlossaryServiceClient.CreateGlossary(request);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = businessGlossaryServiceClient.PollOnceCreateGlossary(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::Glossary glossary = new gcdv::Glossary();
string glossaryId = "";
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = businessGlossaryServiceClient.CreateGlossary(parent, glossary, glossaryId);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = businessGlossaryServiceClient.PollOnceCreateGlossary(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::Glossary glossary = new gcdv::Glossary();
string glossaryId = "";
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.CreateGlossaryAsync(parent, glossary, glossaryId);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcdv::Glossary glossary = new gcdv::Glossary();
string glossaryId = "";
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.CreateGlossaryAsync(parent, glossary, glossaryId);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateGlossaryRequest request = new gcdv::CreateGlossaryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GlossaryId = "",
    Glossary = new gcdv::Glossary(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.CreateGlossaryAsync(request);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateGlossaryRequest request = new gcdv::CreateGlossaryRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GlossaryId = "",
    Glossary = new gcdv::Glossary(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.CreateGlossaryAsync(request);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::Glossary glossary = new gcdv::Glossary();
string glossaryId = "";
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.CreateGlossaryAsync(parent, glossary, glossaryId);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcdv::Glossary glossary = new gcdv::Glossary();
string glossaryId = "";
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.CreateGlossaryAsync(parent, glossary, glossaryId);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceCreateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateGlossaryCategoryRequest request = new gcdv::CreateGlossaryCategoryRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    CategoryId = "",
    Category = new gcdv::GlossaryCategory(),
};
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.CreateGlossaryCategory(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
string categoryId = "";
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.CreateGlossaryCategory(parent, category, categoryId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
string categoryId = "";
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.CreateGlossaryCategory(parent, category, categoryId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateGlossaryCategoryRequest request = new gcdv::CreateGlossaryCategoryRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    CategoryId = "",
    Category = new gcdv::GlossaryCategory(),
};
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.CreateGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateGlossaryCategoryRequest request = new gcdv::CreateGlossaryCategoryRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    CategoryId = "",
    Category = new gcdv::GlossaryCategory(),
};
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.CreateGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
string categoryId = "";
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.CreateGlossaryCategoryAsync(parent, category, categoryId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
string categoryId = "";
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.CreateGlossaryCategoryAsync(parent, category, categoryId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
string categoryId = "";
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.CreateGlossaryCategoryAsync(parent, category, categoryId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
string categoryId = "";
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.CreateGlossaryCategoryAsync(parent, category, categoryId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::CreateGlossaryTermRequest request = new gcdv::CreateGlossaryTermRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    TermId = "",
    Term = new gcdv::GlossaryTerm(),
};
// Make the request
gcdv::GlossaryTerm response = businessGlossaryServiceClient.CreateGlossaryTerm(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
gcdv::GlossaryTerm term = new gcdv::GlossaryTerm();
string termId = "";
// Make the request
gcdv::GlossaryTerm response = businessGlossaryServiceClient.CreateGlossaryTerm(parent, term, termId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
gcdv::GlossaryTerm term = new gcdv::GlossaryTerm();
string termId = "";
// Make the request
gcdv::GlossaryTerm response = businessGlossaryServiceClient.CreateGlossaryTerm(parent, term, termId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateGlossaryTermRequest request = new gcdv::CreateGlossaryTermRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    TermId = "",
    Term = new gcdv::GlossaryTerm(),
};
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.CreateGlossaryTermAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::CreateGlossaryTermRequest request = new gcdv::CreateGlossaryTermRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    TermId = "",
    Term = new gcdv::GlossaryTerm(),
};
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.CreateGlossaryTermAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
gcdv::GlossaryTerm term = new gcdv::GlossaryTerm();
string termId = "";
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.CreateGlossaryTermAsync(parent, term, termId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
gcdv::GlossaryTerm term = new gcdv::GlossaryTerm();
string termId = "";
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.CreateGlossaryTermAsync(parent, term, termId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
gcdv::GlossaryTerm term = new gcdv::GlossaryTerm();
string termId = "";
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.CreateGlossaryTermAsync(parent, term, termId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
gcdv::GlossaryTerm term = new gcdv::GlossaryTerm();
string termId = "";
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.CreateGlossaryTermAsync(parent, term, termId);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteGlossaryRequest request = new gcdv::DeleteGlossaryRequest
{
    GlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Etag = "",
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = businessGlossaryServiceClient.DeleteGlossary(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 = businessGlossaryServiceClient.PollOnceDeleteGlossary(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryName name = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = businessGlossaryServiceClient.DeleteGlossary(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 = businessGlossaryServiceClient.PollOnceDeleteGlossary(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = businessGlossaryServiceClient.DeleteGlossary(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 = businessGlossaryServiceClient.PollOnceDeleteGlossary(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteGlossaryRequest request = new gcdv::DeleteGlossaryRequest
{
    GlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Etag = "",
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.DeleteGlossaryAsync(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 businessGlossaryServiceClient.PollOnceDeleteGlossaryAsync(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteGlossaryRequest request = new gcdv::DeleteGlossaryRequest
{
    GlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Etag = "",
};
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.DeleteGlossaryAsync(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 businessGlossaryServiceClient.PollOnceDeleteGlossaryAsync(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName name = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.DeleteGlossaryAsync(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 businessGlossaryServiceClient.PollOnceDeleteGlossaryAsync(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName name = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.DeleteGlossaryAsync(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 businessGlossaryServiceClient.PollOnceDeleteGlossaryAsync(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.DeleteGlossaryAsync(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 businessGlossaryServiceClient.PollOnceDeleteGlossaryAsync(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
Operation<Empty, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.DeleteGlossaryAsync(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 businessGlossaryServiceClient.PollOnceDeleteGlossaryAsync(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::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteGlossaryCategoryRequest request = new gcdv::DeleteGlossaryCategoryRequest
{
    GlossaryCategoryName = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]"),
};
// Make the request
businessGlossaryServiceClient.DeleteGlossaryCategory(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryCategoryName name = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]");
// Make the request
businessGlossaryServiceClient.DeleteGlossaryCategory(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/categories/[GLOSSARY_CATEGORY]";
// Make the request
businessGlossaryServiceClient.DeleteGlossaryCategory(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteGlossaryCategoryRequest request = new gcdv::DeleteGlossaryCategoryRequest
{
    GlossaryCategoryName = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]"),
};
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteGlossaryCategoryRequest request = new gcdv::DeleteGlossaryCategoryRequest
{
    GlossaryCategoryName = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]"),
};
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryCategoryName name = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]");
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryCategoryName name = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]");
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/categories/[GLOSSARY_CATEGORY]";
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/categories/[GLOSSARY_CATEGORY]";
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::DeleteGlossaryTermRequest request = new gcdv::DeleteGlossaryTermRequest
{
    GlossaryTermName = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]"),
};
// Make the request
businessGlossaryServiceClient.DeleteGlossaryTerm(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryTermName name = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]");
// Make the request
businessGlossaryServiceClient.DeleteGlossaryTerm(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/terms/[GLOSSARY_TERM]";
// Make the request
businessGlossaryServiceClient.DeleteGlossaryTerm(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteGlossaryTermRequest request = new gcdv::DeleteGlossaryTermRequest
{
    GlossaryTermName = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]"),
};
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryTermAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::DeleteGlossaryTermRequest request = new gcdv::DeleteGlossaryTermRequest
{
    GlossaryTermName = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]"),
};
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryTermAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryTermName name = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]");
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryTermName name = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]");
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/terms/[GLOSSARY_TERM]";
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/terms/[GLOSSARY_TERM]";
// Make the request
await businessGlossaryServiceClient.DeleteGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GetGlossaryRequest request = new gcdv::GetGlossaryRequest
{
    GlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
};
// Make the request
gcdv::Glossary response = businessGlossaryServiceClient.GetGlossary(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryName name = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
gcdv::Glossary response = businessGlossaryServiceClient.GetGlossary(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
gcdv::Glossary response = businessGlossaryServiceClient.GetGlossary(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetGlossaryRequest request = new gcdv::GetGlossaryRequest
{
    GlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
};
// Make the request
gcdv::Glossary response = await businessGlossaryServiceClient.GetGlossaryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetGlossaryRequest request = new gcdv::GetGlossaryRequest
{
    GlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
};
// Make the request
gcdv::Glossary response = await businessGlossaryServiceClient.GetGlossaryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName name = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
gcdv::Glossary response = await businessGlossaryServiceClient.GetGlossaryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName name = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
gcdv::Glossary response = await businessGlossaryServiceClient.GetGlossaryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
gcdv::Glossary response = await businessGlossaryServiceClient.GetGlossaryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
gcdv::Glossary response = await businessGlossaryServiceClient.GetGlossaryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GetGlossaryCategoryRequest request = new gcdv::GetGlossaryCategoryRequest
{
    GlossaryCategoryName = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]"),
};
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.GetGlossaryCategory(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryCategoryName name = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]");
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.GetGlossaryCategory(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/categories/[GLOSSARY_CATEGORY]";
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.GetGlossaryCategory(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetGlossaryCategoryRequest request = new gcdv::GetGlossaryCategoryRequest
{
    GlossaryCategoryName = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]"),
};
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.GetGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetGlossaryCategoryRequest request = new gcdv::GetGlossaryCategoryRequest
{
    GlossaryCategoryName = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]"),
};
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.GetGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryCategoryName name = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]");
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.GetGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryCategoryName name = gcdv::GlossaryCategoryName.FromProjectLocationGlossaryGlossaryCategory("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_CATEGORY]");
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.GetGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/categories/[GLOSSARY_CATEGORY]";
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.GetGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/categories/[GLOSSARY_CATEGORY]";
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.GetGlossaryCategoryAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GetGlossaryTermRequest request = new gcdv::GetGlossaryTermRequest
{
    GlossaryTermName = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]"),
};
// Make the request
gcdv::GlossaryTerm response = businessGlossaryServiceClient.GetGlossaryTerm(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryTermName name = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]");
// Make the request
gcdv::GlossaryTerm response = businessGlossaryServiceClient.GetGlossaryTerm(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/terms/[GLOSSARY_TERM]";
// Make the request
gcdv::GlossaryTerm response = businessGlossaryServiceClient.GetGlossaryTerm(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetGlossaryTermRequest request = new gcdv::GetGlossaryTermRequest
{
    GlossaryTermName = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]"),
};
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.GetGlossaryTermAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GetGlossaryTermRequest request = new gcdv::GetGlossaryTermRequest
{
    GlossaryTermName = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]"),
};
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.GetGlossaryTermAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryTermName name = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]");
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.GetGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryTermName name = gcdv::GlossaryTermName.FromProjectLocationGlossaryGlossaryTerm("[PROJECT]", "[LOCATION]", "[GLOSSARY]", "[GLOSSARY_TERM]");
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.GetGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/terms/[GLOSSARY_TERM]";
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.GetGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]/terms/[GLOSSARY_TERM]";
// Make the request
gcdv::GlossaryTerm response = await businessGlossaryServiceClient.GetGlossaryTermAsync(name);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<gcdv::ListGlossariesResponse, gcdv::Glossary> response = businessGlossaryServiceClient.ListGlossaries(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::Glossary> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::Glossary 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::ListGlossariesRequest request = new gcdv::ListGlossariesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListGlossariesResponse, gcdv::Glossary> response = businessGlossaryServiceClient.ListGlossaries(request);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::Glossary> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::Glossary 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<gcdv::ListGlossariesResponse, gcdv::Glossary> response = businessGlossaryServiceClient.ListGlossaries(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::Glossary> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::Glossary 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossariesResponse, gcdv::Glossary> response = businessGlossaryServiceClient.ListGlossariesAsync(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::Glossary> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::Glossary 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListGlossariesRequest request = new gcdv::ListGlossariesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossariesResponse, gcdv::Glossary> response = businessGlossaryServiceClient.ListGlossariesAsync(request);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::Glossary> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::Glossary 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossariesResponse, gcdv::Glossary> response = businessGlossaryServiceClient.ListGlossariesAsync(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::Glossary> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::Glossary 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
PagedEnumerable<gcdv::ListGlossaryCategoriesResponse, gcdv::GlossaryCategory> response = businessGlossaryServiceClient.ListGlossaryCategories(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryCategory> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryCategory 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::ListGlossaryCategoriesRequest request = new gcdv::ListGlossaryCategoriesRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListGlossaryCategoriesResponse, gcdv::GlossaryCategory> response = businessGlossaryServiceClient.ListGlossaryCategories(request);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryCategory> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryCategory 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
PagedEnumerable<gcdv::ListGlossaryCategoriesResponse, gcdv::GlossaryCategory> response = businessGlossaryServiceClient.ListGlossaryCategories(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryCategory> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryCategory 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossaryCategoriesResponse, gcdv::GlossaryCategory> response = businessGlossaryServiceClient.ListGlossaryCategoriesAsync(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryCategory> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryCategory 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListGlossaryCategoriesRequest request = new gcdv::ListGlossaryCategoriesRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossaryCategoriesResponse, gcdv::GlossaryCategory> response = businessGlossaryServiceClient.ListGlossaryCategoriesAsync(request);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryCategory> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryCategory 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossaryCategoriesResponse, gcdv::GlossaryCategory> response = businessGlossaryServiceClient.ListGlossaryCategoriesAsync(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryCategory> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryCategory 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
PagedEnumerable<gcdv::ListGlossaryTermsResponse, gcdv::GlossaryTerm> response = businessGlossaryServiceClient.ListGlossaryTerms(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryTerm> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryTerm 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::ListGlossaryTermsRequest request = new gcdv::ListGlossaryTermsRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<gcdv::ListGlossaryTermsResponse, gcdv::GlossaryTerm> response = businessGlossaryServiceClient.ListGlossaryTerms(request);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryTerm> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryTerm 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
PagedEnumerable<gcdv::ListGlossaryTermsResponse, gcdv::GlossaryTerm> response = businessGlossaryServiceClient.ListGlossaryTerms(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryTerm> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryTerm 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryName parent = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]");
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossaryTermsResponse, gcdv::GlossaryTerm> response = businessGlossaryServiceClient.ListGlossaryTermsAsync(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryTerm> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryTerm 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::ListGlossaryTermsRequest request = new gcdv::ListGlossaryTermsRequest
{
    ParentAsGlossaryName = gcdv::GlossaryName.FromProjectLocationGlossary("[PROJECT]", "[LOCATION]", "[GLOSSARY]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossaryTermsResponse, gcdv::GlossaryTerm> response = businessGlossaryServiceClient.ListGlossaryTermsAsync(request);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryTerm> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryTerm 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/glossaries/[GLOSSARY]";
// Make the request
PagedAsyncEnumerable<gcdv::ListGlossaryTermsResponse, gcdv::GlossaryTerm> response = businessGlossaryServiceClient.ListGlossaryTermsAsync(parent);

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

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

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<gcdv::GlossaryTerm> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (gcdv::GlossaryTerm 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
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::Glossary glossary = new gcdv::Glossary();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = businessGlossaryServiceClient.UpdateGlossary(glossary, updateMask);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = businessGlossaryServiceClient.PollOnceUpdateGlossary(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateGlossaryRequest request = new gcdv::UpdateGlossaryRequest
{
    Glossary = new gcdv::Glossary(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = businessGlossaryServiceClient.UpdateGlossary(request);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = businessGlossaryServiceClient.PollOnceUpdateGlossary(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Glossary glossary = new gcdv::Glossary();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.UpdateGlossaryAsync(glossary, updateMask);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceUpdateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::Glossary glossary = new gcdv::Glossary();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.UpdateGlossaryAsync(glossary, updateMask);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceUpdateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateGlossaryRequest request = new gcdv::UpdateGlossaryRequest
{
    Glossary = new gcdv::Glossary(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.UpdateGlossaryAsync(request);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceUpdateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateGlossaryRequest request = new gcdv::UpdateGlossaryRequest
{
    Glossary = new gcdv::Glossary(),
    UpdateMask = new FieldMask(),
    ValidateOnly = false,
};
// Make the request
Operation<gcdv::Glossary, gcdv::OperationMetadata> response = await businessGlossaryServiceClient.UpdateGlossaryAsync(request);

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

// Or get 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::Glossary, gcdv::OperationMetadata> retrievedResponse = await businessGlossaryServiceClient.PollOnceUpdateGlossaryAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcdv::Glossary retrievedResult = retrievedResponse.Result;
}

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
FieldMask updateMask = new FieldMask();
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.UpdateGlossaryCategory(category, updateMask);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = gcdv::BusinessGlossaryServiceClient.Create();
// Initialize request argument(s)
gcdv::UpdateGlossaryCategoryRequest request = new gcdv::UpdateGlossaryCategoryRequest
{
    Category = new gcdv::GlossaryCategory(),
    UpdateMask = new FieldMask(),
};
// Make the request
gcdv::GlossaryCategory response = businessGlossaryServiceClient.UpdateGlossaryCategory(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
FieldMask updateMask = new FieldMask();
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.UpdateGlossaryCategoryAsync(category, updateMask);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::GlossaryCategory category = new gcdv::GlossaryCategory();
FieldMask updateMask = new FieldMask();
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.UpdateGlossaryCategoryAsync(category, updateMask);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateGlossaryCategoryRequest request = new gcdv::UpdateGlossaryCategoryRequest
{
    Category = new gcdv::GlossaryCategory(),
    UpdateMask = new FieldMask(),
};
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.UpdateGlossaryCategoryAsync(request);

// Create client
gcdv::BusinessGlossaryServiceClient businessGlossaryServiceClient = await gcdv::BusinessGlossaryServiceClient.CreateAsync();
// Initialize request argument(s)
gcdv::UpdateGlossaryCategoryRequest request = new gcdv::UpdateGlossaryCategoryRequest
{
    Category = new gcdv::GlossaryCategory(),
    UpdateMask = new FieldMask(),
};
// Make the request
gcdv::GlossaryCategory response = await businessGlossaryServiceClient.UpdateGlossaryCategoryAsync(request);