Cloud AI Platform v1beta1 API - Class NotebookServiceClient (1.0.0-beta02)

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookRuntimeTemplateName notebookRuntimeTemplate = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
NotebookRuntime notebookRuntime = new NotebookRuntime();
string notebookRuntimeId = "";
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = notebookServiceClient.AssignNotebookRuntime(parent, notebookRuntimeTemplate, notebookRuntime, notebookRuntimeId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceAssignNotebookRuntime(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
AssignNotebookRuntimeRequest request = new AssignNotebookRuntimeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookRuntimeTemplateAsNotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
    NotebookRuntime = new NotebookRuntime(),
    NotebookRuntimeId = "",
};
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = notebookServiceClient.AssignNotebookRuntime(request);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceAssignNotebookRuntime(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string notebookRuntimeTemplate = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
NotebookRuntime notebookRuntime = new NotebookRuntime();
string notebookRuntimeId = "";
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = notebookServiceClient.AssignNotebookRuntime(parent, notebookRuntimeTemplate, notebookRuntime, notebookRuntimeId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceAssignNotebookRuntime(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookRuntimeTemplateName notebookRuntimeTemplate = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
NotebookRuntime notebookRuntime = new NotebookRuntime();
string notebookRuntimeId = "";
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = await notebookServiceClient.AssignNotebookRuntimeAsync(parent, notebookRuntimeTemplate, notebookRuntime, notebookRuntimeId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceAssignNotebookRuntimeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookRuntimeTemplateName notebookRuntimeTemplate = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
NotebookRuntime notebookRuntime = new NotebookRuntime();
string notebookRuntimeId = "";
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = await notebookServiceClient.AssignNotebookRuntimeAsync(parent, notebookRuntimeTemplate, notebookRuntime, notebookRuntimeId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceAssignNotebookRuntimeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
AssignNotebookRuntimeRequest request = new AssignNotebookRuntimeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookRuntimeTemplateAsNotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
    NotebookRuntime = new NotebookRuntime(),
    NotebookRuntimeId = "",
};
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = await notebookServiceClient.AssignNotebookRuntimeAsync(request);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceAssignNotebookRuntimeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
AssignNotebookRuntimeRequest request = new AssignNotebookRuntimeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookRuntimeTemplateAsNotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
    NotebookRuntime = new NotebookRuntime(),
    NotebookRuntimeId = "",
};
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = await notebookServiceClient.AssignNotebookRuntimeAsync(request);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceAssignNotebookRuntimeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string notebookRuntimeTemplate = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
NotebookRuntime notebookRuntime = new NotebookRuntime();
string notebookRuntimeId = "";
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = await notebookServiceClient.AssignNotebookRuntimeAsync(parent, notebookRuntimeTemplate, notebookRuntime, notebookRuntimeId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceAssignNotebookRuntimeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string notebookRuntimeTemplate = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
NotebookRuntime notebookRuntime = new NotebookRuntime();
string notebookRuntimeId = "";
// Make the request
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> response = await notebookServiceClient.AssignNotebookRuntimeAsync(parent, notebookRuntimeTemplate, notebookRuntime, notebookRuntimeId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntime 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<NotebookRuntime, AssignNotebookRuntimeOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceAssignNotebookRuntimeAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntime retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookExecutionJob notebookExecutionJob = new NotebookExecutionJob();
string notebookExecutionJobId = "";
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = notebookServiceClient.CreateNotebookExecutionJob(parent, notebookExecutionJob, notebookExecutionJobId);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceCreateNotebookExecutionJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
CreateNotebookExecutionJobRequest request = new CreateNotebookExecutionJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookExecutionJob = new NotebookExecutionJob(),
    NotebookExecutionJobId = "",
};
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = notebookServiceClient.CreateNotebookExecutionJob(request);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceCreateNotebookExecutionJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
NotebookExecutionJob notebookExecutionJob = new NotebookExecutionJob();
string notebookExecutionJobId = "";
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = notebookServiceClient.CreateNotebookExecutionJob(parent, notebookExecutionJob, notebookExecutionJobId);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceCreateNotebookExecutionJob(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookExecutionJob notebookExecutionJob = new NotebookExecutionJob();
string notebookExecutionJobId = "";
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = await notebookServiceClient.CreateNotebookExecutionJobAsync(parent, notebookExecutionJob, notebookExecutionJobId);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookExecutionJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookExecutionJob notebookExecutionJob = new NotebookExecutionJob();
string notebookExecutionJobId = "";
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = await notebookServiceClient.CreateNotebookExecutionJobAsync(parent, notebookExecutionJob, notebookExecutionJobId);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookExecutionJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
CreateNotebookExecutionJobRequest request = new CreateNotebookExecutionJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookExecutionJob = new NotebookExecutionJob(),
    NotebookExecutionJobId = "",
};
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = await notebookServiceClient.CreateNotebookExecutionJobAsync(request);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookExecutionJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
CreateNotebookExecutionJobRequest request = new CreateNotebookExecutionJobRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookExecutionJob = new NotebookExecutionJob(),
    NotebookExecutionJobId = "",
};
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = await notebookServiceClient.CreateNotebookExecutionJobAsync(request);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookExecutionJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
NotebookExecutionJob notebookExecutionJob = new NotebookExecutionJob();
string notebookExecutionJobId = "";
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = await notebookServiceClient.CreateNotebookExecutionJobAsync(parent, notebookExecutionJob, notebookExecutionJobId);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookExecutionJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
NotebookExecutionJob notebookExecutionJob = new NotebookExecutionJob();
string notebookExecutionJobId = "";
// Make the request
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> response = await notebookServiceClient.CreateNotebookExecutionJobAsync(parent, notebookExecutionJob, notebookExecutionJobId);

// Poll until the returned long-running operation is complete
Operation<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookExecutionJob 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<NotebookExecutionJob, CreateNotebookExecutionJobOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookExecutionJobAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookExecutionJob retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookRuntimeTemplate notebookRuntimeTemplate = new NotebookRuntimeTemplate();
string notebookRuntimeTemplateId = "";
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = notebookServiceClient.CreateNotebookRuntimeTemplate(parent, notebookRuntimeTemplate, notebookRuntimeTemplateId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceCreateNotebookRuntimeTemplate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
CreateNotebookRuntimeTemplateRequest request = new CreateNotebookRuntimeTemplateRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookRuntimeTemplate = new NotebookRuntimeTemplate(),
    NotebookRuntimeTemplateId = "",
};
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = notebookServiceClient.CreateNotebookRuntimeTemplate(request);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceCreateNotebookRuntimeTemplate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
NotebookRuntimeTemplate notebookRuntimeTemplate = new NotebookRuntimeTemplate();
string notebookRuntimeTemplateId = "";
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = notebookServiceClient.CreateNotebookRuntimeTemplate(parent, notebookRuntimeTemplate, notebookRuntimeTemplateId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = notebookServiceClient.PollOnceCreateNotebookRuntimeTemplate(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookRuntimeTemplate notebookRuntimeTemplate = new NotebookRuntimeTemplate();
string notebookRuntimeTemplateId = "";
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = await notebookServiceClient.CreateNotebookRuntimeTemplateAsync(parent, notebookRuntimeTemplate, notebookRuntimeTemplateId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookRuntimeTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
NotebookRuntimeTemplate notebookRuntimeTemplate = new NotebookRuntimeTemplate();
string notebookRuntimeTemplateId = "";
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = await notebookServiceClient.CreateNotebookRuntimeTemplateAsync(parent, notebookRuntimeTemplate, notebookRuntimeTemplateId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookRuntimeTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
CreateNotebookRuntimeTemplateRequest request = new CreateNotebookRuntimeTemplateRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookRuntimeTemplate = new NotebookRuntimeTemplate(),
    NotebookRuntimeTemplateId = "",
};
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = await notebookServiceClient.CreateNotebookRuntimeTemplateAsync(request);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookRuntimeTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
CreateNotebookRuntimeTemplateRequest request = new CreateNotebookRuntimeTemplateRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    NotebookRuntimeTemplate = new NotebookRuntimeTemplate(),
    NotebookRuntimeTemplateId = "",
};
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = await notebookServiceClient.CreateNotebookRuntimeTemplateAsync(request);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookRuntimeTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
NotebookRuntimeTemplate notebookRuntimeTemplate = new NotebookRuntimeTemplate();
string notebookRuntimeTemplateId = "";
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = await notebookServiceClient.CreateNotebookRuntimeTemplateAsync(parent, notebookRuntimeTemplate, notebookRuntimeTemplateId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookRuntimeTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
NotebookRuntimeTemplate notebookRuntimeTemplate = new NotebookRuntimeTemplate();
string notebookRuntimeTemplateId = "";
// Make the request
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> response = await notebookServiceClient.CreateNotebookRuntimeTemplateAsync(parent, notebookRuntimeTemplate, notebookRuntimeTemplateId);

// Poll until the returned long-running operation is complete
Operation<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
NotebookRuntimeTemplate 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<NotebookRuntimeTemplate, CreateNotebookRuntimeTemplateOperationMetadata> retrievedResponse = await notebookServiceClient.PollOnceCreateNotebookRuntimeTemplateAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    NotebookRuntimeTemplate retrievedResult = retrievedResponse.Result;
}

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
DeleteNotebookExecutionJobRequest request = new DeleteNotebookExecutionJobRequest
{
    NotebookExecutionJobName = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookExecutionJob(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 = notebookServiceClient.PollOnceDeleteNotebookExecutionJob(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
NotebookExecutionJobName name = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookExecutionJob(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 = notebookServiceClient.PollOnceDeleteNotebookExecutionJob(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookExecutionJobs/[NOTEBOOK_EXECUTION_JOB]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookExecutionJob(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 = notebookServiceClient.PollOnceDeleteNotebookExecutionJob(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteNotebookExecutionJobRequest request = new DeleteNotebookExecutionJobRequest
{
    NotebookExecutionJobName = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookExecutionJobAsync(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 notebookServiceClient.PollOnceDeleteNotebookExecutionJobAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteNotebookExecutionJobRequest request = new DeleteNotebookExecutionJobRequest
{
    NotebookExecutionJobName = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookExecutionJobAsync(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 notebookServiceClient.PollOnceDeleteNotebookExecutionJobAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookExecutionJobName name = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookExecutionJobAsync(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 notebookServiceClient.PollOnceDeleteNotebookExecutionJobAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookExecutionJobName name = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookExecutionJobAsync(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 notebookServiceClient.PollOnceDeleteNotebookExecutionJobAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookExecutionJobs/[NOTEBOOK_EXECUTION_JOB]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookExecutionJobAsync(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 notebookServiceClient.PollOnceDeleteNotebookExecutionJobAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookExecutionJobs/[NOTEBOOK_EXECUTION_JOB]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookExecutionJobAsync(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 notebookServiceClient.PollOnceDeleteNotebookExecutionJobAsync(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
DeleteNotebookRuntimeRequest request = new DeleteNotebookRuntimeRequest
{
    NotebookRuntimeName = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookRuntime(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 = notebookServiceClient.PollOnceDeleteNotebookRuntime(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
NotebookRuntimeName name = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookRuntime(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 = notebookServiceClient.PollOnceDeleteNotebookRuntime(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimes/[NOTEBOOK_RUNTIME]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookRuntime(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 = notebookServiceClient.PollOnceDeleteNotebookRuntime(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteNotebookRuntimeRequest request = new DeleteNotebookRuntimeRequest
{
    NotebookRuntimeName = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteNotebookRuntimeRequest request = new DeleteNotebookRuntimeRequest
{
    NotebookRuntimeName = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeName name = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeName name = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimes/[NOTEBOOK_RUNTIME]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimes/[NOTEBOOK_RUNTIME]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeAsync(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
DeleteNotebookRuntimeTemplateRequest request = new DeleteNotebookRuntimeTemplateRequest
{
    NotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookRuntimeTemplate(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 = notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplate(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
NotebookRuntimeTemplateName name = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookRuntimeTemplate(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 = notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplate(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = notebookServiceClient.DeleteNotebookRuntimeTemplate(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 = notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplate(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteNotebookRuntimeTemplateRequest request = new DeleteNotebookRuntimeTemplateRequest
{
    NotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeTemplateAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplateAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteNotebookRuntimeTemplateRequest request = new DeleteNotebookRuntimeTemplateRequest
{
    NotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeTemplateAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplateAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeTemplateName name = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeTemplateAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplateAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeTemplateName name = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeTemplateAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplateAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeTemplateAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplateAsync(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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await notebookServiceClient.DeleteNotebookRuntimeTemplateAsync(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 notebookServiceClient.PollOnceDeleteNotebookRuntimeTemplateAsync(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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
GetNotebookExecutionJobRequest request = new GetNotebookExecutionJobRequest
{
    NotebookExecutionJobName = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]"),
    View = NotebookExecutionJobView.Unspecified,
};
// Make the request
NotebookExecutionJob response = notebookServiceClient.GetNotebookExecutionJob(request);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
NotebookExecutionJobName name = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]");
// Make the request
NotebookExecutionJob response = notebookServiceClient.GetNotebookExecutionJob(name);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookExecutionJobs/[NOTEBOOK_EXECUTION_JOB]";
// Make the request
NotebookExecutionJob response = notebookServiceClient.GetNotebookExecutionJob(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetNotebookExecutionJobRequest request = new GetNotebookExecutionJobRequest
{
    NotebookExecutionJobName = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]"),
    View = NotebookExecutionJobView.Unspecified,
};
// Make the request
NotebookExecutionJob response = await notebookServiceClient.GetNotebookExecutionJobAsync(request);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetNotebookExecutionJobRequest request = new GetNotebookExecutionJobRequest
{
    NotebookExecutionJobName = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]"),
    View = NotebookExecutionJobView.Unspecified,
};
// Make the request
NotebookExecutionJob response = await notebookServiceClient.GetNotebookExecutionJobAsync(request);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookExecutionJobName name = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]");
// Make the request
NotebookExecutionJob response = await notebookServiceClient.GetNotebookExecutionJobAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookExecutionJobName name = NotebookExecutionJobName.FromProjectLocationNotebookExecutionJob("[PROJECT]", "[LOCATION]", "[NOTEBOOK_EXECUTION_JOB]");
// Make the request
NotebookExecutionJob response = await notebookServiceClient.GetNotebookExecutionJobAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookExecutionJobs/[NOTEBOOK_EXECUTION_JOB]";
// Make the request
NotebookExecutionJob response = await notebookServiceClient.GetNotebookExecutionJobAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookExecutionJobs/[NOTEBOOK_EXECUTION_JOB]";
// Make the request
NotebookExecutionJob response = await notebookServiceClient.GetNotebookExecutionJobAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
GetNotebookRuntimeRequest request = new GetNotebookRuntimeRequest
{
    NotebookRuntimeName = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]"),
};
// Make the request
NotebookRuntime response = notebookServiceClient.GetNotebookRuntime(request);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
NotebookRuntimeName name = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]");
// Make the request
NotebookRuntime response = notebookServiceClient.GetNotebookRuntime(name);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimes/[NOTEBOOK_RUNTIME]";
// Make the request
NotebookRuntime response = notebookServiceClient.GetNotebookRuntime(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetNotebookRuntimeRequest request = new GetNotebookRuntimeRequest
{
    NotebookRuntimeName = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]"),
};
// Make the request
NotebookRuntime response = await notebookServiceClient.GetNotebookRuntimeAsync(request);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetNotebookRuntimeRequest request = new GetNotebookRuntimeRequest
{
    NotebookRuntimeName = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]"),
};
// Make the request
NotebookRuntime response = await notebookServiceClient.GetNotebookRuntimeAsync(request);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeName name = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]");
// Make the request
NotebookRuntime response = await notebookServiceClient.GetNotebookRuntimeAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeName name = NotebookRuntimeName.FromProjectLocationNotebookRuntime("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME]");
// Make the request
NotebookRuntime response = await notebookServiceClient.GetNotebookRuntimeAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimes/[NOTEBOOK_RUNTIME]";
// Make the request
NotebookRuntime response = await notebookServiceClient.GetNotebookRuntimeAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimes/[NOTEBOOK_RUNTIME]";
// Make the request
NotebookRuntime response = await notebookServiceClient.GetNotebookRuntimeAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
GetNotebookRuntimeTemplateRequest request = new GetNotebookRuntimeTemplateRequest
{
    NotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
};
// Make the request
NotebookRuntimeTemplate response = notebookServiceClient.GetNotebookRuntimeTemplate(request);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
NotebookRuntimeTemplateName name = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
// Make the request
NotebookRuntimeTemplate response = notebookServiceClient.GetNotebookRuntimeTemplate(name);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
// Make the request
NotebookRuntimeTemplate response = notebookServiceClient.GetNotebookRuntimeTemplate(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetNotebookRuntimeTemplateRequest request = new GetNotebookRuntimeTemplateRequest
{
    NotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
};
// Make the request
NotebookRuntimeTemplate response = await notebookServiceClient.GetNotebookRuntimeTemplateAsync(request);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetNotebookRuntimeTemplateRequest request = new GetNotebookRuntimeTemplateRequest
{
    NotebookRuntimeTemplateName = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]"),
};
// Make the request
NotebookRuntimeTemplate response = await notebookServiceClient.GetNotebookRuntimeTemplateAsync(request);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeTemplateName name = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
// Make the request
NotebookRuntimeTemplate response = await notebookServiceClient.GetNotebookRuntimeTemplateAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
NotebookRuntimeTemplateName name = NotebookRuntimeTemplateName.FromProjectLocationNotebookRuntimeTemplate("[PROJECT]", "[LOCATION]", "[NOTEBOOK_RUNTIME_TEMPLATE]");
// Make the request
NotebookRuntimeTemplate response = await notebookServiceClient.GetNotebookRuntimeTemplateAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
// Make the request
NotebookRuntimeTemplate response = await notebookServiceClient.GetNotebookRuntimeTemplateAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/notebookRuntimeTemplates/[NOTEBOOK_RUNTIME_TEMPLATE]";
// Make the request
NotebookRuntimeTemplate response = await notebookServiceClient.GetNotebookRuntimeTemplateAsync(name);

// Create client
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListNotebookExecutionJobsResponse, NotebookExecutionJob> response = notebookServiceClient.ListNotebookExecutionJobs(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (NotebookExecutionJob 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 (ListNotebookExecutionJobsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (NotebookExecutionJob 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<NotebookExecutionJob> 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 (NotebookExecutionJob 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
NotebookServiceClient notebookServiceClient = NotebookServiceClient.Create();
// Initialize request argument(s)
ListNotebookExecutionJobsRequest request = new ListNotebookExecutionJobsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
    View = NotebookExecutionJobView.Unspecified,
};
// Make the request
PagedEnumerable<ListNotebookExecutionJobsResponse, NotebookExecutionJob> response = notebookServiceClient.ListNotebookExecutionJobs(request);

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((NotebookExecutionJob 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((ListNotebookExecutionJobsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (NotebookExecutionJob 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<NotebookExecutionJob> 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 (NotebookExecutionJob 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
NotebookServiceClient notebookServiceClient = await NotebookServiceClient.CreateAsync();
// Initialize request argument(s)
ListNotebookExecutionJobsRequest request = new ListNotebookExecutionJobsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
    View = NotebookExecutionJobView.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListNotebookExecutionJobsResponse, NotebookExecutionJob> response = notebookServiceClient.ListNotebookExecutionJobsAsync(request);

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

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

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

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

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

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

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

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

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

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

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

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((NotebookRuntime 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((ListNotebookRuntimesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (NotebookRuntime 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<NotebookRuntime> 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 (NotebookRuntime 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;