Chronicle v1 API - Class RuleServiceClient (1.0.0-beta02)

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
CreateRetrohuntRequest request = new CreateRetrohuntRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Retrohunt = new Retrohunt(),
};
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = ruleServiceClient.CreateRetrohunt(request);

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

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

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
Retrohunt retrohunt = new Retrohunt();
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = ruleServiceClient.CreateRetrohunt(parent, retrohunt);

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

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

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
Retrohunt retrohunt = new Retrohunt();
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = ruleServiceClient.CreateRetrohunt(parent, retrohunt);

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

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

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRetrohuntRequest request = new CreateRetrohuntRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Retrohunt = new Retrohunt(),
};
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = await ruleServiceClient.CreateRetrohuntAsync(request);

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

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

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRetrohuntRequest request = new CreateRetrohuntRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Retrohunt = new Retrohunt(),
};
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = await ruleServiceClient.CreateRetrohuntAsync(request);

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

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

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
Retrohunt retrohunt = new Retrohunt();
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = await ruleServiceClient.CreateRetrohuntAsync(parent, retrohunt);

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

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

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
Retrohunt retrohunt = new Retrohunt();
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = await ruleServiceClient.CreateRetrohuntAsync(parent, retrohunt);

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

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

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
Retrohunt retrohunt = new Retrohunt();
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = await ruleServiceClient.CreateRetrohuntAsync(parent, retrohunt);

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

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

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
Retrohunt retrohunt = new Retrohunt();
// Make the request
Operation<Retrohunt, RetrohuntMetadata> response = await ruleServiceClient.CreateRetrohuntAsync(parent, retrohunt);

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

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

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
CreateRuleRequest request = new CreateRuleRequest
{
    ParentAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Rule = new Rule(),
};
// Make the request
Rule response = ruleServiceClient.CreateRule(request);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
InstanceName parent = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
Rule rule = new Rule();
// Make the request
Rule response = ruleServiceClient.CreateRule(parent, rule);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
Rule rule = new Rule();
// Make the request
Rule response = ruleServiceClient.CreateRule(parent, rule);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRuleRequest request = new CreateRuleRequest
{
    ParentAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Rule = new Rule(),
};
// Make the request
Rule response = await ruleServiceClient.CreateRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRuleRequest request = new CreateRuleRequest
{
    ParentAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    Rule = new Rule(),
};
// Make the request
Rule response = await ruleServiceClient.CreateRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
InstanceName parent = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
Rule rule = new Rule();
// Make the request
Rule response = await ruleServiceClient.CreateRuleAsync(parent, rule);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
InstanceName parent = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
Rule rule = new Rule();
// Make the request
Rule response = await ruleServiceClient.CreateRuleAsync(parent, rule);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
Rule rule = new Rule();
// Make the request
Rule response = await ruleServiceClient.CreateRuleAsync(parent, rule);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
Rule rule = new Rule();
// Make the request
Rule response = await ruleServiceClient.CreateRuleAsync(parent, rule);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
DeleteRuleRequest request = new DeleteRuleRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Force = false,
};
// Make the request
ruleServiceClient.DeleteRule(request);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
ruleServiceClient.DeleteRule(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
ruleServiceClient.DeleteRule(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRuleRequest request = new DeleteRuleRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Force = false,
};
// Make the request
await ruleServiceClient.DeleteRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRuleRequest request = new DeleteRuleRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Force = false,
};
// Make the request
await ruleServiceClient.DeleteRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
await ruleServiceClient.DeleteRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
await ruleServiceClient.DeleteRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
await ruleServiceClient.DeleteRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
await ruleServiceClient.DeleteRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
GetRetrohuntRequest request = new GetRetrohuntRequest
{
    RetrohuntName = RetrohuntName.FromProjectLocationInstanceRuleRetrohunt("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]", "[RETROHUNT]"),
};
// Make the request
Retrohunt response = ruleServiceClient.GetRetrohunt(request);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RetrohuntName name = RetrohuntName.FromProjectLocationInstanceRuleRetrohunt("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]", "[RETROHUNT]");
// Make the request
Retrohunt response = ruleServiceClient.GetRetrohunt(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]/retrohunts/[RETROHUNT]";
// Make the request
Retrohunt response = ruleServiceClient.GetRetrohunt(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
GetRetrohuntRequest request = new GetRetrohuntRequest
{
    RetrohuntName = RetrohuntName.FromProjectLocationInstanceRuleRetrohunt("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]", "[RETROHUNT]"),
};
// Make the request
Retrohunt response = await ruleServiceClient.GetRetrohuntAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
GetRetrohuntRequest request = new GetRetrohuntRequest
{
    RetrohuntName = RetrohuntName.FromProjectLocationInstanceRuleRetrohunt("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]", "[RETROHUNT]"),
};
// Make the request
Retrohunt response = await ruleServiceClient.GetRetrohuntAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RetrohuntName name = RetrohuntName.FromProjectLocationInstanceRuleRetrohunt("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]", "[RETROHUNT]");
// Make the request
Retrohunt response = await ruleServiceClient.GetRetrohuntAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RetrohuntName name = RetrohuntName.FromProjectLocationInstanceRuleRetrohunt("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]", "[RETROHUNT]");
// Make the request
Retrohunt response = await ruleServiceClient.GetRetrohuntAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]/retrohunts/[RETROHUNT]";
// Make the request
Retrohunt response = await ruleServiceClient.GetRetrohuntAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]/retrohunts/[RETROHUNT]";
// Make the request
Retrohunt response = await ruleServiceClient.GetRetrohuntAsync(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
GetRuleRequest request = new GetRuleRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    View = RuleView.Unspecified,
};
// Make the request
Rule response = ruleServiceClient.GetRule(request);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
Rule response = ruleServiceClient.GetRule(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
Rule response = ruleServiceClient.GetRule(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
GetRuleRequest request = new GetRuleRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    View = RuleView.Unspecified,
};
// Make the request
Rule response = await ruleServiceClient.GetRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
GetRuleRequest request = new GetRuleRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    View = RuleView.Unspecified,
};
// Make the request
Rule response = await ruleServiceClient.GetRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
Rule response = await ruleServiceClient.GetRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
Rule response = await ruleServiceClient.GetRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
Rule response = await ruleServiceClient.GetRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
Rule response = await ruleServiceClient.GetRuleAsync(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
GetRuleDeploymentRequest request = new GetRuleDeploymentRequest
{
    RuleDeploymentName = RuleDeploymentName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
};
// Make the request
RuleDeployment response = ruleServiceClient.GetRuleDeployment(request);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleDeploymentName name = RuleDeploymentName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
RuleDeployment response = ruleServiceClient.GetRuleDeployment(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]/deployment";
// Make the request
RuleDeployment response = ruleServiceClient.GetRuleDeployment(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
GetRuleDeploymentRequest request = new GetRuleDeploymentRequest
{
    RuleDeploymentName = RuleDeploymentName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
};
// Make the request
RuleDeployment response = await ruleServiceClient.GetRuleDeploymentAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
GetRuleDeploymentRequest request = new GetRuleDeploymentRequest
{
    RuleDeploymentName = RuleDeploymentName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
};
// Make the request
RuleDeployment response = await ruleServiceClient.GetRuleDeploymentAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleDeploymentName name = RuleDeploymentName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
RuleDeployment response = await ruleServiceClient.GetRuleDeploymentAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleDeploymentName name = RuleDeploymentName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
RuleDeployment response = await ruleServiceClient.GetRuleDeploymentAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]/deployment";
// Make the request
RuleDeployment response = await ruleServiceClient.GetRuleDeploymentAsync(name);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]/deployment";
// Make the request
RuleDeployment response = await ruleServiceClient.GetRuleDeploymentAsync(name);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
ListRetrohuntsRequest request = new ListRetrohuntsRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListRetrohuntsResponse, Retrohunt> response = ruleServiceClient.ListRetrohunts(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Retrohunt 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 (ListRetrohuntsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Retrohunt 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<Retrohunt> 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 (Retrohunt 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
PagedEnumerable<ListRetrohuntsResponse, Retrohunt> response = ruleServiceClient.ListRetrohunts(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Retrohunt 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 (ListRetrohuntsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Retrohunt 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<Retrohunt> 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 (Retrohunt 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
PagedEnumerable<ListRetrohuntsResponse, Retrohunt> response = ruleServiceClient.ListRetrohunts(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Retrohunt 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 (ListRetrohuntsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Retrohunt 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<Retrohunt> 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 (Retrohunt 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
ListRetrohuntsRequest request = new ListRetrohuntsRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListRetrohuntsResponse, Retrohunt> response = ruleServiceClient.ListRetrohuntsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Retrohunt 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((ListRetrohuntsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Retrohunt 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<Retrohunt> 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 (Retrohunt 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
PagedAsyncEnumerable<ListRetrohuntsResponse, Retrohunt> response = ruleServiceClient.ListRetrohuntsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Retrohunt 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((ListRetrohuntsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Retrohunt 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<Retrohunt> 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 (Retrohunt 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
PagedAsyncEnumerable<ListRetrohuntsResponse, Retrohunt> response = ruleServiceClient.ListRetrohuntsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Retrohunt 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((ListRetrohuntsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Retrohunt 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<Retrohunt> 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 (Retrohunt 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
ListRuleDeploymentsRequest request = new ListRuleDeploymentsRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Filter = "",
};
// Make the request
PagedEnumerable<ListRuleDeploymentsResponse, RuleDeployment> response = ruleServiceClient.ListRuleDeployments(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (RuleDeployment 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 (ListRuleDeploymentsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (RuleDeployment 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<RuleDeployment> 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 (RuleDeployment 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
PagedEnumerable<ListRuleDeploymentsResponse, RuleDeployment> response = ruleServiceClient.ListRuleDeployments(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (RuleDeployment 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 (ListRuleDeploymentsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (RuleDeployment 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<RuleDeployment> 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 (RuleDeployment 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
PagedEnumerable<ListRuleDeploymentsResponse, RuleDeployment> response = ruleServiceClient.ListRuleDeployments(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (RuleDeployment 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 (ListRuleDeploymentsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (RuleDeployment 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<RuleDeployment> 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 (RuleDeployment 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
ListRuleDeploymentsRequest request = new ListRuleDeploymentsRequest
{
    ParentAsRuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListRuleDeploymentsResponse, RuleDeployment> response = ruleServiceClient.ListRuleDeploymentsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((RuleDeployment 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((ListRuleDeploymentsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (RuleDeployment 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<RuleDeployment> 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 (RuleDeployment 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName parent = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
PagedAsyncEnumerable<ListRuleDeploymentsResponse, RuleDeployment> response = ruleServiceClient.ListRuleDeploymentsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((RuleDeployment 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((ListRuleDeploymentsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (RuleDeployment 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<RuleDeployment> 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 (RuleDeployment 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
PagedAsyncEnumerable<ListRuleDeploymentsResponse, RuleDeployment> response = ruleServiceClient.ListRuleDeploymentsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((RuleDeployment 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((ListRuleDeploymentsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (RuleDeployment 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<RuleDeployment> 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 (RuleDeployment 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
ListRuleRevisionsRequest request = new ListRuleRevisionsRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    View = RuleView.Unspecified,
};
// Make the request
PagedEnumerable<ListRuleRevisionsResponse, Rule> response = ruleServiceClient.ListRuleRevisions(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rule 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 (ListRuleRevisionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
PagedEnumerable<ListRuleRevisionsResponse, Rule> response = ruleServiceClient.ListRuleRevisions(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rule 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 (ListRuleRevisionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
PagedEnumerable<ListRuleRevisionsResponse, Rule> response = ruleServiceClient.ListRuleRevisions(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rule 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 (ListRuleRevisionsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
ListRuleRevisionsRequest request = new ListRuleRevisionsRequest
{
    RuleName = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]"),
    View = RuleView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListRuleRevisionsResponse, Rule> response = ruleServiceClient.ListRuleRevisionsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rule 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((ListRuleRevisionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleName name = RuleName.FromProjectLocationInstanceRule("[PROJECT]", "[LOCATION]", "[INSTANCE]", "[RULE]");
// Make the request
PagedAsyncEnumerable<ListRuleRevisionsResponse, Rule> response = ruleServiceClient.ListRuleRevisionsAsync(name);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rule 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((ListRuleRevisionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]/rules/[RULE]";
// Make the request
PagedAsyncEnumerable<ListRuleRevisionsResponse, Rule> response = ruleServiceClient.ListRuleRevisionsAsync(name);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rule 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((ListRuleRevisionsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
InstanceName parent = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
PagedEnumerable<ListRulesResponse, Rule> response = ruleServiceClient.ListRules(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rule 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 (ListRulesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
ListRulesRequest request = new ListRulesRequest
{
    ParentAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    View = RuleView.Unspecified,
    Filter = "",
};
// Make the request
PagedEnumerable<ListRulesResponse, Rule> response = ruleServiceClient.ListRules(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rule 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 (ListRulesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
PagedEnumerable<ListRulesResponse, Rule> response = ruleServiceClient.ListRules(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rule 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 (ListRulesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
InstanceName parent = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]");
// Make the request
PagedAsyncEnumerable<ListRulesResponse, Rule> response = ruleServiceClient.ListRulesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rule 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((ListRulesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
ListRulesRequest request = new ListRulesRequest
{
    ParentAsInstanceName = InstanceName.FromProjectLocationInstance("[PROJECT]", "[LOCATION]", "[INSTANCE]"),
    View = RuleView.Unspecified,
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListRulesResponse, Rule> response = ruleServiceClient.ListRulesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rule 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((ListRulesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/instances/[INSTANCE]";
// Make the request
PagedAsyncEnumerable<ListRulesResponse, Rule> response = ruleServiceClient.ListRulesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rule 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((ListRulesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rule 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<Rule> 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 (Rule 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
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
Rule rule = new Rule();
FieldMask updateMask = new FieldMask();
// Make the request
Rule response = ruleServiceClient.UpdateRule(rule, updateMask);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
UpdateRuleRequest request = new UpdateRuleRequest
{
    Rule = new Rule(),
    UpdateMask = new FieldMask(),
};
// Make the request
Rule response = ruleServiceClient.UpdateRule(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
Rule rule = new Rule();
FieldMask updateMask = new FieldMask();
// Make the request
Rule response = await ruleServiceClient.UpdateRuleAsync(rule, updateMask);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
Rule rule = new Rule();
FieldMask updateMask = new FieldMask();
// Make the request
Rule response = await ruleServiceClient.UpdateRuleAsync(rule, updateMask);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRuleRequest request = new UpdateRuleRequest
{
    Rule = new Rule(),
    UpdateMask = new FieldMask(),
};
// Make the request
Rule response = await ruleServiceClient.UpdateRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRuleRequest request = new UpdateRuleRequest
{
    Rule = new Rule(),
    UpdateMask = new FieldMask(),
};
// Make the request
Rule response = await ruleServiceClient.UpdateRuleAsync(request);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
RuleDeployment ruleDeployment = new RuleDeployment();
FieldMask updateMask = new FieldMask();
// Make the request
RuleDeployment response = ruleServiceClient.UpdateRuleDeployment(ruleDeployment, updateMask);

// Create client
RuleServiceClient ruleServiceClient = RuleServiceClient.Create();
// Initialize request argument(s)
UpdateRuleDeploymentRequest request = new UpdateRuleDeploymentRequest
{
    RuleDeployment = new RuleDeployment(),
    UpdateMask = new FieldMask(),
};
// Make the request
RuleDeployment response = ruleServiceClient.UpdateRuleDeployment(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleDeployment ruleDeployment = new RuleDeployment();
FieldMask updateMask = new FieldMask();
// Make the request
RuleDeployment response = await ruleServiceClient.UpdateRuleDeploymentAsync(ruleDeployment, updateMask);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
RuleDeployment ruleDeployment = new RuleDeployment();
FieldMask updateMask = new FieldMask();
// Make the request
RuleDeployment response = await ruleServiceClient.UpdateRuleDeploymentAsync(ruleDeployment, updateMask);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRuleDeploymentRequest request = new UpdateRuleDeploymentRequest
{
    RuleDeployment = new RuleDeployment(),
    UpdateMask = new FieldMask(),
};
// Make the request
RuleDeployment response = await ruleServiceClient.UpdateRuleDeploymentAsync(request);

// Create client
RuleServiceClient ruleServiceClient = await RuleServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRuleDeploymentRequest request = new UpdateRuleDeploymentRequest
{
    RuleDeployment = new RuleDeployment(),
    UpdateMask = new FieldMask(),
};
// Make the request
RuleDeployment response = await ruleServiceClient.UpdateRuleDeploymentAsync(request);