Cloud AI Platform v1beta1 API - Class ModelMonitoringServiceClient (1.0.0-beta08)

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ModelMonitor modelMonitor = new ModelMonitor();
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = modelMonitoringServiceClient.CreateModelMonitor(parent, modelMonitor);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
CreateModelMonitorRequest request = new CreateModelMonitorRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ModelMonitor = new ModelMonitor(),
    ModelMonitorId = "",
};
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = modelMonitoringServiceClient.CreateModelMonitor(request);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ModelMonitor modelMonitor = new ModelMonitor();
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = modelMonitoringServiceClient.CreateModelMonitor(parent, modelMonitor);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ModelMonitor modelMonitor = new ModelMonitor();
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.CreateModelMonitorAsync(parent, modelMonitor);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ModelMonitor modelMonitor = new ModelMonitor();
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.CreateModelMonitorAsync(parent, modelMonitor);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
CreateModelMonitorRequest request = new CreateModelMonitorRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ModelMonitor = new ModelMonitor(),
    ModelMonitorId = "",
};
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.CreateModelMonitorAsync(request);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
CreateModelMonitorRequest request = new CreateModelMonitorRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ModelMonitor = new ModelMonitor(),
    ModelMonitorId = "",
};
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.CreateModelMonitorAsync(request);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ModelMonitor modelMonitor = new ModelMonitor();
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.CreateModelMonitorAsync(parent, modelMonitor);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ModelMonitor modelMonitor = new ModelMonitor();
// Make the request
Operation<ModelMonitor, CreateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.CreateModelMonitorAsync(parent, modelMonitor);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
CreateModelMonitoringJobRequest request = new CreateModelMonitoringJobRequest
{
    ParentAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    ModelMonitoringJob = new ModelMonitoringJob(),
    ModelMonitoringJobId = "",
};
// Make the request
ModelMonitoringJob response = modelMonitoringServiceClient.CreateModelMonitoringJob(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitorName parent = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
ModelMonitoringJob modelMonitoringJob = new ModelMonitoringJob();
// Make the request
ModelMonitoringJob response = modelMonitoringServiceClient.CreateModelMonitoringJob(parent, modelMonitoringJob);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
ModelMonitoringJob modelMonitoringJob = new ModelMonitoringJob();
// Make the request
ModelMonitoringJob response = modelMonitoringServiceClient.CreateModelMonitoringJob(parent, modelMonitoringJob);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
CreateModelMonitoringJobRequest request = new CreateModelMonitoringJobRequest
{
    ParentAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    ModelMonitoringJob = new ModelMonitoringJob(),
    ModelMonitoringJobId = "",
};
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.CreateModelMonitoringJobAsync(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
CreateModelMonitoringJobRequest request = new CreateModelMonitoringJobRequest
{
    ParentAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    ModelMonitoringJob = new ModelMonitoringJob(),
    ModelMonitoringJobId = "",
};
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.CreateModelMonitoringJobAsync(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName parent = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
ModelMonitoringJob modelMonitoringJob = new ModelMonitoringJob();
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.CreateModelMonitoringJobAsync(parent, modelMonitoringJob);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName parent = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
ModelMonitoringJob modelMonitoringJob = new ModelMonitoringJob();
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.CreateModelMonitoringJobAsync(parent, modelMonitoringJob);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
ModelMonitoringJob modelMonitoringJob = new ModelMonitoringJob();
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.CreateModelMonitoringJobAsync(parent, modelMonitoringJob);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
ModelMonitoringJob modelMonitoringJob = new ModelMonitoringJob();
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.CreateModelMonitoringJobAsync(parent, modelMonitoringJob);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
DeleteModelMonitorRequest request = new DeleteModelMonitorRequest
{
    ModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = modelMonitoringServiceClient.DeleteModelMonitor(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = modelMonitoringServiceClient.PollOnceDeleteModelMonitor(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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitorName name = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = modelMonitoringServiceClient.DeleteModelMonitor(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = modelMonitoringServiceClient.PollOnceDeleteModelMonitor(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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = modelMonitoringServiceClient.DeleteModelMonitor(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = modelMonitoringServiceClient.PollOnceDeleteModelMonitor(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteModelMonitorRequest request = new DeleteModelMonitorRequest
{
    ModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitorAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitorAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteModelMonitorRequest request = new DeleteModelMonitorRequest
{
    ModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitorAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitorAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName name = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitorAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitorAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName name = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitorAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitorAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitorAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitorAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitorAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitorAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
DeleteModelMonitoringJobRequest request = new DeleteModelMonitoringJobRequest
{
    ModelMonitoringJobName = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = modelMonitoringServiceClient.DeleteModelMonitoringJob(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJob(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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitoringJobName name = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = modelMonitoringServiceClient.DeleteModelMonitoringJob(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJob(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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]/modelMonitoringJobs/[MODEL_MONITORING_JOB]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = modelMonitoringServiceClient.DeleteModelMonitoringJob(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJob(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteModelMonitoringJobRequest request = new DeleteModelMonitoringJobRequest
{
    ModelMonitoringJobName = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitoringJobAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJobAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteModelMonitoringJobRequest request = new DeleteModelMonitoringJobRequest
{
    ModelMonitoringJobName = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitoringJobAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJobAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitoringJobName name = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitoringJobAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJobAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitoringJobName name = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitoringJobAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJobAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]/modelMonitoringJobs/[MODEL_MONITORING_JOB]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitoringJobAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJobAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]/modelMonitoringJobs/[MODEL_MONITORING_JOB]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await modelMonitoringServiceClient.DeleteModelMonitoringJobAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, DeleteOperationMetadata> retrievedResponse = await modelMonitoringServiceClient.PollOnceDeleteModelMonitoringJobAsync(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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
GetModelMonitorRequest request = new GetModelMonitorRequest
{
    ModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
};
// Make the request
ModelMonitor response = modelMonitoringServiceClient.GetModelMonitor(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitorName name = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
ModelMonitor response = modelMonitoringServiceClient.GetModelMonitor(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
ModelMonitor response = modelMonitoringServiceClient.GetModelMonitor(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
GetModelMonitorRequest request = new GetModelMonitorRequest
{
    ModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
};
// Make the request
ModelMonitor response = await modelMonitoringServiceClient.GetModelMonitorAsync(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
GetModelMonitorRequest request = new GetModelMonitorRequest
{
    ModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
};
// Make the request
ModelMonitor response = await modelMonitoringServiceClient.GetModelMonitorAsync(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName name = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
ModelMonitor response = await modelMonitoringServiceClient.GetModelMonitorAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName name = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
ModelMonitor response = await modelMonitoringServiceClient.GetModelMonitorAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
ModelMonitor response = await modelMonitoringServiceClient.GetModelMonitorAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
ModelMonitor response = await modelMonitoringServiceClient.GetModelMonitorAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
GetModelMonitoringJobRequest request = new GetModelMonitoringJobRequest
{
    ModelMonitoringJobName = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]"),
};
// Make the request
ModelMonitoringJob response = modelMonitoringServiceClient.GetModelMonitoringJob(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitoringJobName name = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]");
// Make the request
ModelMonitoringJob response = modelMonitoringServiceClient.GetModelMonitoringJob(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]/modelMonitoringJobs/[MODEL_MONITORING_JOB]";
// Make the request
ModelMonitoringJob response = modelMonitoringServiceClient.GetModelMonitoringJob(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
GetModelMonitoringJobRequest request = new GetModelMonitoringJobRequest
{
    ModelMonitoringJobName = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]"),
};
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.GetModelMonitoringJobAsync(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
GetModelMonitoringJobRequest request = new GetModelMonitoringJobRequest
{
    ModelMonitoringJobName = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]"),
};
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.GetModelMonitoringJobAsync(request);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitoringJobName name = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]");
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.GetModelMonitoringJobAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitoringJobName name = ModelMonitoringJobName.FromProjectLocationModelMonitorModelMonitoringJob("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]", "[MODEL_MONITORING_JOB]");
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.GetModelMonitoringJobAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]/modelMonitoringJobs/[MODEL_MONITORING_JOB]";
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.GetModelMonitoringJobAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]/modelMonitoringJobs/[MODEL_MONITORING_JOB]";
// Make the request
ModelMonitoringJob response = await modelMonitoringServiceClient.GetModelMonitoringJobAsync(name);

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ListModelMonitoringJobsRequest request = new ListModelMonitoringJobsRequest
{
    ParentAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    Filter = "",
    ReadMask = new FieldMask(),
};
// Make the request
PagedEnumerable<ListModelMonitoringJobsResponse, ModelMonitoringJob> response = modelMonitoringServiceClient.ListModelMonitoringJobs(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringJob 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 (ListModelMonitoringJobsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringJob 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<ModelMonitoringJob> 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 (ModelMonitoringJob 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitorName parent = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
PagedEnumerable<ListModelMonitoringJobsResponse, ModelMonitoringJob> response = modelMonitoringServiceClient.ListModelMonitoringJobs(parent);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringJob 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 (ListModelMonitoringJobsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringJob 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<ModelMonitoringJob> 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 (ModelMonitoringJob 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ListModelMonitoringJobsRequest request = new ListModelMonitoringJobsRequest
{
    ParentAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    Filter = "",
    ReadMask = new FieldMask(),
};
// Make the request
PagedAsyncEnumerable<ListModelMonitoringJobsResponse, ModelMonitoringJob> response = modelMonitoringServiceClient.ListModelMonitoringJobsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringJob 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((ListModelMonitoringJobsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringJob 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<ModelMonitoringJob> 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 (ModelMonitoringJob 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName parent = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
PagedAsyncEnumerable<ListModelMonitoringJobsResponse, ModelMonitoringJob> response = modelMonitoringServiceClient.ListModelMonitoringJobsAsync(parent);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringJob 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((ListModelMonitoringJobsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringJob 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<ModelMonitoringJob> 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 (ModelMonitoringJob 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListModelMonitorsResponse, ModelMonitor> response = modelMonitoringServiceClient.ListModelMonitors(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitor 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 (ListModelMonitorsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitor 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<ModelMonitor> 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 (ModelMonitor 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ListModelMonitorsRequest request = new ListModelMonitorsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    ReadMask = new FieldMask(),
};
// Make the request
PagedEnumerable<ListModelMonitorsResponse, ModelMonitor> response = modelMonitoringServiceClient.ListModelMonitors(request);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitor 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 (ListModelMonitorsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitor 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<ModelMonitor> 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 (ModelMonitor 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListModelMonitorsResponse, ModelMonitor> response = modelMonitoringServiceClient.ListModelMonitorsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitor 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((ListModelMonitorsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitor 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<ModelMonitor> 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 (ModelMonitor 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ListModelMonitorsRequest request = new ListModelMonitorsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    ReadMask = new FieldMask(),
};
// Make the request
PagedAsyncEnumerable<ListModelMonitorsResponse, ModelMonitor> response = modelMonitoringServiceClient.ListModelMonitorsAsync(request);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitor 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((ListModelMonitorsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitor 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<ModelMonitor> 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 (ModelMonitor 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitorName modelMonitor = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
PagedEnumerable<SearchModelMonitoringAlertsResponse, ModelMonitoringAlert> response = modelMonitoringServiceClient.SearchModelMonitoringAlerts(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringAlert 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 (SearchModelMonitoringAlertsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringAlert 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<ModelMonitoringAlert> 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 (ModelMonitoringAlert 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
SearchModelMonitoringAlertsRequest request = new SearchModelMonitoringAlertsRequest
{
    ModelMonitorAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    ModelMonitoringJob = "",
    AlertTimeInterval = new Interval(),
    StatsName = "",
    ObjectiveType = "",
};
// Make the request
PagedEnumerable<SearchModelMonitoringAlertsResponse, ModelMonitoringAlert> response = modelMonitoringServiceClient.SearchModelMonitoringAlerts(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringAlert 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 (SearchModelMonitoringAlertsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringAlert 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<ModelMonitoringAlert> 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 (ModelMonitoringAlert 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string modelMonitor = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
PagedEnumerable<SearchModelMonitoringAlertsResponse, ModelMonitoringAlert> response = modelMonitoringServiceClient.SearchModelMonitoringAlerts(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringAlert 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 (SearchModelMonitoringAlertsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringAlert 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<ModelMonitoringAlert> 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 (ModelMonitoringAlert 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName modelMonitor = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
PagedAsyncEnumerable<SearchModelMonitoringAlertsResponse, ModelMonitoringAlert> response = modelMonitoringServiceClient.SearchModelMonitoringAlertsAsync(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringAlert 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((SearchModelMonitoringAlertsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringAlert 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<ModelMonitoringAlert> 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 (ModelMonitoringAlert 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
SearchModelMonitoringAlertsRequest request = new SearchModelMonitoringAlertsRequest
{
    ModelMonitorAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    ModelMonitoringJob = "",
    AlertTimeInterval = new Interval(),
    StatsName = "",
    ObjectiveType = "",
};
// Make the request
PagedAsyncEnumerable<SearchModelMonitoringAlertsResponse, ModelMonitoringAlert> response = modelMonitoringServiceClient.SearchModelMonitoringAlertsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringAlert 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((SearchModelMonitoringAlertsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringAlert 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<ModelMonitoringAlert> 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 (ModelMonitoringAlert 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string modelMonitor = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
PagedAsyncEnumerable<SearchModelMonitoringAlertsResponse, ModelMonitoringAlert> response = modelMonitoringServiceClient.SearchModelMonitoringAlertsAsync(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringAlert 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((SearchModelMonitoringAlertsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringAlert 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<ModelMonitoringAlert> 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 (ModelMonitoringAlert 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitorName modelMonitor = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
PagedEnumerable<SearchModelMonitoringStatsResponse, ModelMonitoringStats> response = modelMonitoringServiceClient.SearchModelMonitoringStats(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringStats 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 (SearchModelMonitoringStatsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringStats 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<ModelMonitoringStats> 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 (ModelMonitoringStats 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
SearchModelMonitoringStatsRequest request = new SearchModelMonitoringStatsRequest
{
    ModelMonitorAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    StatsFilter = new SearchModelMonitoringStatsFilter(),
    TimeInterval = new Interval(),
};
// Make the request
PagedEnumerable<SearchModelMonitoringStatsResponse, ModelMonitoringStats> response = modelMonitoringServiceClient.SearchModelMonitoringStats(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringStats 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 (SearchModelMonitoringStatsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringStats 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<ModelMonitoringStats> 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 (ModelMonitoringStats 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
string modelMonitor = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
PagedEnumerable<SearchModelMonitoringStatsResponse, ModelMonitoringStats> response = modelMonitoringServiceClient.SearchModelMonitoringStats(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
foreach (ModelMonitoringStats 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 (SearchModelMonitoringStatsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringStats 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<ModelMonitoringStats> 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 (ModelMonitoringStats 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitorName modelMonitor = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]");
// Make the request
PagedAsyncEnumerable<SearchModelMonitoringStatsResponse, ModelMonitoringStats> response = modelMonitoringServiceClient.SearchModelMonitoringStatsAsync(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringStats 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((SearchModelMonitoringStatsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringStats 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<ModelMonitoringStats> 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 (ModelMonitoringStats 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
SearchModelMonitoringStatsRequest request = new SearchModelMonitoringStatsRequest
{
    ModelMonitorAsModelMonitorName = ModelMonitorName.FromProjectLocationModelMonitor("[PROJECT]", "[LOCATION]", "[MODEL_MONITOR]"),
    StatsFilter = new SearchModelMonitoringStatsFilter(),
    TimeInterval = new Interval(),
};
// Make the request
PagedAsyncEnumerable<SearchModelMonitoringStatsResponse, ModelMonitoringStats> response = modelMonitoringServiceClient.SearchModelMonitoringStatsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringStats 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((SearchModelMonitoringStatsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringStats 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<ModelMonitoringStats> 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 (ModelMonitoringStats 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
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
string modelMonitor = "projects/[PROJECT]/locations/[LOCATION]/modelMonitors/[MODEL_MONITOR]";
// Make the request
PagedAsyncEnumerable<SearchModelMonitoringStatsResponse, ModelMonitoringStats> response = modelMonitoringServiceClient.SearchModelMonitoringStatsAsync(modelMonitor);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ModelMonitoringStats 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((SearchModelMonitoringStatsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ModelMonitoringStats 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<ModelMonitoringStats> 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 (ModelMonitoringStats 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
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
ModelMonitor modelMonitor = new ModelMonitor();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ModelMonitor, UpdateModelMonitorOperationMetadata> response = modelMonitoringServiceClient.UpdateModelMonitor(modelMonitor, updateMask);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = ModelMonitoringServiceClient.Create();
// Initialize request argument(s)
UpdateModelMonitorRequest request = new UpdateModelMonitorRequest
{
    ModelMonitor = new ModelMonitor(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<ModelMonitor, UpdateModelMonitorOperationMetadata> response = modelMonitoringServiceClient.UpdateModelMonitor(request);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitor modelMonitor = new ModelMonitor();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ModelMonitor, UpdateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.UpdateModelMonitorAsync(modelMonitor, updateMask);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
ModelMonitor modelMonitor = new ModelMonitor();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<ModelMonitor, UpdateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.UpdateModelMonitorAsync(modelMonitor, updateMask);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateModelMonitorRequest request = new UpdateModelMonitorRequest
{
    ModelMonitor = new ModelMonitor(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<ModelMonitor, UpdateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.UpdateModelMonitorAsync(request);

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

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

// Create client
ModelMonitoringServiceClient modelMonitoringServiceClient = await ModelMonitoringServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateModelMonitorRequest request = new UpdateModelMonitorRequest
{
    ModelMonitor = new ModelMonitor(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<ModelMonitor, UpdateModelMonitorOperationMetadata> response = await modelMonitoringServiceClient.UpdateModelMonitorAsync(request);

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

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