AI Platform Notebooks v1 API - Class ManagedNotebookServiceClient (2.2.0)

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
CreateRuntimeRequest request = new CreateRuntimeRequest
{
    ParentAsRuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    RuntimeId = "",
    Runtime = new Runtime(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.CreateRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RuntimeName parent = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
string runtimeId = "";
Runtime runtime = new Runtime();
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.CreateRuntime(parent, runtimeId, runtime);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
string runtimeId = "";
Runtime runtime = new Runtime();
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.CreateRuntime(parent, runtimeId, runtime);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRuntimeRequest request = new CreateRuntimeRequest
{
    ParentAsRuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    RuntimeId = "",
    Runtime = new Runtime(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.CreateRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
CreateRuntimeRequest request = new CreateRuntimeRequest
{
    ParentAsRuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    RuntimeId = "",
    Runtime = new Runtime(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.CreateRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName parent = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
string runtimeId = "";
Runtime runtime = new Runtime();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.CreateRuntimeAsync(parent, runtimeId, runtime);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName parent = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
string runtimeId = "";
Runtime runtime = new Runtime();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.CreateRuntimeAsync(parent, runtimeId, runtime);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
string runtimeId = "";
Runtime runtime = new Runtime();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.CreateRuntimeAsync(parent, runtimeId, runtime);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
string runtimeId = "";
Runtime runtime = new Runtime();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.CreateRuntimeAsync(parent, runtimeId, runtime);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
DeleteRuntimeRequest request = new DeleteRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = managedNotebookServiceClient.DeleteRuntime(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = managedNotebookServiceClient.PollOnceDeleteRuntime(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
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Operation<Empty, OperationMetadata> response = managedNotebookServiceClient.DeleteRuntime(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = managedNotebookServiceClient.PollOnceDeleteRuntime(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
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Operation<Empty, OperationMetadata> response = managedNotebookServiceClient.DeleteRuntime(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = managedNotebookServiceClient.PollOnceDeleteRuntime(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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRuntimeRequest request = new DeleteRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await managedNotebookServiceClient.DeleteRuntimeAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await managedNotebookServiceClient.PollOnceDeleteRuntimeAsync(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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteRuntimeRequest request = new DeleteRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await managedNotebookServiceClient.DeleteRuntimeAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await managedNotebookServiceClient.PollOnceDeleteRuntimeAsync(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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Operation<Empty, OperationMetadata> response = await managedNotebookServiceClient.DeleteRuntimeAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await managedNotebookServiceClient.PollOnceDeleteRuntimeAsync(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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Operation<Empty, OperationMetadata> response = await managedNotebookServiceClient.DeleteRuntimeAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await managedNotebookServiceClient.PollOnceDeleteRuntimeAsync(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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Operation<Empty, OperationMetadata> response = await managedNotebookServiceClient.DeleteRuntimeAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await managedNotebookServiceClient.PollOnceDeleteRuntimeAsync(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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Operation<Empty, OperationMetadata> response = await managedNotebookServiceClient.DeleteRuntimeAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await managedNotebookServiceClient.PollOnceDeleteRuntimeAsync(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
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
DiagnoseRuntimeRequest request = new DiagnoseRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    DiagnosticConfig = new DiagnosticConfig(),
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.DiagnoseRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
DiagnosticConfig diagnosticConfig = new DiagnosticConfig();
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.DiagnoseRuntime(name, diagnosticConfig);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
DiagnosticConfig diagnosticConfig = new DiagnosticConfig();
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.DiagnoseRuntime(name, diagnosticConfig);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DiagnoseRuntimeRequest request = new DiagnoseRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    DiagnosticConfig = new DiagnosticConfig(),
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.DiagnoseRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
DiagnoseRuntimeRequest request = new DiagnoseRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    DiagnosticConfig = new DiagnosticConfig(),
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.DiagnoseRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
DiagnosticConfig diagnosticConfig = new DiagnosticConfig();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.DiagnoseRuntimeAsync(name, diagnosticConfig);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
DiagnosticConfig diagnosticConfig = new DiagnosticConfig();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.DiagnoseRuntimeAsync(name, diagnosticConfig);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
DiagnosticConfig diagnosticConfig = new DiagnosticConfig();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.DiagnoseRuntimeAsync(name, diagnosticConfig);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
DiagnosticConfig diagnosticConfig = new DiagnosticConfig();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.DiagnoseRuntimeAsync(name, diagnosticConfig);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
GetRuntimeRequest request = new GetRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
};
// Make the request
Runtime response = managedNotebookServiceClient.GetRuntime(request);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Runtime response = managedNotebookServiceClient.GetRuntime(name);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Runtime response = managedNotebookServiceClient.GetRuntime(name);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetRuntimeRequest request = new GetRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
};
// Make the request
Runtime response = await managedNotebookServiceClient.GetRuntimeAsync(request);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
GetRuntimeRequest request = new GetRuntimeRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
};
// Make the request
Runtime response = await managedNotebookServiceClient.GetRuntimeAsync(request);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Runtime response = await managedNotebookServiceClient.GetRuntimeAsync(name);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Runtime response = await managedNotebookServiceClient.GetRuntimeAsync(name);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Runtime response = await managedNotebookServiceClient.GetRuntimeAsync(name);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Runtime response = await managedNotebookServiceClient.GetRuntimeAsync(name);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListRuntimesResponse, Runtime> response = managedNotebookServiceClient.ListRuntimes(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Runtime 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 (ListRuntimesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Runtime 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<Runtime> 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 (Runtime 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
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
ListRuntimesRequest request = new ListRuntimesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListRuntimesResponse, Runtime> response = managedNotebookServiceClient.ListRuntimes(request);

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Runtime 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((ListRuntimesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Runtime 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<Runtime> 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 (Runtime 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
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
ListRuntimesRequest request = new ListRuntimesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListRuntimesResponse, Runtime> response = managedNotebookServiceClient.ListRuntimesAsync(request);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Runtime 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((ListRuntimesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Runtime 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<Runtime> 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 (Runtime 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
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RefreshRuntimeTokenInternalRequest request = new RefreshRuntimeTokenInternalRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    VmId = "",
};
// Make the request
RefreshRuntimeTokenInternalResponse response = managedNotebookServiceClient.RefreshRuntimeTokenInternal(request);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
string vmId = "";
// Make the request
RefreshRuntimeTokenInternalResponse response = managedNotebookServiceClient.RefreshRuntimeTokenInternal(name, vmId);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
string vmId = "";
// Make the request
RefreshRuntimeTokenInternalResponse response = managedNotebookServiceClient.RefreshRuntimeTokenInternal(name, vmId);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RefreshRuntimeTokenInternalRequest request = new RefreshRuntimeTokenInternalRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    VmId = "",
};
// Make the request
RefreshRuntimeTokenInternalResponse response = await managedNotebookServiceClient.RefreshRuntimeTokenInternalAsync(request);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RefreshRuntimeTokenInternalRequest request = new RefreshRuntimeTokenInternalRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    VmId = "",
};
// Make the request
RefreshRuntimeTokenInternalResponse response = await managedNotebookServiceClient.RefreshRuntimeTokenInternalAsync(request);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
string vmId = "";
// Make the request
RefreshRuntimeTokenInternalResponse response = await managedNotebookServiceClient.RefreshRuntimeTokenInternalAsync(name, vmId);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
string vmId = "";
// Make the request
RefreshRuntimeTokenInternalResponse response = await managedNotebookServiceClient.RefreshRuntimeTokenInternalAsync(name, vmId);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
string vmId = "";
// Make the request
RefreshRuntimeTokenInternalResponse response = await managedNotebookServiceClient.RefreshRuntimeTokenInternalAsync(name, vmId);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
string vmId = "";
// Make the request
RefreshRuntimeTokenInternalResponse response = await managedNotebookServiceClient.RefreshRuntimeTokenInternalAsync(name, vmId);

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
ReportRuntimeEventRequest request = new ReportRuntimeEventRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    VmId = "",
    Event = new Event(),
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.ReportRuntimeEvent(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.ReportRuntimeEvent(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.ReportRuntimeEvent(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
ReportRuntimeEventRequest request = new ReportRuntimeEventRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    VmId = "",
    Event = new Event(),
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ReportRuntimeEventAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
ReportRuntimeEventRequest request = new ReportRuntimeEventRequest
{
    RuntimeName = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]"),
    VmId = "",
    Event = new Event(),
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ReportRuntimeEventAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ReportRuntimeEventAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
RuntimeName name = RuntimeName.FromProjectLocationRuntime("[PROJECT]", "[LOCATION]", "[RUNTIME]");
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ReportRuntimeEventAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ReportRuntimeEventAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/runtimes/[RUNTIME]";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ReportRuntimeEventAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
ResetRuntimeRequest request = new ResetRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.ResetRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.ResetRuntime(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
ResetRuntimeRequest request = new ResetRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ResetRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
ResetRuntimeRequest request = new ResetRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ResetRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ResetRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.ResetRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
StartRuntimeRequest request = new StartRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.StartRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.StartRuntime(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
StartRuntimeRequest request = new StartRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StartRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
StartRuntimeRequest request = new StartRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StartRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StartRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StartRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
StopRuntimeRequest request = new StopRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.StopRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.StopRuntime(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
StopRuntimeRequest request = new StopRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StopRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
StopRuntimeRequest request = new StopRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StopRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StopRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.StopRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
SwitchRuntimeRequest request = new SwitchRuntimeRequest
{
    Name = "",
    MachineType = "",
    AcceleratorConfig = new RuntimeAcceleratorConfig(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.SwitchRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.SwitchRuntime(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
SwitchRuntimeRequest request = new SwitchRuntimeRequest
{
    Name = "",
    MachineType = "",
    AcceleratorConfig = new RuntimeAcceleratorConfig(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.SwitchRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
SwitchRuntimeRequest request = new SwitchRuntimeRequest
{
    Name = "",
    MachineType = "",
    AcceleratorConfig = new RuntimeAcceleratorConfig(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.SwitchRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.SwitchRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.SwitchRuntimeAsync(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
Runtime runtime = new Runtime();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.UpdateRuntime(runtime, updateMask);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
UpdateRuntimeRequest request = new UpdateRuntimeRequest
{
    Runtime = new Runtime(),
    UpdateMask = new FieldMask(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.UpdateRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
Runtime runtime = new Runtime();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpdateRuntimeAsync(runtime, updateMask);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
Runtime runtime = new Runtime();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpdateRuntimeAsync(runtime, updateMask);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRuntimeRequest request = new UpdateRuntimeRequest
{
    Runtime = new Runtime(),
    UpdateMask = new FieldMask(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpdateRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateRuntimeRequest request = new UpdateRuntimeRequest
{
    Runtime = new Runtime(),
    UpdateMask = new FieldMask(),
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpdateRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
UpgradeRuntimeRequest request = new UpgradeRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.UpgradeRuntime(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = ManagedNotebookServiceClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = managedNotebookServiceClient.UpgradeRuntime(name);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
UpgradeRuntimeRequest request = new UpgradeRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpgradeRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
UpgradeRuntimeRequest request = new UpgradeRuntimeRequest
{
    Name = "",
    RequestId = "",
};
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpgradeRuntimeAsync(request);

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

// Create client
ManagedNotebookServiceClient managedNotebookServiceClient = await ManagedNotebookServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Runtime, OperationMetadata> response = await managedNotebookServiceClient.UpgradeRuntimeAsync(name);

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